drivers/net/enic/enic_clsf.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2008-2017 Cisco Systems, Inc.  All rights reserved.
   3  * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
   4  */
   5
   6 #include <rte_ethdev_driver.h>
   7 #include <rte_malloc.h>
   8 #include <rte_hash.h>
   9 #include <rte_byteorder.h>
  10 #include <rte_ip.h>
  11 #include <rte_tcp.h>
  12 #include <rte_udp.h>
  13 #include <rte_sctp.h>
  14
  15 #include "enic_compat.h"
  16 #include "enic.h"
  17 #include "wq_enet_desc.h"
  18 #include "rq_enet_desc.h"
  19 #include "cq_enet_desc.h"
  20 #include "vnic_enet.h"
  21 #include "vnic_dev.h"
  22 #include "vnic_wq.h"
  23 #include "vnic_rq.h"
  24 #include "vnic_cq.h"
  25 #include "vnic_intr.h"
  26 #include "vnic_nic.h"
  27
  28 #ifdef RTE_ARCH_X86
  29 #include <rte_hash_crc.h>
  30 #define DEFAULT_HASH_FUNC       rte_hash_crc
  31 #else
  32 #include <rte_jhash.h>
  33 #define DEFAULT_HASH_FUNC       rte_jhash
  34 #endif
  35
  36 #define ENICPMD_CLSF_HASH_ENTRIES       ENICPMD_FDIR_MAX
  37
  38 static void copy_fltr_v1(struct filter_v2 *fltr,
  39                 const struct rte_eth_fdir_input *input,
  40                 const struct rte_eth_fdir_masks *masks);
  41 static void copy_fltr_v2(struct filter_v2 *fltr,
  42                 const struct rte_eth_fdir_input *input,
  43                 const struct rte_eth_fdir_masks *masks);
  44
  45 void enic_fdir_info(struct enic *enic)
  46 {
  47         enic->fdir.modes = (uint32_t)RTE_FDIR_MODE_PERFECT;
  48         enic->fdir.types_mask  = 1 << RTE_ETH_FLOW_NONFRAG_IPV4_UDP |
  49                                  1 << RTE_ETH_FLOW_NONFRAG_IPV4_TCP;
  50         if (enic->adv_filters) {
  51                 enic->fdir.types_mask |= 1 << RTE_ETH_FLOW_NONFRAG_IPV4_OTHER |
  52                                          1 << RTE_ETH_FLOW_NONFRAG_IPV4_SCTP |
  53                                          1 << RTE_ETH_FLOW_NONFRAG_IPV6_UDP |
  54                                          1 << RTE_ETH_FLOW_NONFRAG_IPV6_TCP |
  55                                          1 << RTE_ETH_FLOW_NONFRAG_IPV6_SCTP |
  56                                          1 << RTE_ETH_FLOW_NONFRAG_IPV6_OTHER;
  57                 enic->fdir.copy_fltr_fn = copy_fltr_v2;
  58         } else {
  59                 enic->fdir.copy_fltr_fn = copy_fltr_v1;
  60         }
  61 }
  62
  63 static void
  64 enic_set_layer(struct filter_generic_1 *gp, unsigned int flag,
  65                enum filter_generic_1_layer layer, void *mask, void *val,
  66                unsigned int len)
  67 {
  68         gp->mask_flags |= flag;
  69         gp->val_flags |= gp->mask_flags;
  70         memcpy(gp->layer[layer].mask, mask, len);
  71         memcpy(gp->layer[layer].val, val, len);
  72 }
  73
  74 /* Copy Flow Director filter to a VIC ipv4 filter (for Cisco VICs
  75  * without advanced filter support.
  76  */
  77 static void
  78 copy_fltr_v1(struct filter_v2 *fltr, const struct rte_eth_fdir_input *input,
  79              __rte_unused const struct rte_eth_fdir_masks *masks)
  80 {
  81         fltr->type = FILTER_IPV4_5TUPLE;
  82         fltr->u.ipv4.src_addr = rte_be_to_cpu_32(
  83                 input->flow.ip4_flow.src_ip);
  84         fltr->u.ipv4.dst_addr = rte_be_to_cpu_32(
  85                 input->flow.ip4_flow.dst_ip);
  86         fltr->u.ipv4.src_port = rte_be_to_cpu_16(
  87                 input->flow.udp4_flow.src_port);
  88         fltr->u.ipv4.dst_port = rte_be_to_cpu_16(
  89                 input->flow.udp4_flow.dst_port);
  90
  91         if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_TCP)
  92                 fltr->u.ipv4.protocol = PROTO_TCP;
  93         else
  94                 fltr->u.ipv4.protocol = PROTO_UDP;
  95
  96         fltr->u.ipv4.flags = FILTER_FIELDS_IPV4_5TUPLE;
  97 }
  98
  99 /* Copy Flow Director filter to a VIC generic filter (requires advanced
 100  * filter support.
 101  */
 102 static void
 103 copy_fltr_v2(struct filter_v2 *fltr, const struct rte_eth_fdir_input *input,
 104              const struct rte_eth_fdir_masks *masks)
 105 {
 106         struct filter_generic_1 *gp = &fltr->u.generic_1;
 107
 108         fltr->type = FILTER_DPDK_1;
 109         memset(gp, 0, sizeof(*gp));
 110
 111         if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_UDP) {
 112                 struct rte_udp_hdr udp_mask, udp_val;
 113                 memset(&udp_mask, 0, sizeof(udp_mask));
 114                 memset(&udp_val, 0, sizeof(udp_val));
 115
 116                 if (input->flow.udp4_flow.src_port) {
 117                         udp_mask.src_port = masks->src_port_mask;
 118                         udp_val.src_port = input->flow.udp4_flow.src_port;
 119                 }
 120                 if (input->flow.udp4_flow.dst_port) {
 121                         udp_mask.dst_port = masks->dst_port_mask;
 122                         udp_val.dst_port = input->flow.udp4_flow.dst_port;
 123                 }
 124
 125                 enic_set_layer(gp, FILTER_GENERIC_1_UDP, FILTER_GENERIC_1_L4,
 126                                &udp_mask, &udp_val, sizeof(struct rte_udp_hdr));
 127         } else if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_TCP) {
 128                 struct rte_tcp_hdr tcp_mask, tcp_val;
 129                 memset(&tcp_mask, 0, sizeof(tcp_mask));
 130                 memset(&tcp_val, 0, sizeof(tcp_val));
 131
 132                 if (input->flow.tcp4_flow.src_port) {
 133                         tcp_mask.src_port = masks->src_port_mask;
 134                         tcp_val.src_port = input->flow.tcp4_flow.src_port;
 135                 }
 136                 if (input->flow.tcp4_flow.dst_port) {
 137                         tcp_mask.dst_port = masks->dst_port_mask;
 138                         tcp_val.dst_port = input->flow.tcp4_flow.dst_port;
 139                 }
 140
 141                 enic_set_layer(gp, FILTER_GENERIC_1_TCP, FILTER_GENERIC_1_L4,
 142                                &tcp_mask, &tcp_val, sizeof(struct rte_tcp_hdr));
 143         } else if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_SCTP) {
 144                 struct rte_sctp_hdr sctp_mask, sctp_val;
 145                 memset(&sctp_mask, 0, sizeof(sctp_mask));
 146                 memset(&sctp_val, 0, sizeof(sctp_val));
 147
 148                 if (input->flow.sctp4_flow.src_port) {
 149                         sctp_mask.src_port = masks->src_port_mask;
 150                         sctp_val.src_port = input->flow.sctp4_flow.src_port;
 151                 }
 152                 if (input->flow.sctp4_flow.dst_port) {
 153                         sctp_mask.dst_port = masks->dst_port_mask;
 154                         sctp_val.dst_port = input->flow.sctp4_flow.dst_port;
 155                 }
 156                 if (input->flow.sctp4_flow.verify_tag) {
 157                         sctp_mask.tag = 0xffffffff;
 158                         sctp_val.tag = input->flow.sctp4_flow.verify_tag;
 159                 }
 160
 161                 /*
 162                  * Unlike UDP/TCP (FILTER_GENERIC_1_{UDP,TCP}), the firmware
 163                  * has no "packet is SCTP" flag. Use flag=0 (generic L4) and
 164                  * manually set proto_id=sctp below.
 165                  */
 166                 enic_set_layer(gp, 0, FILTER_GENERIC_1_L4, &sctp_mask,
 167                                &sctp_val, sizeof(struct rte_sctp_hdr));
 168         }
 169
 170         if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_UDP ||
 171             input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_TCP ||
 172             input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_SCTP ||
 173             input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_OTHER) {
 174                 struct rte_ipv4_hdr ip4_mask, ip4_val;
 175                 memset(&ip4_mask, 0, sizeof(struct rte_ipv4_hdr));
 176                 memset(&ip4_val, 0, sizeof(struct rte_ipv4_hdr));
 177
 178                 if (input->flow.ip4_flow.tos) {
 179                         ip4_mask.type_of_service = masks->ipv4_mask.tos;
 180                         ip4_val.type_of_service = input->flow.ip4_flow.tos;
 181                 }
 182                 if (input->flow.ip4_flow.ttl) {
 183                         ip4_mask.time_to_live = masks->ipv4_mask.ttl;
 184                         ip4_val.time_to_live = input->flow.ip4_flow.ttl;
 185                 }
 186                 if (input->flow.ip4_flow.proto) {
 187                         ip4_mask.next_proto_id = masks->ipv4_mask.proto;
 188                         ip4_val.next_proto_id = input->flow.ip4_flow.proto;
 189                 } else if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_SCTP) {
 190                         /* Explicitly match the SCTP protocol number */
 191                         ip4_mask.next_proto_id = 0xff;
 192                         ip4_val.next_proto_id = IPPROTO_SCTP;
 193                 }
 194                 if (input->flow.ip4_flow.src_ip) {
 195                         ip4_mask.src_addr =  masks->ipv4_mask.src_ip;
 196                         ip4_val.src_addr = input->flow.ip4_flow.src_ip;
 197                 }
 198                 if (input->flow.ip4_flow.dst_ip) {
 199                         ip4_mask.dst_addr =  masks->ipv4_mask.dst_ip;
 200                         ip4_val.dst_addr = input->flow.ip4_flow.dst_ip;
 201                 }
 202
 203                 enic_set_layer(gp, FILTER_GENERIC_1_IPV4, FILTER_GENERIC_1_L3,
 204                         &ip4_mask, &ip4_val, sizeof(struct rte_ipv4_hdr));
 205         }
 206
 207         if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_UDP) {
 208                 struct rte_udp_hdr udp_mask, udp_val;
 209                 memset(&udp_mask, 0, sizeof(udp_mask));
 210                 memset(&udp_val, 0, sizeof(udp_val));
 211
 212                 if (input->flow.udp6_flow.src_port) {
 213                         udp_mask.src_port = masks->src_port_mask;
 214                         udp_val.src_port = input->flow.udp6_flow.src_port;
 215                 }
 216                 if (input->flow.udp6_flow.dst_port) {
 217                         udp_mask.dst_port = masks->dst_port_mask;
 218                         udp_val.dst_port = input->flow.udp6_flow.dst_port;
 219                 }
 220                 enic_set_layer(gp, FILTER_GENERIC_1_UDP, FILTER_GENERIC_1_L4,
 221                                &udp_mask, &udp_val, sizeof(struct rte_udp_hdr));
 222         } else if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_TCP) {
 223                 struct rte_tcp_hdr tcp_mask, tcp_val;
 224                 memset(&tcp_mask, 0, sizeof(tcp_mask));
 225                 memset(&tcp_val, 0, sizeof(tcp_val));
 226
 227                 if (input->flow.tcp6_flow.src_port) {
 228                         tcp_mask.src_port = masks->src_port_mask;
 229                         tcp_val.src_port = input->flow.tcp6_flow.src_port;
 230                 }
 231                 if (input->flow.tcp6_flow.dst_port) {
 232                         tcp_mask.dst_port = masks->dst_port_mask;
 233                         tcp_val.dst_port = input->flow.tcp6_flow.dst_port;
 234                 }
 235                 enic_set_layer(gp, FILTER_GENERIC_1_TCP, FILTER_GENERIC_1_L4,
 236                                &tcp_mask, &tcp_val, sizeof(struct rte_tcp_hdr));
 237         } else if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_SCTP) {
 238                 struct rte_sctp_hdr sctp_mask, sctp_val;
 239                 memset(&sctp_mask, 0, sizeof(sctp_mask));
 240                 memset(&sctp_val, 0, sizeof(sctp_val));
 241
 242                 if (input->flow.sctp6_flow.src_port) {
 243                         sctp_mask.src_port = masks->src_port_mask;
 244                         sctp_val.src_port = input->flow.sctp6_flow.src_port;
 245                 }
 246                 if (input->flow.sctp6_flow.dst_port) {
 247                         sctp_mask.dst_port = masks->dst_port_mask;
 248                         sctp_val.dst_port = input->flow.sctp6_flow.dst_port;
 249                 }
 250                 if (input->flow.sctp6_flow.verify_tag) {
 251                         sctp_mask.tag = 0xffffffff;
 252                         sctp_val.tag = input->flow.sctp6_flow.verify_tag;
 253                 }
 254
 255                 enic_set_layer(gp, 0, FILTER_GENERIC_1_L4, &sctp_mask,
 256                                &sctp_val, sizeof(struct rte_sctp_hdr));
 257         }
 258
 259         if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_UDP ||
 260             input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_TCP ||
 261             input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_SCTP ||
 262             input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_OTHER) {
 263                 struct rte_ipv6_hdr ipv6_mask, ipv6_val;
 264                 memset(&ipv6_mask, 0, sizeof(struct rte_ipv6_hdr));
 265                 memset(&ipv6_val, 0, sizeof(struct rte_ipv6_hdr));
 266
 267                 if (input->flow.ipv6_flow.proto) {
 268                         ipv6_mask.proto = masks->ipv6_mask.proto;
 269                         ipv6_val.proto = input->flow.ipv6_flow.proto;
 270                 } else if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_SCTP) {
 271                         /* See comments for IPv4 SCTP above. */
 272                         ipv6_mask.proto = 0xff;
 273                         ipv6_val.proto = IPPROTO_SCTP;
 274                 }
 275                 memcpy(ipv6_mask.src_addr, masks->ipv6_mask.src_ip,
 276                        sizeof(ipv6_mask.src_addr));
 277                 memcpy(ipv6_val.src_addr, input->flow.ipv6_flow.src_ip,
 278                        sizeof(ipv6_val.src_addr));
 279                 memcpy(ipv6_mask.dst_addr, masks->ipv6_mask.dst_ip,
 280                        sizeof(ipv6_mask.dst_addr));
 281                 memcpy(ipv6_val.dst_addr, input->flow.ipv6_flow.dst_ip,
 282                        sizeof(ipv6_val.dst_addr));
 283                 if (input->flow.ipv6_flow.tc) {
 284                         ipv6_mask.vtc_flow = masks->ipv6_mask.tc << 12;
 285                         ipv6_val.vtc_flow = input->flow.ipv6_flow.tc << 12;
 286                 }
 287                 if (input->flow.ipv6_flow.hop_limits) {
 288                         ipv6_mask.hop_limits = masks->ipv6_mask.hop_limits;
 289                         ipv6_val.hop_limits = input->flow.ipv6_flow.hop_limits;
 290                 }
 291
 292                 enic_set_layer(gp, FILTER_GENERIC_1_IPV6, FILTER_GENERIC_1_L3,
 293                         &ipv6_mask, &ipv6_val, sizeof(struct rte_ipv6_hdr));
 294         }
 295 }
 296
 297 void enic_clsf_destroy(struct enic *enic)
 298 {
 299         uint32_t index;
 300         struct enic_fdir_node *key;
 301         /* delete classifier entries */
 302         for (index = 0; index < ENICPMD_FDIR_MAX; index++) {
 303                 key = enic->fdir.nodes[index];
 304                 if (key) {
 305                         vnic_dev_classifier(enic->vdev, CLSF_DEL,
 306                                 &key->fltr_id, NULL, NULL);
 307                         rte_free(key);
 308                         enic->fdir.nodes[index] = NULL;
 309                 }
 310         }
 311
 312         if (enic->fdir.hash) {
 313                 rte_hash_free(enic->fdir.hash);
 314                 enic->fdir.hash = NULL;
 315         }
 316 }
 317
 318 int enic_clsf_init(struct enic *enic)
 319 {
 320         char clsf_name[RTE_HASH_NAMESIZE];
 321         struct rte_hash_parameters hash_params = {
 322                 .name = clsf_name,
 323                 .entries = ENICPMD_CLSF_HASH_ENTRIES,
 324                 .key_len = sizeof(struct rte_eth_fdir_filter),
 325                 .hash_func = DEFAULT_HASH_FUNC,
 326                 .hash_func_init_val = 0,
 327                 .socket_id = SOCKET_ID_ANY,
 328         };
 329         snprintf(clsf_name, RTE_HASH_NAMESIZE, "enic_clsf_%s", enic->bdf_name);
 330         enic->fdir.hash = rte_hash_create(&hash_params);
 331         memset(&enic->fdir.stats, 0, sizeof(enic->fdir.stats));
 332         enic->fdir.stats.free = ENICPMD_FDIR_MAX;
 333         return NULL == enic->fdir.hash;
 334 }