drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

   1 /* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
   2 /* Copyright (c) 2018 Mellanox Technologies. */
   3
   4 #include <net/vxlan.h>
   5 #include <net/gre.h>
   6 #include "lib/vxlan.h"
   7 #include "en/tc_tun.h"
   8
   9 static int get_route_and_out_devs(struct mlx5e_priv *priv,
  10                                   struct net_device *dev,
  11                                   struct net_device **route_dev,
  12                                   struct net_device **out_dev)
  13 {
  14         struct net_device *uplink_dev, *uplink_upper, *real_dev;
  15         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
  16         bool dst_is_lag_dev;
  17
  18         real_dev = is_vlan_dev(dev) ? vlan_dev_real_dev(dev) : dev;
  19         uplink_dev = mlx5_eswitch_uplink_get_proto_dev(esw, REP_ETH);
  20         uplink_upper = netdev_master_upper_dev_get(uplink_dev);
  21         dst_is_lag_dev = (uplink_upper &&
  22                           netif_is_lag_master(uplink_upper) &&
  23                           real_dev == uplink_upper &&
  24                           mlx5_lag_is_sriov(priv->mdev));
  25
  26         /* if the egress device isn't on the same HW e-switch or
  27          * it's a LAG device, use the uplink
  28          */
  29         if (!netdev_port_same_parent_id(priv->netdev, real_dev) ||
  30             dst_is_lag_dev) {
  31                 *route_dev = dev;
  32                 *out_dev = uplink_dev;
  33         } else {
  34                 *route_dev = dev;
  35                 if (is_vlan_dev(*route_dev))
  36                         *out_dev = uplink_dev;
  37                 else if (mlx5e_eswitch_rep(dev))
  38                         *out_dev = *route_dev;
  39                 else
  40                         return -EOPNOTSUPP;
  41         }
  42
  43         if (!(mlx5e_eswitch_rep(*out_dev) &&
  44               mlx5e_is_uplink_rep(netdev_priv(*out_dev))))
  45                 return -EOPNOTSUPP;
  46
  47         return 0;
  48 }
  49
  50 static int mlx5e_route_lookup_ipv4(struct mlx5e_priv *priv,
  51                                    struct net_device *mirred_dev,
  52                                    struct net_device **out_dev,
  53                                    struct net_device **route_dev,
  54                                    struct flowi4 *fl4,
  55                                    struct neighbour **out_n,
  56                                    u8 *out_ttl)
  57 {
  58         struct rtable *rt;
  59         struct neighbour *n = NULL;
  60
  61 #if IS_ENABLED(CONFIG_INET)
  62         struct mlx5_core_dev *mdev = priv->mdev;
  63         struct net_device *uplink_dev;
  64         int ret;
  65
  66         if (mlx5_lag_is_multipath(mdev)) {
  67                 struct mlx5_eswitch *esw = mdev->priv.eswitch;
  68
  69                 uplink_dev = mlx5_eswitch_uplink_get_proto_dev(esw, REP_ETH);
  70                 fl4->flowi4_oif = uplink_dev->ifindex;
  71         }
  72
  73         rt = ip_route_output_key(dev_net(mirred_dev), fl4);
  74         ret = PTR_ERR_OR_ZERO(rt);
  75         if (ret)
  76                 return ret;
  77
  78         if (mlx5_lag_is_multipath(mdev) && rt->rt_gw_family != AF_INET)
  79                 return -ENETUNREACH;
  80 #else
  81         return -EOPNOTSUPP;
  82 #endif
  83
  84         ret = get_route_and_out_devs(priv, rt->dst.dev, route_dev, out_dev);
  85         if (ret < 0)
  86                 return ret;
  87
  88         if (!(*out_ttl))
  89                 *out_ttl = ip4_dst_hoplimit(&rt->dst);
  90         n = dst_neigh_lookup(&rt->dst, &fl4->daddr);
  91         ip_rt_put(rt);
  92         if (!n)
  93                 return -ENOMEM;
  94
  95         *out_n = n;
  96         return 0;
  97 }
  98
  99 static const char *mlx5e_netdev_kind(struct net_device *dev)
 100 {
 101         if (dev->rtnl_link_ops)
 102                 return dev->rtnl_link_ops->kind;
 103         else
 104                 return "unknown";
 105 }
 106
 107 static int mlx5e_route_lookup_ipv6(struct mlx5e_priv *priv,
 108                                    struct net_device *mirred_dev,
 109                                    struct net_device **out_dev,
 110                                    struct net_device **route_dev,
 111                                    struct flowi6 *fl6,
 112                                    struct neighbour **out_n,
 113                                    u8 *out_ttl)
 114 {
 115         struct neighbour *n = NULL;
 116         struct dst_entry *dst;
 117
 118 #if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6)
 119         int ret;
 120
 121         ret = ipv6_stub->ipv6_dst_lookup(dev_net(mirred_dev), NULL, &dst,
 122                                          fl6);
 123         if (ret < 0)
 124                 return ret;
 125
 126         if (!(*out_ttl))
 127                 *out_ttl = ip6_dst_hoplimit(dst);
 128
 129         ret = get_route_and_out_devs(priv, dst->dev, route_dev, out_dev);
 130         if (ret < 0)
 131                 return ret;
 132 #else
 133         return -EOPNOTSUPP;
 134 #endif
 135
 136         n = dst_neigh_lookup(dst, &fl6->daddr);
 137         dst_release(dst);
 138         if (!n)
 139                 return -ENOMEM;
 140
 141         *out_n = n;
 142         return 0;
 143 }
 144
 145 static int mlx5e_gen_vxlan_header(char buf[], struct ip_tunnel_key *tun_key)
 146 {
 147         __be32 tun_id = tunnel_id_to_key32(tun_key->tun_id);
 148         struct udphdr *udp = (struct udphdr *)(buf);
 149         struct vxlanhdr *vxh = (struct vxlanhdr *)
 150                                ((char *)udp + sizeof(struct udphdr));
 151
 152         udp->dest = tun_key->tp_dst;
 153         vxh->vx_flags = VXLAN_HF_VNI;
 154         vxh->vx_vni = vxlan_vni_field(tun_id);
 155
 156         return 0;
 157 }
 158
 159 static int mlx5e_gen_gre_header(char buf[], struct ip_tunnel_key *tun_key)
 160 {
 161         __be32 tun_id = tunnel_id_to_key32(tun_key->tun_id);
 162         int hdr_len;
 163         struct gre_base_hdr *greh = (struct gre_base_hdr *)(buf);
 164
 165         /* the HW does not calculate GRE csum or sequences */
 166         if (tun_key->tun_flags & (TUNNEL_CSUM | TUNNEL_SEQ))
 167                 return -EOPNOTSUPP;
 168
 169         greh->protocol = htons(ETH_P_TEB);
 170
 171         /* GRE key */
 172         hdr_len = gre_calc_hlen(tun_key->tun_flags);
 173         greh->flags = gre_tnl_flags_to_gre_flags(tun_key->tun_flags);
 174         if (tun_key->tun_flags & TUNNEL_KEY) {
 175                 __be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4);
 176
 177                 *ptr = tun_id;
 178         }
 179
 180         return 0;
 181 }
 182
 183 static int mlx5e_gen_ip_tunnel_header(char buf[], __u8 *ip_proto,
 184                                       struct mlx5e_encap_entry *e)
 185 {
 186         int err = 0;
 187         struct ip_tunnel_key *key = &e->tun_info.key;
 188
 189         if (e->tunnel_type == MLX5E_TC_TUNNEL_TYPE_VXLAN) {
 190                 *ip_proto = IPPROTO_UDP;
 191                 err = mlx5e_gen_vxlan_header(buf, key);
 192         } else if  (e->tunnel_type == MLX5E_TC_TUNNEL_TYPE_GRETAP) {
 193                 *ip_proto = IPPROTO_GRE;
 194                 err = mlx5e_gen_gre_header(buf, key);
 195         } else {
 196                 pr_warn("mlx5: Cannot generate tunnel header for tunnel type (%d)\n"
 197                         , e->tunnel_type);
 198                 err = -EOPNOTSUPP;
 199         }
 200
 201         return err;
 202 }
 203
 204 static char *gen_eth_tnl_hdr(char *buf, struct net_device *dev,
 205                              struct mlx5e_encap_entry *e,
 206                              u16 proto)
 207 {
 208         struct ethhdr *eth = (struct ethhdr *)buf;
 209         char *ip;
 210
 211         ether_addr_copy(eth->h_dest, e->h_dest);
 212         ether_addr_copy(eth->h_source, dev->dev_addr);
 213         if (is_vlan_dev(dev)) {
 214                 struct vlan_hdr *vlan = (struct vlan_hdr *)
 215                                         ((char *)eth + ETH_HLEN);
 216                 ip = (char *)vlan + VLAN_HLEN;
 217                 eth->h_proto = vlan_dev_vlan_proto(dev);
 218                 vlan->h_vlan_TCI = htons(vlan_dev_vlan_id(dev));
 219                 vlan->h_vlan_encapsulated_proto = htons(proto);
 220         } else {
 221                 eth->h_proto = htons(proto);
 222                 ip = (char *)eth + ETH_HLEN;
 223         }
 224
 225         return ip;
 226 }
 227
 228 int mlx5e_tc_tun_create_header_ipv4(struct mlx5e_priv *priv,
 229                                     struct net_device *mirred_dev,
 230                                     struct mlx5e_encap_entry *e)
 231 {
 232         int max_encap_size = MLX5_CAP_ESW(priv->mdev, max_encap_header_size);
 233         struct ip_tunnel_key *tun_key = &e->tun_info.key;
 234         struct net_device *out_dev, *route_dev;
 235         struct neighbour *n = NULL;
 236         struct flowi4 fl4 = {};
 237         int ipv4_encap_size;
 238         char *encap_header;
 239         u8 nud_state, ttl;
 240         struct iphdr *ip;
 241         int err;
 242
 243         /* add the IP fields */
 244         fl4.flowi4_tos = tun_key->tos;
 245         fl4.daddr = tun_key->u.ipv4.dst;
 246         fl4.saddr = tun_key->u.ipv4.src;
 247         ttl = tun_key->ttl;
 248
 249         err = mlx5e_route_lookup_ipv4(priv, mirred_dev, &out_dev, &route_dev,
 250                                       &fl4, &n, &ttl);
 251         if (err)
 252                 return err;
 253
 254         ipv4_encap_size =
 255                 (is_vlan_dev(route_dev) ? VLAN_ETH_HLEN : ETH_HLEN) +
 256                 sizeof(struct iphdr) +
 257                 e->tunnel_hlen;
 258
 259         if (max_encap_size < ipv4_encap_size) {
 260                 mlx5_core_warn(priv->mdev, "encap size %d too big, max supported is %d\n",
 261                                ipv4_encap_size, max_encap_size);
 262                 return -EOPNOTSUPP;
 263         }
 264
 265         encap_header = kzalloc(ipv4_encap_size, GFP_KERNEL);
 266         if (!encap_header)
 267                 return -ENOMEM;
 268
 269         /* used by mlx5e_detach_encap to lookup a neigh hash table
 270          * entry in the neigh hash table when a user deletes a rule
 271          */
 272         e->m_neigh.dev = n->dev;
 273         e->m_neigh.family = n->ops->family;
 274         memcpy(&e->m_neigh.dst_ip, n->primary_key, n->tbl->key_len);
 275         e->out_dev = out_dev;
 276         e->route_dev = route_dev;
 277
 278         /* It's important to add the neigh to the hash table before checking
 279          * the neigh validity state. So if we'll get a notification, in case the
 280          * neigh changes it's validity state, we would find the relevant neigh
 281          * in the hash.
 282          */
 283         err = mlx5e_rep_encap_entry_attach(netdev_priv(out_dev), e);
 284         if (err)
 285                 goto free_encap;
 286
 287         read_lock_bh(&n->lock);
 288         nud_state = n->nud_state;
 289         ether_addr_copy(e->h_dest, n->ha);
 290         read_unlock_bh(&n->lock);
 291
 292         /* add ethernet header */
 293         ip = (struct iphdr *)gen_eth_tnl_hdr(encap_header, route_dev, e,
 294                                              ETH_P_IP);
 295
 296         /* add ip header */
 297         ip->tos = tun_key->tos;
 298         ip->version = 0x4;
 299         ip->ihl = 0x5;
 300         ip->ttl = ttl;
 301         ip->daddr = fl4.daddr;
 302         ip->saddr = fl4.saddr;
 303
 304         /* add tunneling protocol header */
 305         err = mlx5e_gen_ip_tunnel_header((char *)ip + sizeof(struct iphdr),
 306                                          &ip->protocol, e);
 307         if (err)
 308                 goto destroy_neigh_entry;
 309
 310         e->encap_size = ipv4_encap_size;
 311         e->encap_header = encap_header;
 312
 313         if (!(nud_state & NUD_VALID)) {
 314                 neigh_event_send(n, NULL);
 315                 /* the encap entry will be made valid on neigh update event
 316                  * and not used before that.
 317                  */
 318                 goto out;
 319         }
 320
 321         err = mlx5_packet_reformat_alloc(priv->mdev,
 322                                          e->reformat_type,
 323                                          ipv4_encap_size, encap_header,
 324                                          MLX5_FLOW_NAMESPACE_FDB,
 325                                          &e->encap_id);
 326         if (err)
 327                 goto destroy_neigh_entry;
 328
 329         e->flags |= MLX5_ENCAP_ENTRY_VALID;
 330         mlx5e_rep_queue_neigh_stats_work(netdev_priv(out_dev));
 331         neigh_release(n);
 332         return err;
 333
 334 destroy_neigh_entry:
 335         mlx5e_rep_encap_entry_detach(netdev_priv(e->out_dev), e);
 336 free_encap:
 337         kfree(encap_header);
 338 out:
 339         if (n)
 340                 neigh_release(n);
 341         return err;
 342 }
 343
 344 int mlx5e_tc_tun_create_header_ipv6(struct mlx5e_priv *priv,
 345                                     struct net_device *mirred_dev,
 346                                     struct mlx5e_encap_entry *e)
 347 {
 348         int max_encap_size = MLX5_CAP_ESW(priv->mdev, max_encap_header_size);
 349         struct ip_tunnel_key *tun_key = &e->tun_info.key;
 350         struct net_device *out_dev, *route_dev;
 351         struct neighbour *n = NULL;
 352         struct flowi6 fl6 = {};
 353         struct ipv6hdr *ip6h;
 354         int ipv6_encap_size;
 355         char *encap_header;
 356         u8 nud_state, ttl;
 357         int err;
 358
 359         ttl = tun_key->ttl;
 360
 361         fl6.flowlabel = ip6_make_flowinfo(RT_TOS(tun_key->tos), tun_key->label);
 362         fl6.daddr = tun_key->u.ipv6.dst;
 363         fl6.saddr = tun_key->u.ipv6.src;
 364
 365         err = mlx5e_route_lookup_ipv6(priv, mirred_dev, &out_dev, &route_dev,
 366                                       &fl6, &n, &ttl);
 367         if (err)
 368                 return err;
 369
 370         ipv6_encap_size =
 371                 (is_vlan_dev(route_dev) ? VLAN_ETH_HLEN : ETH_HLEN) +
 372                 sizeof(struct ipv6hdr) +
 373                 e->tunnel_hlen;
 374
 375         if (max_encap_size < ipv6_encap_size) {
 376                 mlx5_core_warn(priv->mdev, "encap size %d too big, max supported is %d\n",
 377                                ipv6_encap_size, max_encap_size);
 378                 return -EOPNOTSUPP;
 379         }
 380
 381         encap_header = kzalloc(ipv6_encap_size, GFP_KERNEL);
 382         if (!encap_header)
 383                 return -ENOMEM;
 384
 385         /* used by mlx5e_detach_encap to lookup a neigh hash table
 386          * entry in the neigh hash table when a user deletes a rule
 387          */
 388         e->m_neigh.dev = n->dev;
 389         e->m_neigh.family = n->ops->family;
 390         memcpy(&e->m_neigh.dst_ip, n->primary_key, n->tbl->key_len);
 391         e->out_dev = out_dev;
 392         e->route_dev = route_dev;
 393
 394         /* It's importent to add the neigh to the hash table before checking
 395          * the neigh validity state. So if we'll get a notification, in case the
 396          * neigh changes it's validity state, we would find the relevant neigh
 397          * in the hash.
 398          */
 399         err = mlx5e_rep_encap_entry_attach(netdev_priv(out_dev), e);
 400         if (err)
 401                 goto free_encap;
 402
 403         read_lock_bh(&n->lock);
 404         nud_state = n->nud_state;
 405         ether_addr_copy(e->h_dest, n->ha);
 406         read_unlock_bh(&n->lock);
 407
 408         /* add ethernet header */
 409         ip6h = (struct ipv6hdr *)gen_eth_tnl_hdr(encap_header, route_dev, e,
 410                                                  ETH_P_IPV6);
 411
 412         /* add ip header */
 413         ip6_flow_hdr(ip6h, tun_key->tos, 0);
 414         /* the HW fills up ipv6 payload len */
 415         ip6h->hop_limit   = ttl;
 416         ip6h->daddr       = fl6.daddr;
 417         ip6h->saddr       = fl6.saddr;
 418
 419         /* add tunneling protocol header */
 420         err = mlx5e_gen_ip_tunnel_header((char *)ip6h + sizeof(struct ipv6hdr),
 421                                          &ip6h->nexthdr, e);
 422         if (err)
 423                 goto destroy_neigh_entry;
 424
 425         e->encap_size = ipv6_encap_size;
 426         e->encap_header = encap_header;
 427
 428         if (!(nud_state & NUD_VALID)) {
 429                 neigh_event_send(n, NULL);
 430                 /* the encap entry will be made valid on neigh update event
 431                  * and not used before that.
 432                  */
 433                 goto out;
 434         }
 435
 436         err = mlx5_packet_reformat_alloc(priv->mdev,
 437                                          e->reformat_type,
 438                                          ipv6_encap_size, encap_header,
 439                                          MLX5_FLOW_NAMESPACE_FDB,
 440                                          &e->encap_id);
 441         if (err)
 442                 goto destroy_neigh_entry;
 443
 444         e->flags |= MLX5_ENCAP_ENTRY_VALID;
 445         mlx5e_rep_queue_neigh_stats_work(netdev_priv(out_dev));
 446         neigh_release(n);
 447         return err;
 448
 449 destroy_neigh_entry:
 450         mlx5e_rep_encap_entry_detach(netdev_priv(e->out_dev), e);
 451 free_encap:
 452         kfree(encap_header);
 453 out:
 454         if (n)
 455                 neigh_release(n);
 456         return err;
 457 }
 458
 459 int mlx5e_tc_tun_get_type(struct net_device *tunnel_dev)
 460 {
 461         if (netif_is_vxlan(tunnel_dev))
 462                 return MLX5E_TC_TUNNEL_TYPE_VXLAN;
 463         else if (netif_is_gretap(tunnel_dev) ||
 464                  netif_is_ip6gretap(tunnel_dev))
 465                 return MLX5E_TC_TUNNEL_TYPE_GRETAP;
 466         else
 467                 return MLX5E_TC_TUNNEL_TYPE_UNKNOWN;
 468 }
 469
 470 bool mlx5e_tc_tun_device_to_offload(struct mlx5e_priv *priv,
 471                                     struct net_device *netdev)
 472 {
 473         int tunnel_type = mlx5e_tc_tun_get_type(netdev);
 474
 475         if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_VXLAN &&
 476             MLX5_CAP_ESW(priv->mdev, vxlan_encap_decap))
 477                 return true;
 478         else if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_GRETAP &&
 479                  MLX5_CAP_ESW(priv->mdev, nvgre_encap_decap))
 480                 return true;
 481         else
 482                 return false;
 483 }
 484
 485 int mlx5e_tc_tun_init_encap_attr(struct net_device *tunnel_dev,
 486                                  struct mlx5e_priv *priv,
 487                                  struct mlx5e_encap_entry *e,
 488                                  struct netlink_ext_ack *extack)
 489 {
 490         e->tunnel_type = mlx5e_tc_tun_get_type(tunnel_dev);
 491
 492         if (e->tunnel_type == MLX5E_TC_TUNNEL_TYPE_VXLAN) {
 493                 int dst_port =  be16_to_cpu(e->tun_info.key.tp_dst);
 494
 495                 if (!mlx5_vxlan_lookup_port(priv->mdev->vxlan, dst_port)) {
 496                         NL_SET_ERR_MSG_MOD(extack,
 497                                            "vxlan udp dport was not registered with the HW");
 498                         netdev_warn(priv->netdev,
 499                                     "%d isn't an offloaded vxlan udp dport\n",
 500                                     dst_port);
 501                         return -EOPNOTSUPP;
 502                 }
 503                 e->reformat_type = MLX5_REFORMAT_TYPE_L2_TO_VXLAN;
 504                 e->tunnel_hlen = VXLAN_HLEN;
 505         } else if (e->tunnel_type == MLX5E_TC_TUNNEL_TYPE_GRETAP) {
 506                 e->reformat_type = MLX5_REFORMAT_TYPE_L2_TO_NVGRE;
 507                 e->tunnel_hlen = gre_calc_hlen(e->tun_info.key.tun_flags);
 508         } else {
 509                 e->reformat_type = -1;
 510                 e->tunnel_hlen = -1;
 511                 return -EOPNOTSUPP;
 512         }
 513         return 0;
 514 }
 515
 516 static int mlx5e_tc_tun_parse_vxlan(struct mlx5e_priv *priv,
 517                                     struct mlx5_flow_spec *spec,
 518                                     struct tc_cls_flower_offload *f,
 519                                     void *headers_c,
 520                                     void *headers_v)
 521 {
 522         struct flow_rule *rule = tc_cls_flower_offload_flow_rule(f);
 523         struct netlink_ext_ack *extack = f->common.extack;
 524         void *misc_c = MLX5_ADDR_OF(fte_match_param,
 525                                     spec->match_criteria,
 526                                     misc_parameters);
 527         void *misc_v = MLX5_ADDR_OF(fte_match_param,
 528                                     spec->match_value,
 529                                     misc_parameters);
 530         struct flow_match_ports enc_ports;
 531
 532         flow_rule_match_enc_ports(rule, &enc_ports);
 533
 534         /* Full udp dst port must be given */
 535         if (!flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_PORTS) ||
 536             memchr_inv(&enc_ports.mask->dst, 0xff, sizeof(enc_ports.mask->dst))) {
 537                 NL_SET_ERR_MSG_MOD(extack,
 538                                    "VXLAN decap filter must include enc_dst_port condition");
 539                 netdev_warn(priv->netdev,
 540                             "VXLAN decap filter must include enc_dst_port condition\n");
 541                 return -EOPNOTSUPP;
 542         }
 543
 544         /* udp dst port must be knonwn as a VXLAN port */
 545         if (!mlx5_vxlan_lookup_port(priv->mdev->vxlan, be16_to_cpu(enc_ports.key->dst))) {
 546                 NL_SET_ERR_MSG_MOD(extack,
 547                                    "Matched UDP port is not registered as a VXLAN port");
 548                 netdev_warn(priv->netdev,
 549                             "UDP port %d is not registered as a VXLAN port\n",
 550                             be16_to_cpu(enc_ports.key->dst));
 551                 return -EOPNOTSUPP;
 552         }
 553
 554         /* dst UDP port is valid here */
 555         MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, headers_c, ip_protocol);
 556         MLX5_SET(fte_match_set_lyr_2_4, headers_v, ip_protocol, IPPROTO_UDP);
 557
 558         MLX5_SET(fte_match_set_lyr_2_4, headers_c, udp_dport,
 559                  ntohs(enc_ports.mask->dst));
 560         MLX5_SET(fte_match_set_lyr_2_4, headers_v, udp_dport,
 561                  ntohs(enc_ports.key->dst));
 562
 563         MLX5_SET(fte_match_set_lyr_2_4, headers_c, udp_sport,
 564                  ntohs(enc_ports.mask->src));
 565         MLX5_SET(fte_match_set_lyr_2_4, headers_v, udp_sport,
 566                  ntohs(enc_ports.key->src));
 567
 568         /* match on VNI */
 569         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID)) {
 570                 struct flow_match_enc_keyid enc_keyid;
 571
 572                 flow_rule_match_enc_keyid(rule, &enc_keyid);
 573
 574                 MLX5_SET(fte_match_set_misc, misc_c, vxlan_vni,
 575                          be32_to_cpu(enc_keyid.mask->keyid));
 576                 MLX5_SET(fte_match_set_misc, misc_v, vxlan_vni,
 577                          be32_to_cpu(enc_keyid.key->keyid));
 578         }
 579         return 0;
 580 }
 581
 582 static int mlx5e_tc_tun_parse_gretap(struct mlx5e_priv *priv,
 583                                      struct mlx5_flow_spec *spec,
 584                                      struct tc_cls_flower_offload *f,
 585                                      void *outer_headers_c,
 586                                      void *outer_headers_v)
 587 {
 588         void *misc_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
 589                                     misc_parameters);
 590         void *misc_v = MLX5_ADDR_OF(fte_match_param, spec->match_value,
 591                                     misc_parameters);
 592         struct flow_rule *rule = tc_cls_flower_offload_flow_rule(f);
 593
 594         if (!MLX5_CAP_ESW(priv->mdev, nvgre_encap_decap)) {
 595                 NL_SET_ERR_MSG_MOD(f->common.extack,
 596                                    "GRE HW offloading is not supported");
 597                 netdev_warn(priv->netdev, "GRE HW offloading is not supported\n");
 598                 return -EOPNOTSUPP;
 599         }
 600
 601         MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, outer_headers_c, ip_protocol);
 602         MLX5_SET(fte_match_set_lyr_2_4, outer_headers_v,
 603                  ip_protocol, IPPROTO_GRE);
 604
 605         /* gre protocol*/
 606         MLX5_SET_TO_ONES(fte_match_set_misc, misc_c, gre_protocol);
 607         MLX5_SET(fte_match_set_misc, misc_v, gre_protocol, ETH_P_TEB);
 608
 609         /* gre key */
 610         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID)) {
 611                 struct flow_match_enc_keyid enc_keyid;
 612
 613                 flow_rule_match_enc_keyid(rule, &enc_keyid);
 614                 MLX5_SET(fte_match_set_misc, misc_c,
 615                          gre_key.key, be32_to_cpu(enc_keyid.mask->keyid));
 616                 MLX5_SET(fte_match_set_misc, misc_v,
 617                          gre_key.key, be32_to_cpu(enc_keyid.key->keyid));
 618         }
 619
 620         return 0;
 621 }
 622
 623 int mlx5e_tc_tun_parse(struct net_device *filter_dev,
 624                        struct mlx5e_priv *priv,
 625                        struct mlx5_flow_spec *spec,
 626                        struct tc_cls_flower_offload *f,
 627                        void *headers_c,
 628                        void *headers_v, u8 *match_level)
 629 {
 630         int tunnel_type;
 631         int err = 0;
 632
 633         tunnel_type = mlx5e_tc_tun_get_type(filter_dev);
 634         if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_VXLAN) {
 635                 *match_level = MLX5_MATCH_L4;
 636                 err = mlx5e_tc_tun_parse_vxlan(priv, spec, f,
 637                                                headers_c, headers_v);
 638         } else if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_GRETAP) {
 639                 *match_level = MLX5_MATCH_L3;
 640                 err = mlx5e_tc_tun_parse_gretap(priv, spec, f,
 641                                                 headers_c, headers_v);
 642         } else {
 643                 netdev_warn(priv->netdev,
 644                             "decapsulation offload is not supported for %s (kind: \"%s\")\n",
 645                             netdev_name(filter_dev),
 646                             mlx5e_netdev_kind(filter_dev));
 647
 648                 return -EOPNOTSUPP;
 649         }
 650         return err;
 651 }