Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Oz Shlomo | 2569 | 81.37% | 2 | 16.67% |
Eli Britstein | 514 | 16.28% | 6 | 50.00% |
Rabie Loulou | 47 | 1.49% | 1 | 8.33% |
Or Gerlitz | 14 | 0.44% | 1 | 8.33% |
Tonghao Zhang | 12 | 0.38% | 1 | 8.33% |
Aviv Heller | 1 | 0.03% | 1 | 8.33% |
Total | 3157 | 12 |
/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */ /* Copyright (c) 2018 Mellanox Technologies. */ #include <net/vxlan.h> #include <net/gre.h> #include "lib/vxlan.h" #include "en/tc_tun.h" static int get_route_and_out_devs(struct mlx5e_priv *priv, struct net_device *dev, struct net_device **route_dev, struct net_device **out_dev) { struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; struct net_device *uplink_dev, *uplink_upper; bool dst_is_lag_dev; uplink_dev = mlx5_eswitch_uplink_get_proto_dev(esw, REP_ETH); uplink_upper = netdev_master_upper_dev_get(uplink_dev); dst_is_lag_dev = (uplink_upper && netif_is_lag_master(uplink_upper) && dev == uplink_upper && mlx5_lag_is_sriov(priv->mdev)); /* if the egress device isn't on the same HW e-switch or * it's a LAG device, use the uplink */ if (!switchdev_port_same_parent_id(priv->netdev, dev) || dst_is_lag_dev) { *route_dev = uplink_dev; *out_dev = *route_dev; } else { *route_dev = dev; if (is_vlan_dev(*route_dev)) *out_dev = uplink_dev; else if (mlx5e_eswitch_rep(dev)) *out_dev = *route_dev; else return -EOPNOTSUPP; } return 0; } static int mlx5e_route_lookup_ipv4(struct mlx5e_priv *priv, struct net_device *mirred_dev, struct net_device **out_dev, struct net_device **route_dev, struct flowi4 *fl4, struct neighbour **out_n, u8 *out_ttl) { struct rtable *rt; struct neighbour *n = NULL; #if IS_ENABLED(CONFIG_INET) int ret; rt = ip_route_output_key(dev_net(mirred_dev), fl4); ret = PTR_ERR_OR_ZERO(rt); if (ret) return ret; #else return -EOPNOTSUPP; #endif ret = get_route_and_out_devs(priv, rt->dst.dev, route_dev, out_dev); if (ret < 0) return ret; if (!(*out_ttl)) *out_ttl = ip4_dst_hoplimit(&rt->dst); n = dst_neigh_lookup(&rt->dst, &fl4->daddr); ip_rt_put(rt); if (!n) return -ENOMEM; *out_n = n; return 0; } static const char *mlx5e_netdev_kind(struct net_device *dev) { if (dev->rtnl_link_ops) return dev->rtnl_link_ops->kind; else return ""; } static int mlx5e_route_lookup_ipv6(struct mlx5e_priv *priv, struct net_device *mirred_dev, struct net_device **out_dev, struct net_device **route_dev, struct flowi6 *fl6, struct neighbour **out_n, u8 *out_ttl) { struct neighbour *n = NULL; struct dst_entry *dst; #if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6) int ret; ret = ipv6_stub->ipv6_dst_lookup(dev_net(mirred_dev), NULL, &dst, fl6); if (ret < 0) return ret; if (!(*out_ttl)) *out_ttl = ip6_dst_hoplimit(dst); ret = get_route_and_out_devs(priv, dst->dev, route_dev, out_dev); if (ret < 0) return ret; #else return -EOPNOTSUPP; #endif n = dst_neigh_lookup(dst, &fl6->daddr); dst_release(dst); if (!n) return -ENOMEM; *out_n = n; return 0; } static int mlx5e_gen_vxlan_header(char buf[], struct ip_tunnel_key *tun_key) { __be32 tun_id = tunnel_id_to_key32(tun_key->tun_id); struct udphdr *udp = (struct udphdr *)(buf); struct vxlanhdr *vxh = (struct vxlanhdr *) ((char *)udp + sizeof(struct udphdr)); udp->dest = tun_key->tp_dst; vxh->vx_flags = VXLAN_HF_VNI; vxh->vx_vni = vxlan_vni_field(tun_id); return 0; } static int mlx5e_gen_gre_header(char buf[], struct ip_tunnel_key *tun_key) { __be32 tun_id = tunnel_id_to_key32(tun_key->tun_id); int hdr_len; struct gre_base_hdr *greh = (struct gre_base_hdr *)(buf); /* the HW does not calculate GRE csum or sequences */ if (tun_key->tun_flags & (TUNNEL_CSUM | TUNNEL_SEQ)) return -EOPNOTSUPP; greh->protocol = htons(ETH_P_TEB); /* GRE key */ hdr_len = gre_calc_hlen(tun_key->tun_flags); greh->flags = gre_tnl_flags_to_gre_flags(tun_key->tun_flags); if (tun_key->tun_flags & TUNNEL_KEY) { __be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4); *ptr = tun_id; } return 0; } static int mlx5e_gen_ip_tunnel_header(char buf[], __u8 *ip_proto, struct mlx5e_encap_entry *e) { int err = 0; struct ip_tunnel_key *key = &e->tun_info.key; if (e->tunnel_type == MLX5E_TC_TUNNEL_TYPE_VXLAN) { *ip_proto = IPPROTO_UDP; err = mlx5e_gen_vxlan_header(buf, key); } else if (e->tunnel_type == MLX5E_TC_TUNNEL_TYPE_GRETAP) { *ip_proto = IPPROTO_GRE; err = mlx5e_gen_gre_header(buf, key); } else { pr_warn("mlx5: Cannot generate tunnel header for tunnel type (%d)\n" , e->tunnel_type); err = -EOPNOTSUPP; } return err; } static char *gen_eth_tnl_hdr(char *buf, struct net_device *dev, struct mlx5e_encap_entry *e, u16 proto) { struct ethhdr *eth = (struct ethhdr *)buf; char *ip; ether_addr_copy(eth->h_dest, e->h_dest); ether_addr_copy(eth->h_source, dev->dev_addr); if (is_vlan_dev(dev)) { struct vlan_hdr *vlan = (struct vlan_hdr *) ((char *)eth + ETH_HLEN); ip = (char *)vlan + VLAN_HLEN; eth->h_proto = vlan_dev_vlan_proto(dev); vlan->h_vlan_TCI = htons(vlan_dev_vlan_id(dev)); vlan->h_vlan_encapsulated_proto = htons(proto); } else { eth->h_proto = htons(proto); ip = (char *)eth + ETH_HLEN; } return ip; } int mlx5e_tc_tun_create_header_ipv4(struct mlx5e_priv *priv, struct net_device *mirred_dev, struct mlx5e_encap_entry *e) { int max_encap_size = MLX5_CAP_ESW(priv->mdev, max_encap_header_size); struct ip_tunnel_key *tun_key = &e->tun_info.key; struct net_device *out_dev, *route_dev; struct neighbour *n = NULL; struct flowi4 fl4 = {}; int ipv4_encap_size; char *encap_header; u8 nud_state, ttl; struct iphdr *ip; int err; /* add the IP fields */ fl4.flowi4_tos = tun_key->tos; fl4.daddr = tun_key->u.ipv4.dst; fl4.saddr = tun_key->u.ipv4.src; ttl = tun_key->ttl; err = mlx5e_route_lookup_ipv4(priv, mirred_dev, &out_dev, &route_dev, &fl4, &n, &ttl); if (err) return err; ipv4_encap_size = (is_vlan_dev(route_dev) ? VLAN_ETH_HLEN : ETH_HLEN) + sizeof(struct iphdr) + e->tunnel_hlen; if (max_encap_size < ipv4_encap_size) { mlx5_core_warn(priv->mdev, "encap size %d too big, max supported is %d\n", ipv4_encap_size, max_encap_size); return -EOPNOTSUPP; } encap_header = kzalloc(ipv4_encap_size, GFP_KERNEL); if (!encap_header) return -ENOMEM; /* used by mlx5e_detach_encap to lookup a neigh hash table * entry in the neigh hash table when a user deletes a rule */ e->m_neigh.dev = n->dev; e->m_neigh.family = n->ops->family; memcpy(&e->m_neigh.dst_ip, n->primary_key, n->tbl->key_len); e->out_dev = out_dev; e->route_dev = route_dev; /* It's important to add the neigh to the hash table before checking * the neigh validity state. So if we'll get a notification, in case the * neigh changes it's validity state, we would find the relevant neigh * in the hash. */ err = mlx5e_rep_encap_entry_attach(netdev_priv(out_dev), e); if (err) goto free_encap; read_lock_bh(&n->lock); nud_state = n->nud_state; ether_addr_copy(e->h_dest, n->ha); read_unlock_bh(&n->lock); /* add ethernet header */ ip = (struct iphdr *)gen_eth_tnl_hdr(encap_header, route_dev, e, ETH_P_IP); /* add ip header */ ip->tos = tun_key->tos; ip->version = 0x4; ip->ihl = 0x5; ip->ttl = ttl; ip->daddr = fl4.daddr; ip->saddr = fl4.saddr; /* add tunneling protocol header */ err = mlx5e_gen_ip_tunnel_header((char *)ip + sizeof(struct iphdr), &ip->protocol, e); if (err) goto destroy_neigh_entry; e->encap_size = ipv4_encap_size; e->encap_header = encap_header; if (!(nud_state & NUD_VALID)) { neigh_event_send(n, NULL); err = -EAGAIN; goto out; } err = mlx5_packet_reformat_alloc(priv->mdev, e->reformat_type, ipv4_encap_size, encap_header, MLX5_FLOW_NAMESPACE_FDB, &e->encap_id); if (err) goto destroy_neigh_entry; e->flags |= MLX5_ENCAP_ENTRY_VALID; mlx5e_rep_queue_neigh_stats_work(netdev_priv(out_dev)); neigh_release(n); return err; destroy_neigh_entry: mlx5e_rep_encap_entry_detach(netdev_priv(e->out_dev), e); free_encap: kfree(encap_header); out: if (n) neigh_release(n); return err; } int mlx5e_tc_tun_create_header_ipv6(struct mlx5e_priv *priv, struct net_device *mirred_dev, struct mlx5e_encap_entry *e) { int max_encap_size = MLX5_CAP_ESW(priv->mdev, max_encap_header_size); struct ip_tunnel_key *tun_key = &e->tun_info.key; struct net_device *out_dev, *route_dev; struct neighbour *n = NULL; struct flowi6 fl6 = {}; struct ipv6hdr *ip6h; int ipv6_encap_size; char *encap_header; u8 nud_state, ttl; int err; ttl = tun_key->ttl; fl6.flowlabel = ip6_make_flowinfo(RT_TOS(tun_key->tos), tun_key->label); fl6.daddr = tun_key->u.ipv6.dst; fl6.saddr = tun_key->u.ipv6.src; err = mlx5e_route_lookup_ipv6(priv, mirred_dev, &out_dev, &route_dev, &fl6, &n, &ttl); if (err) return err; ipv6_encap_size = (is_vlan_dev(route_dev) ? VLAN_ETH_HLEN : ETH_HLEN) + sizeof(struct ipv6hdr) + e->tunnel_hlen; if (max_encap_size < ipv6_encap_size) { mlx5_core_warn(priv->mdev, "encap size %d too big, max supported is %d\n", ipv6_encap_size, max_encap_size); return -EOPNOTSUPP; } encap_header = kzalloc(ipv6_encap_size, GFP_KERNEL); if (!encap_header) return -ENOMEM; /* used by mlx5e_detach_encap to lookup a neigh hash table * entry in the neigh hash table when a user deletes a rule */ e->m_neigh.dev = n->dev; e->m_neigh.family = n->ops->family; memcpy(&e->m_neigh.dst_ip, n->primary_key, n->tbl->key_len); e->out_dev = out_dev; e->route_dev = route_dev; /* It's importent to add the neigh to the hash table before checking * the neigh validity state. So if we'll get a notification, in case the * neigh changes it's validity state, we would find the relevant neigh * in the hash. */ err = mlx5e_rep_encap_entry_attach(netdev_priv(out_dev), e); if (err) goto free_encap; read_lock_bh(&n->lock); nud_state = n->nud_state; ether_addr_copy(e->h_dest, n->ha); read_unlock_bh(&n->lock); /* add ethernet header */ ip6h = (struct ipv6hdr *)gen_eth_tnl_hdr(encap_header, route_dev, e, ETH_P_IPV6); /* add ip header */ ip6_flow_hdr(ip6h, tun_key->tos, 0); /* the HW fills up ipv6 payload len */ ip6h->hop_limit = ttl; ip6h->daddr = fl6.daddr; ip6h->saddr = fl6.saddr; /* add tunneling protocol header */ err = mlx5e_gen_ip_tunnel_header((char *)ip6h + sizeof(struct ipv6hdr), &ip6h->nexthdr, e); if (err) goto destroy_neigh_entry; e->encap_size = ipv6_encap_size; e->encap_header = encap_header; if (!(nud_state & NUD_VALID)) { neigh_event_send(n, NULL); err = -EAGAIN; goto out; } err = mlx5_packet_reformat_alloc(priv->mdev, e->reformat_type, ipv6_encap_size, encap_header, MLX5_FLOW_NAMESPACE_FDB, &e->encap_id); if (err) goto destroy_neigh_entry; e->flags |= MLX5_ENCAP_ENTRY_VALID; mlx5e_rep_queue_neigh_stats_work(netdev_priv(out_dev)); neigh_release(n); return err; destroy_neigh_entry: mlx5e_rep_encap_entry_detach(netdev_priv(e->out_dev), e); free_encap: kfree(encap_header); out: if (n) neigh_release(n); return err; } int mlx5e_tc_tun_get_type(struct net_device *tunnel_dev) { if (netif_is_vxlan(tunnel_dev)) return MLX5E_TC_TUNNEL_TYPE_VXLAN; else if (netif_is_gretap(tunnel_dev) || netif_is_ip6gretap(tunnel_dev)) return MLX5E_TC_TUNNEL_TYPE_GRETAP; else return MLX5E_TC_TUNNEL_TYPE_UNKNOWN; } bool mlx5e_tc_tun_device_to_offload(struct mlx5e_priv *priv, struct net_device *netdev) { int tunnel_type = mlx5e_tc_tun_get_type(netdev); if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_VXLAN && MLX5_CAP_ESW(priv->mdev, vxlan_encap_decap)) return true; else if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_GRETAP && MLX5_CAP_ESW(priv->mdev, nvgre_encap_decap)) return true; else return false; } int mlx5e_tc_tun_init_encap_attr(struct net_device *tunnel_dev, struct mlx5e_priv *priv, struct mlx5e_encap_entry *e, struct netlink_ext_ack *extack) { e->tunnel_type = mlx5e_tc_tun_get_type(tunnel_dev); if (e->tunnel_type == MLX5E_TC_TUNNEL_TYPE_VXLAN) { int dst_port = be16_to_cpu(e->tun_info.key.tp_dst); if (!mlx5_vxlan_lookup_port(priv->mdev->vxlan, dst_port)) { NL_SET_ERR_MSG_MOD(extack, "vxlan udp dport was not registered with the HW"); netdev_warn(priv->netdev, "%d isn't an offloaded vxlan udp dport\n", dst_port); return -EOPNOTSUPP; } e->reformat_type = MLX5_REFORMAT_TYPE_L2_TO_VXLAN; e->tunnel_hlen = VXLAN_HLEN; } else if (e->tunnel_type == MLX5E_TC_TUNNEL_TYPE_GRETAP) { e->reformat_type = MLX5_REFORMAT_TYPE_L2_TO_NVGRE; e->tunnel_hlen = gre_calc_hlen(e->tun_info.key.tun_flags); } else { e->reformat_type = -1; e->tunnel_hlen = -1; return -EOPNOTSUPP; } return 0; } static int mlx5e_tc_tun_parse_vxlan(struct mlx5e_priv *priv, struct mlx5_flow_spec *spec, struct tc_cls_flower_offload *f, void *headers_c, void *headers_v) { struct netlink_ext_ack *extack = f->common.extack; struct flow_dissector_key_ports *key = skb_flow_dissector_target(f->dissector, FLOW_DISSECTOR_KEY_ENC_PORTS, f->key); struct flow_dissector_key_ports *mask = skb_flow_dissector_target(f->dissector, FLOW_DISSECTOR_KEY_ENC_PORTS, f->mask); void *misc_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters); void *misc_v = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters); /* Full udp dst port must be given */ if (!dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_ENC_PORTS) || memchr_inv(&mask->dst, 0xff, sizeof(mask->dst))) { NL_SET_ERR_MSG_MOD(extack, "VXLAN decap filter must include enc_dst_port condition"); netdev_warn(priv->netdev, "VXLAN decap filter must include enc_dst_port condition\n"); return -EOPNOTSUPP; } /* udp dst port must be knonwn as a VXLAN port */ if (!mlx5_vxlan_lookup_port(priv->mdev->vxlan, be16_to_cpu(key->dst))) { NL_SET_ERR_MSG_MOD(extack, "Matched UDP port is not registered as a VXLAN port"); netdev_warn(priv->netdev, "UDP port %d is not registered as a VXLAN port\n", be16_to_cpu(key->dst)); return -EOPNOTSUPP; } /* dst UDP port is valid here */ MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, headers_c, ip_protocol); MLX5_SET(fte_match_set_lyr_2_4, headers_v, ip_protocol, IPPROTO_UDP); MLX5_SET(fte_match_set_lyr_2_4, headers_c, udp_dport, ntohs(mask->dst)); MLX5_SET(fte_match_set_lyr_2_4, headers_v, udp_dport, ntohs(key->dst)); MLX5_SET(fte_match_set_lyr_2_4, headers_c, udp_sport, ntohs(mask->src)); MLX5_SET(fte_match_set_lyr_2_4, headers_v, udp_sport, ntohs(key->src)); /* match on VNI */ if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_ENC_KEYID)) { struct flow_dissector_key_keyid *key = skb_flow_dissector_target(f->dissector, FLOW_DISSECTOR_KEY_ENC_KEYID, f->key); struct flow_dissector_key_keyid *mask = skb_flow_dissector_target(f->dissector, FLOW_DISSECTOR_KEY_ENC_KEYID, f->mask); MLX5_SET(fte_match_set_misc, misc_c, vxlan_vni, be32_to_cpu(mask->keyid)); MLX5_SET(fte_match_set_misc, misc_v, vxlan_vni, be32_to_cpu(key->keyid)); } return 0; } static int mlx5e_tc_tun_parse_gretap(struct mlx5e_priv *priv, struct mlx5_flow_spec *spec, struct tc_cls_flower_offload *f, void *outer_headers_c, void *outer_headers_v) { void *misc_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters); void *misc_v = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters); if (!MLX5_CAP_ESW(priv->mdev, nvgre_encap_decap)) { NL_SET_ERR_MSG_MOD(f->common.extack, "GRE HW offloading is not supported"); netdev_warn(priv->netdev, "GRE HW offloading is not supported\n"); return -EOPNOTSUPP; } MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, outer_headers_c, ip_protocol); MLX5_SET(fte_match_set_lyr_2_4, outer_headers_v, ip_protocol, IPPROTO_GRE); /* gre protocol*/ MLX5_SET_TO_ONES(fte_match_set_misc, misc_c, gre_protocol); MLX5_SET(fte_match_set_misc, misc_v, gre_protocol, ETH_P_TEB); /* gre key */ if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_ENC_KEYID)) { struct flow_dissector_key_keyid *mask = NULL; struct flow_dissector_key_keyid *key = NULL; mask = skb_flow_dissector_target(f->dissector, FLOW_DISSECTOR_KEY_ENC_KEYID, f->mask); MLX5_SET(fte_match_set_misc, misc_c, gre_key.key, be32_to_cpu(mask->keyid)); key = skb_flow_dissector_target(f->dissector, FLOW_DISSECTOR_KEY_ENC_KEYID, f->key); MLX5_SET(fte_match_set_misc, misc_v, gre_key.key, be32_to_cpu(key->keyid)); } return 0; } int mlx5e_tc_tun_parse(struct net_device *filter_dev, struct mlx5e_priv *priv, struct mlx5_flow_spec *spec, struct tc_cls_flower_offload *f, void *headers_c, void *headers_v, u8 *match_level) { int tunnel_type; int err = 0; tunnel_type = mlx5e_tc_tun_get_type(filter_dev); if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_VXLAN) { *match_level = MLX5_MATCH_L4; err = mlx5e_tc_tun_parse_vxlan(priv, spec, f, headers_c, headers_v); } else if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_GRETAP) { *match_level = MLX5_MATCH_L3; err = mlx5e_tc_tun_parse_gretap(priv, spec, f, headers_c, headers_v); } else { netdev_warn(priv->netdev, "decapsulation offload is not supported for %s net device (%d)\n", mlx5e_netdev_kind(filter_dev), tunnel_type); return -EOPNOTSUPP; } return err; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1