Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Pieter Jansen van Vuuren | 1559 | 77.76% | 12 | 57.14% |
John Hurley | 444 | 22.14% | 8 | 38.10% |
Jakub Kiciński | 2 | 0.10% | 1 | 4.76% |
Total | 2005 | 21 |
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) /* Copyright (C) 2017-2018 Netronome Systems, Inc. */ #include <linux/bitfield.h> #include <net/pkt_cls.h> #include "cmsg.h" #include "main.h" static void nfp_flower_compile_meta_tci(struct nfp_flower_meta_tci *frame, struct tc_cls_flower_offload *flow, u8 key_type, bool mask_version) { struct fl_flow_key *target = mask_version ? flow->mask : flow->key; struct flow_dissector_key_vlan *flow_vlan; u16 tmp_tci; memset(frame, 0, sizeof(struct nfp_flower_meta_tci)); /* Populate the metadata frame. */ frame->nfp_flow_key_layer = key_type; frame->mask_id = ~0; if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_VLAN)) { flow_vlan = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_VLAN, target); /* Populate the tci field. */ if (flow_vlan->vlan_id || flow_vlan->vlan_priority) { tmp_tci = FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO, flow_vlan->vlan_priority) | FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID, flow_vlan->vlan_id) | NFP_FLOWER_MASK_VLAN_CFI; frame->tci = cpu_to_be16(tmp_tci); } } } static void nfp_flower_compile_ext_meta(struct nfp_flower_ext_meta *frame, u32 key_ext) { frame->nfp_flow_key_layer2 = cpu_to_be32(key_ext); } static int nfp_flower_compile_port(struct nfp_flower_in_port *frame, u32 cmsg_port, bool mask_version, enum nfp_flower_tun_type tun_type) { if (mask_version) { frame->in_port = cpu_to_be32(~0); return 0; } if (tun_type) { frame->in_port = cpu_to_be32(NFP_FL_PORT_TYPE_TUN | tun_type); } else { if (!cmsg_port) return -EOPNOTSUPP; frame->in_port = cpu_to_be32(cmsg_port); } return 0; } static void nfp_flower_compile_mac(struct nfp_flower_mac_mpls *frame, struct tc_cls_flower_offload *flow, bool mask_version) { struct fl_flow_key *target = mask_version ? flow->mask : flow->key; struct flow_dissector_key_eth_addrs *addr; memset(frame, 0, sizeof(struct nfp_flower_mac_mpls)); if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_ETH_ADDRS)) { addr = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_ETH_ADDRS, target); /* Populate mac frame. */ ether_addr_copy(frame->mac_dst, &addr->dst[0]); ether_addr_copy(frame->mac_src, &addr->src[0]); } if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_MPLS)) { struct flow_dissector_key_mpls *mpls; u32 t_mpls; mpls = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_MPLS, target); t_mpls = FIELD_PREP(NFP_FLOWER_MASK_MPLS_LB, mpls->mpls_label) | FIELD_PREP(NFP_FLOWER_MASK_MPLS_TC, mpls->mpls_tc) | FIELD_PREP(NFP_FLOWER_MASK_MPLS_BOS, mpls->mpls_bos) | NFP_FLOWER_MASK_MPLS_Q; frame->mpls_lse = cpu_to_be32(t_mpls); } else if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_BASIC)) { /* Check for mpls ether type and set NFP_FLOWER_MASK_MPLS_Q * bit, which indicates an mpls ether type but without any * mpls fields. */ struct flow_dissector_key_basic *key_basic; key_basic = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_BASIC, flow->key); if (key_basic->n_proto == cpu_to_be16(ETH_P_MPLS_UC) || key_basic->n_proto == cpu_to_be16(ETH_P_MPLS_MC)) frame->mpls_lse = cpu_to_be32(NFP_FLOWER_MASK_MPLS_Q); } } static void nfp_flower_compile_tport(struct nfp_flower_tp_ports *frame, struct tc_cls_flower_offload *flow, bool mask_version) { struct fl_flow_key *target = mask_version ? flow->mask : flow->key; struct flow_dissector_key_ports *tp; memset(frame, 0, sizeof(struct nfp_flower_tp_ports)); if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_PORTS)) { tp = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_PORTS, target); frame->port_src = tp->src; frame->port_dst = tp->dst; } } static void nfp_flower_compile_ip_ext(struct nfp_flower_ip_ext *frame, struct tc_cls_flower_offload *flow, bool mask_version) { struct fl_flow_key *target = mask_version ? flow->mask : flow->key; if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_BASIC)) { struct flow_dissector_key_basic *basic; basic = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_BASIC, target); frame->proto = basic->ip_proto; } if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_IP)) { struct flow_dissector_key_ip *flow_ip; flow_ip = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_IP, target); frame->tos = flow_ip->tos; frame->ttl = flow_ip->ttl; } if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_TCP)) { struct flow_dissector_key_tcp *tcp; u32 tcp_flags; tcp = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_TCP, target); tcp_flags = be16_to_cpu(tcp->flags); if (tcp_flags & TCPHDR_FIN) frame->flags |= NFP_FL_TCP_FLAG_FIN; if (tcp_flags & TCPHDR_SYN) frame->flags |= NFP_FL_TCP_FLAG_SYN; if (tcp_flags & TCPHDR_RST) frame->flags |= NFP_FL_TCP_FLAG_RST; if (tcp_flags & TCPHDR_PSH) frame->flags |= NFP_FL_TCP_FLAG_PSH; if (tcp_flags & TCPHDR_URG) frame->flags |= NFP_FL_TCP_FLAG_URG; } if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_CONTROL)) { struct flow_dissector_key_control *key; key = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_CONTROL, target); if (key->flags & FLOW_DIS_IS_FRAGMENT) frame->flags |= NFP_FL_IP_FRAGMENTED; if (key->flags & FLOW_DIS_FIRST_FRAG) frame->flags |= NFP_FL_IP_FRAG_FIRST; } } static void nfp_flower_compile_ipv4(struct nfp_flower_ipv4 *frame, struct tc_cls_flower_offload *flow, bool mask_version) { struct fl_flow_key *target = mask_version ? flow->mask : flow->key; struct flow_dissector_key_ipv4_addrs *addr; memset(frame, 0, sizeof(struct nfp_flower_ipv4)); if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_IPV4_ADDRS)) { addr = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_IPV4_ADDRS, target); frame->ipv4_src = addr->src; frame->ipv4_dst = addr->dst; } nfp_flower_compile_ip_ext(&frame->ip_ext, flow, mask_version); } static void nfp_flower_compile_ipv6(struct nfp_flower_ipv6 *frame, struct tc_cls_flower_offload *flow, bool mask_version) { struct fl_flow_key *target = mask_version ? flow->mask : flow->key; struct flow_dissector_key_ipv6_addrs *addr; memset(frame, 0, sizeof(struct nfp_flower_ipv6)); if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_IPV6_ADDRS)) { addr = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_IPV6_ADDRS, target); frame->ipv6_src = addr->src; frame->ipv6_dst = addr->dst; } nfp_flower_compile_ip_ext(&frame->ip_ext, flow, mask_version); } static int nfp_flower_compile_geneve_opt(void *key_buf, struct tc_cls_flower_offload *flow, bool mask_version) { struct fl_flow_key *target = mask_version ? flow->mask : flow->key; struct flow_dissector_key_enc_opts *opts; opts = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_ENC_OPTS, target); memcpy(key_buf, opts->data, opts->len); return 0; } static void nfp_flower_compile_ipv4_udp_tun(struct nfp_flower_ipv4_udp_tun *frame, struct tc_cls_flower_offload *flow, bool mask_version) { struct fl_flow_key *target = mask_version ? flow->mask : flow->key; struct flow_dissector_key_ipv4_addrs *tun_ips; struct flow_dissector_key_keyid *vni; struct flow_dissector_key_ip *ip; memset(frame, 0, sizeof(struct nfp_flower_ipv4_udp_tun)); if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_ENC_KEYID)) { u32 temp_vni; vni = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_ENC_KEYID, target); temp_vni = be32_to_cpu(vni->keyid) << NFP_FL_TUN_VNI_OFFSET; frame->tun_id = cpu_to_be32(temp_vni); } if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS)) { tun_ips = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS, target); frame->ip_src = tun_ips->src; frame->ip_dst = tun_ips->dst; } if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_ENC_IP)) { ip = skb_flow_dissector_target(flow->dissector, FLOW_DISSECTOR_KEY_ENC_IP, target); frame->tos = ip->tos; frame->ttl = ip->ttl; } } int nfp_flower_compile_flow_match(struct nfp_app *app, struct tc_cls_flower_offload *flow, struct nfp_fl_key_ls *key_ls, struct net_device *netdev, struct nfp_fl_payload *nfp_flow, enum nfp_flower_tun_type tun_type) { u32 cmsg_port = 0; int err; u8 *ext; u8 *msk; if (nfp_netdev_is_nfp_repr(netdev)) cmsg_port = nfp_repr_get_port_id(netdev); memset(nfp_flow->unmasked_data, 0, key_ls->key_size); memset(nfp_flow->mask_data, 0, key_ls->key_size); ext = nfp_flow->unmasked_data; msk = nfp_flow->mask_data; /* Populate Exact Metadata. */ nfp_flower_compile_meta_tci((struct nfp_flower_meta_tci *)ext, flow, key_ls->key_layer, false); /* Populate Mask Metadata. */ nfp_flower_compile_meta_tci((struct nfp_flower_meta_tci *)msk, flow, key_ls->key_layer, true); ext += sizeof(struct nfp_flower_meta_tci); msk += sizeof(struct nfp_flower_meta_tci); /* Populate Extended Metadata if Required. */ if (NFP_FLOWER_LAYER_EXT_META & key_ls->key_layer) { nfp_flower_compile_ext_meta((struct nfp_flower_ext_meta *)ext, key_ls->key_layer_two); nfp_flower_compile_ext_meta((struct nfp_flower_ext_meta *)msk, key_ls->key_layer_two); ext += sizeof(struct nfp_flower_ext_meta); msk += sizeof(struct nfp_flower_ext_meta); } /* Populate Exact Port data. */ err = nfp_flower_compile_port((struct nfp_flower_in_port *)ext, cmsg_port, false, tun_type); if (err) return err; /* Populate Mask Port Data. */ err = nfp_flower_compile_port((struct nfp_flower_in_port *)msk, cmsg_port, true, tun_type); if (err) return err; ext += sizeof(struct nfp_flower_in_port); msk += sizeof(struct nfp_flower_in_port); if (NFP_FLOWER_LAYER_MAC & key_ls->key_layer) { /* Populate Exact MAC Data. */ nfp_flower_compile_mac((struct nfp_flower_mac_mpls *)ext, flow, false); /* Populate Mask MAC Data. */ nfp_flower_compile_mac((struct nfp_flower_mac_mpls *)msk, flow, true); ext += sizeof(struct nfp_flower_mac_mpls); msk += sizeof(struct nfp_flower_mac_mpls); } if (NFP_FLOWER_LAYER_TP & key_ls->key_layer) { /* Populate Exact TP Data. */ nfp_flower_compile_tport((struct nfp_flower_tp_ports *)ext, flow, false); /* Populate Mask TP Data. */ nfp_flower_compile_tport((struct nfp_flower_tp_ports *)msk, flow, true); ext += sizeof(struct nfp_flower_tp_ports); msk += sizeof(struct nfp_flower_tp_ports); } if (NFP_FLOWER_LAYER_IPV4 & key_ls->key_layer) { /* Populate Exact IPv4 Data. */ nfp_flower_compile_ipv4((struct nfp_flower_ipv4 *)ext, flow, false); /* Populate Mask IPv4 Data. */ nfp_flower_compile_ipv4((struct nfp_flower_ipv4 *)msk, flow, true); ext += sizeof(struct nfp_flower_ipv4); msk += sizeof(struct nfp_flower_ipv4); } if (NFP_FLOWER_LAYER_IPV6 & key_ls->key_layer) { /* Populate Exact IPv4 Data. */ nfp_flower_compile_ipv6((struct nfp_flower_ipv6 *)ext, flow, false); /* Populate Mask IPv4 Data. */ nfp_flower_compile_ipv6((struct nfp_flower_ipv6 *)msk, flow, true); ext += sizeof(struct nfp_flower_ipv6); msk += sizeof(struct nfp_flower_ipv6); } if (key_ls->key_layer & NFP_FLOWER_LAYER_VXLAN || key_ls->key_layer_two & NFP_FLOWER_LAYER2_GENEVE) { __be32 tun_dst; /* Populate Exact VXLAN Data. */ nfp_flower_compile_ipv4_udp_tun((void *)ext, flow, false); /* Populate Mask VXLAN Data. */ nfp_flower_compile_ipv4_udp_tun((void *)msk, flow, true); tun_dst = ((struct nfp_flower_ipv4_udp_tun *)ext)->ip_dst; ext += sizeof(struct nfp_flower_ipv4_udp_tun); msk += sizeof(struct nfp_flower_ipv4_udp_tun); /* Configure tunnel end point MAC. */ nfp_tunnel_write_macs(app); /* Store the tunnel destination in the rule data. * This must be present and be an exact match. */ nfp_flow->nfp_tun_ipv4_addr = tun_dst; nfp_tunnel_add_ipv4_off(app, tun_dst); if (key_ls->key_layer_two & NFP_FLOWER_LAYER2_GENEVE_OP) { err = nfp_flower_compile_geneve_opt(ext, flow, false); if (err) return err; err = nfp_flower_compile_geneve_opt(msk, flow, true); if (err) return err; } } return 0; }
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