1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright 2020 Mellanox Technologies, Ltd 3 * 4 * This file contain the implementations of the items 5 * related methods. Each Item have a method to prepare 6 * the item and add it into items array in given index. 7 */ 8 9 #include <stdint.h> 10 #include <rte_flow.h> 11 12 #include "items_gen.h" 13 #include "config.h" 14 15 /* Storage for additional parameters for items */ 16 struct additional_para { 17 rte_be32_t src_ip; 18 }; 19 20 static void 21 add_ether(struct rte_flow_item *items, 22 uint8_t items_counter, 23 __rte_unused struct additional_para para) 24 { 25 static struct rte_flow_item_eth eth_spec; 26 static struct rte_flow_item_eth eth_mask; 27 28 memset(ð_spec, 0, sizeof(struct rte_flow_item_eth)); 29 memset(ð_mask, 0, sizeof(struct rte_flow_item_eth)); 30 31 items[items_counter].type = RTE_FLOW_ITEM_TYPE_ETH; 32 items[items_counter].spec = ð_spec; 33 items[items_counter].mask = ð_mask; 34 } 35 36 static void 37 add_vlan(struct rte_flow_item *items, 38 uint8_t items_counter, 39 __rte_unused struct additional_para para) 40 { 41 static struct rte_flow_item_vlan vlan_spec; 42 static struct rte_flow_item_vlan vlan_mask; 43 44 uint16_t vlan_value = VLAN_VALUE; 45 46 memset(&vlan_spec, 0, sizeof(struct rte_flow_item_vlan)); 47 memset(&vlan_mask, 0, sizeof(struct rte_flow_item_vlan)); 48 49 vlan_spec.tci = RTE_BE16(vlan_value); 50 vlan_mask.tci = RTE_BE16(0xffff); 51 52 items[items_counter].type = RTE_FLOW_ITEM_TYPE_VLAN; 53 items[items_counter].spec = &vlan_spec; 54 items[items_counter].mask = &vlan_mask; 55 } 56 57 static void 58 add_ipv4(struct rte_flow_item *items, 59 uint8_t items_counter, struct additional_para para) 60 { 61 static struct rte_flow_item_ipv4 ipv4_spec; 62 static struct rte_flow_item_ipv4 ipv4_mask; 63 64 memset(&ipv4_spec, 0, sizeof(struct rte_flow_item_ipv4)); 65 memset(&ipv4_mask, 0, sizeof(struct rte_flow_item_ipv4)); 66 67 ipv4_spec.hdr.src_addr = para.src_ip; 68 ipv4_mask.hdr.src_addr = RTE_BE32(0xffffffff); 69 70 items[items_counter].type = RTE_FLOW_ITEM_TYPE_IPV4; 71 items[items_counter].spec = &ipv4_spec; 72 items[items_counter].mask = &ipv4_mask; 73 } 74 75 76 static void 77 add_ipv6(struct rte_flow_item *items, 78 uint8_t items_counter, struct additional_para para) 79 { 80 static struct rte_flow_item_ipv6 ipv6_spec; 81 static struct rte_flow_item_ipv6 ipv6_mask; 82 83 memset(&ipv6_spec, 0, sizeof(struct rte_flow_item_ipv6)); 84 memset(&ipv6_mask, 0, sizeof(struct rte_flow_item_ipv6)); 85 86 /** Set ipv6 src **/ 87 memset(&ipv6_spec.hdr.src_addr, para.src_ip, 88 sizeof(ipv6_spec.hdr.src_addr) / 2); 89 90 /** Full mask **/ 91 memset(&ipv6_mask.hdr.src_addr, 0xff, 92 sizeof(ipv6_spec.hdr.src_addr)); 93 94 items[items_counter].type = RTE_FLOW_ITEM_TYPE_IPV6; 95 items[items_counter].spec = &ipv6_spec; 96 items[items_counter].mask = &ipv6_mask; 97 } 98 99 static void 100 add_tcp(struct rte_flow_item *items, 101 uint8_t items_counter, 102 __rte_unused struct additional_para para) 103 { 104 static struct rte_flow_item_tcp tcp_spec; 105 static struct rte_flow_item_tcp tcp_mask; 106 107 memset(&tcp_spec, 0, sizeof(struct rte_flow_item_tcp)); 108 memset(&tcp_mask, 0, sizeof(struct rte_flow_item_tcp)); 109 110 items[items_counter].type = RTE_FLOW_ITEM_TYPE_TCP; 111 items[items_counter].spec = &tcp_spec; 112 items[items_counter].mask = &tcp_mask; 113 } 114 115 static void 116 add_udp(struct rte_flow_item *items, 117 uint8_t items_counter, 118 __rte_unused struct additional_para para) 119 { 120 static struct rte_flow_item_udp udp_spec; 121 static struct rte_flow_item_udp udp_mask; 122 123 memset(&udp_spec, 0, sizeof(struct rte_flow_item_udp)); 124 memset(&udp_mask, 0, sizeof(struct rte_flow_item_udp)); 125 126 items[items_counter].type = RTE_FLOW_ITEM_TYPE_UDP; 127 items[items_counter].spec = &udp_spec; 128 items[items_counter].mask = &udp_mask; 129 } 130 131 static void 132 add_vxlan(struct rte_flow_item *items, 133 uint8_t items_counter, 134 __rte_unused struct additional_para para) 135 { 136 static struct rte_flow_item_vxlan vxlan_spec; 137 static struct rte_flow_item_vxlan vxlan_mask; 138 139 uint32_t vni_value; 140 uint8_t i; 141 142 vni_value = VNI_VALUE; 143 144 memset(&vxlan_spec, 0, sizeof(struct rte_flow_item_vxlan)); 145 memset(&vxlan_mask, 0, sizeof(struct rte_flow_item_vxlan)); 146 147 /* Set standard vxlan vni */ 148 for (i = 0; i < 3; i++) { 149 vxlan_spec.vni[2 - i] = vni_value >> (i * 8); 150 vxlan_mask.vni[2 - i] = 0xff; 151 } 152 153 /* Standard vxlan flags */ 154 vxlan_spec.flags = 0x8; 155 156 items[items_counter].type = RTE_FLOW_ITEM_TYPE_VXLAN; 157 items[items_counter].spec = &vxlan_spec; 158 items[items_counter].mask = &vxlan_mask; 159 } 160 161 static void 162 add_vxlan_gpe(struct rte_flow_item *items, 163 uint8_t items_counter, 164 __rte_unused struct additional_para para) 165 { 166 static struct rte_flow_item_vxlan_gpe vxlan_gpe_spec; 167 static struct rte_flow_item_vxlan_gpe vxlan_gpe_mask; 168 169 uint32_t vni_value; 170 uint8_t i; 171 172 vni_value = VNI_VALUE; 173 174 memset(&vxlan_gpe_spec, 0, sizeof(struct rte_flow_item_vxlan_gpe)); 175 memset(&vxlan_gpe_mask, 0, sizeof(struct rte_flow_item_vxlan_gpe)); 176 177 /* Set vxlan-gpe vni */ 178 for (i = 0; i < 3; i++) { 179 vxlan_gpe_spec.vni[2 - i] = vni_value >> (i * 8); 180 vxlan_gpe_mask.vni[2 - i] = 0xff; 181 } 182 183 /* vxlan-gpe flags */ 184 vxlan_gpe_spec.flags = 0x0c; 185 186 items[items_counter].type = RTE_FLOW_ITEM_TYPE_VXLAN_GPE; 187 items[items_counter].spec = &vxlan_gpe_spec; 188 items[items_counter].mask = &vxlan_gpe_mask; 189 } 190 191 static void 192 add_gre(struct rte_flow_item *items, 193 uint8_t items_counter, 194 __rte_unused struct additional_para para) 195 { 196 static struct rte_flow_item_gre gre_spec; 197 static struct rte_flow_item_gre gre_mask; 198 199 uint16_t proto; 200 201 proto = RTE_ETHER_TYPE_TEB; 202 203 memset(&gre_spec, 0, sizeof(struct rte_flow_item_gre)); 204 memset(&gre_mask, 0, sizeof(struct rte_flow_item_gre)); 205 206 gre_spec.protocol = RTE_BE16(proto); 207 gre_mask.protocol = RTE_BE16(0xffff); 208 209 items[items_counter].type = RTE_FLOW_ITEM_TYPE_GRE; 210 items[items_counter].spec = &gre_spec; 211 items[items_counter].mask = &gre_mask; 212 } 213 214 static void 215 add_geneve(struct rte_flow_item *items, 216 uint8_t items_counter, 217 __rte_unused struct additional_para para) 218 { 219 static struct rte_flow_item_geneve geneve_spec; 220 static struct rte_flow_item_geneve geneve_mask; 221 222 uint32_t vni_value; 223 uint8_t i; 224 225 vni_value = VNI_VALUE; 226 227 memset(&geneve_spec, 0, sizeof(struct rte_flow_item_geneve)); 228 memset(&geneve_mask, 0, sizeof(struct rte_flow_item_geneve)); 229 230 for (i = 0; i < 3; i++) { 231 geneve_spec.vni[2 - i] = vni_value >> (i * 8); 232 geneve_mask.vni[2 - i] = 0xff; 233 } 234 235 items[items_counter].type = RTE_FLOW_ITEM_TYPE_GENEVE; 236 items[items_counter].spec = &geneve_spec; 237 items[items_counter].mask = &geneve_mask; 238 } 239 240 static void 241 add_gtp(struct rte_flow_item *items, 242 uint8_t items_counter, 243 __rte_unused struct additional_para para) 244 { 245 static struct rte_flow_item_gtp gtp_spec; 246 static struct rte_flow_item_gtp gtp_mask; 247 248 uint32_t teid_value; 249 250 teid_value = TEID_VALUE; 251 252 memset(>p_spec, 0, sizeof(struct rte_flow_item_gtp)); 253 memset(>p_mask, 0, sizeof(struct rte_flow_item_gtp)); 254 255 gtp_spec.teid = RTE_BE32(teid_value); 256 gtp_mask.teid = RTE_BE32(0xffffffff); 257 258 items[items_counter].type = RTE_FLOW_ITEM_TYPE_GTP; 259 items[items_counter].spec = >p_spec; 260 items[items_counter].mask = >p_mask; 261 } 262 263 static void 264 add_meta_data(struct rte_flow_item *items, 265 uint8_t items_counter, 266 __rte_unused struct additional_para para) 267 { 268 static struct rte_flow_item_meta meta_spec; 269 static struct rte_flow_item_meta meta_mask; 270 271 uint32_t data; 272 273 data = META_DATA; 274 275 memset(&meta_spec, 0, sizeof(struct rte_flow_item_meta)); 276 memset(&meta_mask, 0, sizeof(struct rte_flow_item_meta)); 277 278 meta_spec.data = RTE_BE32(data); 279 meta_mask.data = RTE_BE32(0xffffffff); 280 281 items[items_counter].type = RTE_FLOW_ITEM_TYPE_META; 282 items[items_counter].spec = &meta_spec; 283 items[items_counter].mask = &meta_mask; 284 } 285 286 287 static void 288 add_meta_tag(struct rte_flow_item *items, 289 uint8_t items_counter, 290 __rte_unused struct additional_para para) 291 { 292 static struct rte_flow_item_tag tag_spec; 293 static struct rte_flow_item_tag tag_mask; 294 uint32_t data; 295 uint8_t index; 296 297 data = META_DATA; 298 index = TAG_INDEX; 299 300 memset(&tag_spec, 0, sizeof(struct rte_flow_item_tag)); 301 memset(&tag_mask, 0, sizeof(struct rte_flow_item_tag)); 302 303 tag_spec.data = RTE_BE32(data); 304 tag_mask.data = RTE_BE32(0xffffffff); 305 tag_spec.index = index; 306 tag_mask.index = 0xff; 307 308 items[items_counter].type = RTE_FLOW_ITEM_TYPE_TAG; 309 items[items_counter].spec = &tag_spec; 310 items[items_counter].mask = &tag_mask; 311 } 312 313 void 314 fill_items(struct rte_flow_item *items, 315 uint64_t flow_items, uint32_t outer_ip_src) 316 { 317 uint8_t items_counter = 0; 318 uint8_t i; 319 struct additional_para additional_para_data = { 320 .src_ip = outer_ip_src, 321 }; 322 323 /* Support outer items up to tunnel layer only. */ 324 static const struct items_dict { 325 uint64_t mask; 326 void (*funct)( 327 struct rte_flow_item *items, 328 uint8_t items_counter, 329 struct additional_para para 330 ); 331 } flows_items[] = { 332 { 333 .mask = RTE_FLOW_ITEM_TYPE_META, 334 .funct = add_meta_data, 335 }, 336 { 337 .mask = RTE_FLOW_ITEM_TYPE_TAG, 338 .funct = add_meta_tag, 339 }, 340 { 341 .mask = RTE_FLOW_ITEM_TYPE_ETH, 342 .funct = add_ether, 343 }, 344 { 345 .mask = RTE_FLOW_ITEM_TYPE_VLAN, 346 .funct = add_vlan, 347 }, 348 { 349 .mask = RTE_FLOW_ITEM_TYPE_IPV4, 350 .funct = add_ipv4, 351 }, 352 { 353 .mask = RTE_FLOW_ITEM_TYPE_IPV6, 354 .funct = add_ipv6, 355 }, 356 { 357 .mask = RTE_FLOW_ITEM_TYPE_TCP, 358 .funct = add_tcp, 359 }, 360 { 361 .mask = RTE_FLOW_ITEM_TYPE_UDP, 362 .funct = add_udp, 363 }, 364 { 365 .mask = RTE_FLOW_ITEM_TYPE_VXLAN, 366 .funct = add_vxlan, 367 }, 368 { 369 .mask = RTE_FLOW_ITEM_TYPE_VXLAN_GPE, 370 .funct = add_vxlan_gpe, 371 }, 372 { 373 .mask = RTE_FLOW_ITEM_TYPE_GRE, 374 .funct = add_gre, 375 }, 376 { 377 .mask = RTE_FLOW_ITEM_TYPE_GENEVE, 378 .funct = add_geneve, 379 }, 380 { 381 .mask = RTE_FLOW_ITEM_TYPE_GTP, 382 .funct = add_gtp, 383 }, 384 385 }; 386 387 for (i = 0; i < RTE_DIM(flows_items); i++) { 388 if ((flow_items & FLOW_ITEM_MASK(flows_items[i].mask)) == 0) 389 continue; 390 flows_items[i].funct( 391 items, items_counter++, 392 additional_para_data 393 ); 394 } 395 396 items[items_counter].type = RTE_FLOW_ITEM_TYPE_END; 397 } 398