app/test-flow-perf/actions_gen.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2020 Mellanox Technologies, Ltd
   3  *
   4  * The file contains the implementations of actions generators.
   5  * Each generator is responsible for preparing it's action instance
   6  * and initializing it with needed data.
   7  */
   8
   9 #include <sys/types.h>
  10 #include <rte_malloc.h>
  11 #include <rte_flow.h>
  12 #include <rte_ethdev.h>
  13
  14 #include "actions_gen.h"
  15 #include "flow_gen.h"
  16 #include "config.h"
  17
  18 /* Storage for additional parameters for actions */
  19 struct additional_para {
  20         uint16_t queue;
  21         uint16_t next_table;
  22         uint16_t *queues;
  23         uint16_t queues_number;
  24         uint32_t counter;
  25 };
  26
  27 /* Storage for struct rte_flow_action_rss including external data. */
  28 struct action_rss_data {
  29         struct rte_flow_action_rss conf;
  30         uint8_t key[40];
  31         uint16_t queue[128];
  32 };
  33
  34 static void
  35 add_mark(struct rte_flow_action *actions,
  36         uint8_t actions_counter,
  37         __rte_unused struct additional_para para)
  38 {
  39         static struct rte_flow_action_mark mark_action;
  40
  41         do {
  42                 mark_action.id = MARK_ID;
  43         } while (0);
  44
  45         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_MARK;
  46         actions[actions_counter].conf = &mark_action;
  47 }
  48
  49 static void
  50 add_queue(struct rte_flow_action *actions,
  51         uint8_t actions_counter,
  52         struct additional_para para)
  53 {
  54         static struct rte_flow_action_queue queue_action;
  55
  56         do {
  57                 queue_action.index = para.queue;
  58         } while (0);
  59
  60         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_QUEUE;
  61         actions[actions_counter].conf = &queue_action;
  62 }
  63
  64 static void
  65 add_jump(struct rte_flow_action *actions,
  66         uint8_t actions_counter,
  67         struct additional_para para)
  68 {
  69         static struct rte_flow_action_jump jump_action;
  70
  71         do {
  72                 jump_action.group = para.next_table;
  73         } while (0);
  74
  75         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_JUMP;
  76         actions[actions_counter].conf = &jump_action;
  77 }
  78
  79 static void
  80 add_rss(struct rte_flow_action *actions,
  81         uint8_t actions_counter,
  82         struct additional_para para)
  83 {
  84         static struct rte_flow_action_rss *rss_action;
  85         static struct action_rss_data *rss_data;
  86
  87         uint16_t queue;
  88
  89         rss_data = rte_malloc("rss_data",
  90                 sizeof(struct action_rss_data), 0);
  91
  92         if (rss_data == NULL)
  93                 rte_exit(EXIT_FAILURE, "No Memory available!");
  94
  95         *rss_data = (struct action_rss_data){
  96                 .conf = (struct rte_flow_action_rss){
  97                         .func = RTE_ETH_HASH_FUNCTION_DEFAULT,
  98                         .level = 0,
  99                         .types = GET_RSS_HF(),
 100                         .key_len = sizeof(rss_data->key),
 101                         .queue_num = para.queues_number,
 102                         .key = rss_data->key,
 103                         .queue = rss_data->queue,
 104                 },
 105                 .key = { 1 },
 106                 .queue = { 0 },
 107         };
 108
 109         for (queue = 0; queue < para.queues_number; queue++)
 110                 rss_data->queue[queue] = para.queues[queue];
 111
 112         rss_action = &rss_data->conf;
 113
 114         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_RSS;
 115         actions[actions_counter].conf = rss_action;
 116 }
 117
 118 static void
 119 add_set_meta(struct rte_flow_action *actions,
 120         uint8_t actions_counter,
 121         __rte_unused struct additional_para para)
 122 {
 123         static struct rte_flow_action_set_meta meta_action;
 124
 125         do {
 126                 meta_action.data = RTE_BE32(META_DATA);
 127                 meta_action.mask = RTE_BE32(0xffffffff);
 128         } while (0);
 129
 130         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_META;
 131         actions[actions_counter].conf = &meta_action;
 132 }
 133
 134 static void
 135 add_set_tag(struct rte_flow_action *actions,
 136         uint8_t actions_counter,
 137         __rte_unused struct additional_para para)
 138 {
 139         static struct rte_flow_action_set_tag tag_action;
 140
 141         do {
 142                 tag_action.data = RTE_BE32(META_DATA);
 143                 tag_action.mask = RTE_BE32(0xffffffff);
 144                 tag_action.index = TAG_INDEX;
 145         } while (0);
 146
 147         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_TAG;
 148         actions[actions_counter].conf = &tag_action;
 149 }
 150
 151 static void
 152 add_port_id(struct rte_flow_action *actions,
 153         uint8_t actions_counter,
 154         __rte_unused struct additional_para para)
 155 {
 156         static struct rte_flow_action_port_id port_id;
 157
 158         do {
 159                 port_id.id = PORT_ID_DST;
 160         } while (0);
 161
 162         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_PORT_ID;
 163         actions[actions_counter].conf = &port_id;
 164 }
 165
 166 static void
 167 add_drop(struct rte_flow_action *actions,
 168         uint8_t actions_counter,
 169         __rte_unused struct additional_para para)
 170 {
 171         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_DROP;
 172 }
 173
 174 static void
 175 add_count(struct rte_flow_action *actions,
 176         uint8_t actions_counter,
 177         __rte_unused struct additional_para para)
 178 {
 179         static struct rte_flow_action_count count_action;
 180
 181         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_COUNT;
 182         actions[actions_counter].conf = &count_action;
 183 }
 184
 185 static void
 186 add_set_src_mac(struct rte_flow_action *actions,
 187         uint8_t actions_counter,
 188         __rte_unused struct additional_para para)
 189 {
 190         static struct rte_flow_action_set_mac set_mac;
 191         uint32_t mac = para.counter;
 192         uint16_t i;
 193
 194         /* Mac address to be set is random each time */
 195         for (i = 0; i < RTE_ETHER_ADDR_LEN; i++) {
 196                 set_mac.mac_addr[i] = mac & 0xff;
 197                 mac = mac >> 8;
 198         }
 199
 200         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_MAC_SRC;
 201         actions[actions_counter].conf = &set_mac;
 202 }
 203
 204 static void
 205 add_set_dst_mac(struct rte_flow_action *actions,
 206         uint8_t actions_counter,
 207         __rte_unused struct additional_para para)
 208 {
 209         static struct rte_flow_action_set_mac set_mac;
 210         uint32_t mac = para.counter;
 211         uint16_t i;
 212
 213         /* Mac address to be set is random each time */
 214         for (i = 0; i < RTE_ETHER_ADDR_LEN; i++) {
 215                 set_mac.mac_addr[i] = mac & 0xff;
 216                 mac = mac >> 8;
 217         }
 218
 219         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_MAC_DST;
 220         actions[actions_counter].conf = &set_mac;
 221 }
 222
 223 static void
 224 add_set_src_ipv4(struct rte_flow_action *actions,
 225         uint8_t actions_counter,
 226         __rte_unused struct additional_para para)
 227 {
 228         static struct rte_flow_action_set_ipv4 set_ipv4;
 229
 230         /* IPv4 value to be set is random each time */
 231         set_ipv4.ipv4_addr = RTE_BE32(para.counter + 1);
 232
 233         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC;
 234         actions[actions_counter].conf = &set_ipv4;
 235 }
 236
 237 static void
 238 add_set_dst_ipv4(struct rte_flow_action *actions,
 239         uint8_t actions_counter,
 240         __rte_unused struct additional_para para)
 241 {
 242         static struct rte_flow_action_set_ipv4 set_ipv4;
 243
 244         /* IPv4 value to be set is random each time */
 245         set_ipv4.ipv4_addr = RTE_BE32(para.counter + 1);
 246
 247         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_IPV4_DST;
 248         actions[actions_counter].conf = &set_ipv4;
 249 }
 250
 251 static void
 252 add_set_src_ipv6(struct rte_flow_action *actions,
 253         uint8_t actions_counter,
 254         __rte_unused struct additional_para para)
 255 {
 256         static struct rte_flow_action_set_ipv6 set_ipv6;
 257         uint32_t ipv6 = para.counter;
 258         uint8_t i;
 259
 260         /* IPv6 value to set is random each time */
 261         for (i = 0; i < 16; i++) {
 262                 set_ipv6.ipv6_addr[i] = ipv6 & 0xff;
 263                 ipv6 = ipv6 >> 8;
 264         }
 265
 266         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC;
 267         actions[actions_counter].conf = &set_ipv6;
 268 }
 269
 270 static void
 271 add_set_dst_ipv6(struct rte_flow_action *actions,
 272         uint8_t actions_counter,
 273         __rte_unused struct additional_para para)
 274 {
 275         static struct rte_flow_action_set_ipv6 set_ipv6;
 276         uint32_t ipv6 = para.counter;
 277         uint8_t i;
 278
 279         /* IPv6 value to set is random each time */
 280         for (i = 0; i < 16; i++) {
 281                 set_ipv6.ipv6_addr[i] = ipv6 & 0xff;
 282                 ipv6 = ipv6 >> 8;
 283         }
 284
 285         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_IPV6_DST;
 286         actions[actions_counter].conf = &set_ipv6;
 287 }
 288
 289 static void
 290 add_set_src_tp(struct rte_flow_action *actions,
 291         uint8_t actions_counter,
 292         __rte_unused struct additional_para para)
 293 {
 294         static struct rte_flow_action_set_tp set_tp;
 295         uint32_t tp = para.counter;
 296
 297         /* TP src port is random each time */
 298         if (tp > 0xffff)
 299                 tp = tp >> 16;
 300
 301         set_tp.port = RTE_BE16(tp & 0xffff);
 302
 303         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_TP_SRC;
 304         actions[actions_counter].conf = &set_tp;
 305 }
 306
 307 static void
 308 add_set_dst_tp(struct rte_flow_action *actions,
 309         uint8_t actions_counter,
 310         __rte_unused struct additional_para para)
 311 {
 312         static struct rte_flow_action_set_tp set_tp;
 313         uint32_t tp = para.counter;
 314
 315         /* TP src port is random each time */
 316         if (tp > 0xffff)
 317                 tp = tp >> 16;
 318
 319         set_tp.port = RTE_BE16(tp & 0xffff);
 320
 321         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_TP_DST;
 322         actions[actions_counter].conf = &set_tp;
 323 }
 324
 325 static void
 326 add_inc_tcp_ack(struct rte_flow_action *actions,
 327         uint8_t actions_counter,
 328         __rte_unused struct additional_para para)
 329 {
 330         static rte_be32_t value = RTE_BE32(1);
 331
 332         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_INC_TCP_ACK;
 333         actions[actions_counter].conf = &value;
 334 }
 335
 336 static void
 337 add_dec_tcp_ack(struct rte_flow_action *actions,
 338         uint8_t actions_counter,
 339         __rte_unused struct additional_para para)
 340 {
 341         static rte_be32_t value = RTE_BE32(1);
 342
 343         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_DEC_TCP_ACK;
 344         actions[actions_counter].conf = &value;
 345 }
 346
 347 static void
 348 add_inc_tcp_seq(struct rte_flow_action *actions,
 349         uint8_t actions_counter,
 350         __rte_unused struct additional_para para)
 351 {
 352         static rte_be32_t value = RTE_BE32(1);
 353
 354         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_INC_TCP_SEQ;
 355         actions[actions_counter].conf = &value;
 356 }
 357
 358 static void
 359 add_dec_tcp_seq(struct rte_flow_action *actions,
 360         uint8_t actions_counter,
 361         __rte_unused struct additional_para para)
 362 {
 363         static rte_be32_t value = RTE_BE32(1);
 364
 365         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_DEC_TCP_SEQ;
 366         actions[actions_counter].conf = &value;
 367 }
 368
 369 static void
 370 add_set_ttl(struct rte_flow_action *actions,
 371         uint8_t actions_counter,
 372         __rte_unused struct additional_para para)
 373 {
 374         static struct rte_flow_action_set_ttl set_ttl;
 375         uint32_t ttl_value = para.counter;
 376
 377         /* Set ttl to random value each time */
 378         while (ttl_value > 0xff)
 379                 ttl_value = ttl_value >> 8;
 380
 381         set_ttl.ttl_value = ttl_value;
 382
 383         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_TTL;
 384         actions[actions_counter].conf = &set_ttl;
 385 }
 386
 387 static void
 388 add_dec_ttl(struct rte_flow_action *actions,
 389         uint8_t actions_counter,
 390         __rte_unused struct additional_para para)
 391 {
 392         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_DEC_TTL;
 393 }
 394
 395 static void
 396 add_set_ipv4_dscp(struct rte_flow_action *actions,
 397         uint8_t actions_counter,
 398         __rte_unused struct additional_para para)
 399 {
 400         static struct rte_flow_action_set_dscp set_dscp;
 401         uint32_t dscp_value = para.counter;
 402
 403         /* Set dscp to random value each time */
 404         while (dscp_value > 0xff)
 405                 dscp_value = dscp_value >> 8;
 406
 407         set_dscp.dscp = dscp_value;
 408
 409         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_IPV4_DSCP;
 410         actions[actions_counter].conf = &set_dscp;
 411 }
 412
 413 static void
 414 add_set_ipv6_dscp(struct rte_flow_action *actions,
 415         uint8_t actions_counter,
 416         __rte_unused struct additional_para para)
 417 {
 418         static struct rte_flow_action_set_dscp set_dscp;
 419         uint32_t dscp_value = para.counter;
 420
 421         /* Set dscp to random value each time */
 422         while (dscp_value > 0xff)
 423                 dscp_value = dscp_value >> 8;
 424
 425         set_dscp.dscp = dscp_value;
 426
 427         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_SET_IPV6_DSCP;
 428         actions[actions_counter].conf = &set_dscp;
 429 }
 430
 431 void
 432 fill_actions(struct rte_flow_action *actions, uint64_t *flow_actions,
 433         uint32_t counter, uint16_t next_table, uint16_t hairpinq)
 434 {
 435         struct additional_para additional_para_data;
 436         uint8_t actions_counter = 0;
 437         uint16_t hairpin_queues[hairpinq];
 438         uint16_t queues[RXQ_NUM];
 439         uint16_t i, j;
 440
 441         for (i = 0; i < RXQ_NUM; i++)
 442                 queues[i] = i;
 443
 444         for (i = 0; i < hairpinq; i++)
 445                 hairpin_queues[i] = i + RXQ_NUM;
 446
 447         additional_para_data = (struct additional_para){
 448                 .queue = counter % RXQ_NUM,
 449                 .next_table = next_table,
 450                 .queues = queues,
 451                 .queues_number = RXQ_NUM,
 452                 .counter = counter,
 453         };
 454
 455         if (hairpinq != 0) {
 456                 additional_para_data.queues = hairpin_queues;
 457                 additional_para_data.queues_number = hairpinq;
 458                 additional_para_data.queue = (counter % hairpinq) + RXQ_NUM;
 459         }
 460
 461         static const struct actions_dict {
 462                 uint64_t mask;
 463                 void (*funct)(
 464                         struct rte_flow_action *actions,
 465                         uint8_t actions_counter,
 466                         struct additional_para para
 467                         );
 468         } actions_list[] = {
 469                 {
 470                         .mask = FLOW_ACTION_MASK(RTE_FLOW_ACTION_TYPE_MARK),
 471                         .funct = add_mark,
 472                 },
 473                 {
 474                         .mask = FLOW_ACTION_MASK(RTE_FLOW_ACTION_TYPE_COUNT),
 475                         .funct = add_count,
 476                 },
 477                 {
 478                         .mask = FLOW_ACTION_MASK(RTE_FLOW_ACTION_TYPE_SET_META),
 479                         .funct = add_set_meta,
 480                 },
 481                 {
 482                         .mask = FLOW_ACTION_MASK(RTE_FLOW_ACTION_TYPE_SET_TAG),
 483                         .funct = add_set_tag,
 484                 },
 485                 {
 486                         .mask = FLOW_ACTION_MASK(
 487                                 RTE_FLOW_ACTION_TYPE_SET_MAC_SRC
 488                         ),
 489                         .funct = add_set_src_mac,
 490                 },
 491                 {
 492                         .mask = FLOW_ACTION_MASK(
 493                                 RTE_FLOW_ACTION_TYPE_SET_MAC_DST
 494                         ),
 495                         .funct = add_set_dst_mac,
 496                 },
 497                 {
 498                         .mask = FLOW_ACTION_MASK(
 499                                 RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC
 500                         ),
 501                         .funct = add_set_src_ipv4,
 502                 },
 503                 {
 504                         .mask = FLOW_ACTION_MASK(
 505                                 RTE_FLOW_ACTION_TYPE_SET_IPV4_DST
 506                         ),
 507                         .funct = add_set_dst_ipv4,
 508                 },
 509                 {
 510                         .mask = FLOW_ACTION_MASK(
 511                                 RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC
 512                         ),
 513                         .funct = add_set_src_ipv6,
 514                 },
 515                 {
 516                         .mask = FLOW_ACTION_MASK(
 517                                 RTE_FLOW_ACTION_TYPE_SET_IPV6_DST
 518                         ),
 519                         .funct = add_set_dst_ipv6,
 520                 },
 521                 {
 522                         .mask = FLOW_ACTION_MASK(
 523                                 RTE_FLOW_ACTION_TYPE_SET_TP_SRC
 524                         ),
 525                         .funct = add_set_src_tp,
 526                 },
 527                 {
 528                         .mask = FLOW_ACTION_MASK(
 529                                 RTE_FLOW_ACTION_TYPE_SET_TP_DST
 530                         ),
 531                         .funct = add_set_dst_tp,
 532                 },
 533                 {
 534                         .mask = FLOW_ACTION_MASK(
 535                                 RTE_FLOW_ACTION_TYPE_INC_TCP_ACK
 536                         ),
 537                         .funct = add_inc_tcp_ack,
 538                 },
 539                 {
 540                         .mask = FLOW_ACTION_MASK(
 541                                 RTE_FLOW_ACTION_TYPE_DEC_TCP_ACK
 542                         ),
 543                         .funct = add_dec_tcp_ack,
 544                 },
 545                 {
 546                         .mask = FLOW_ACTION_MASK(
 547                                 RTE_FLOW_ACTION_TYPE_INC_TCP_SEQ
 548                         ),
 549                         .funct = add_inc_tcp_seq,
 550                 },
 551                 {
 552                         .mask = FLOW_ACTION_MASK(
 553                                 RTE_FLOW_ACTION_TYPE_DEC_TCP_SEQ
 554                         ),
 555                         .funct = add_dec_tcp_seq,
 556                 },
 557                 {
 558                         .mask = FLOW_ACTION_MASK(
 559                                 RTE_FLOW_ACTION_TYPE_SET_TTL
 560                         ),
 561                         .funct = add_set_ttl,
 562                 },
 563                 {
 564                         .mask = FLOW_ACTION_MASK(
 565                                 RTE_FLOW_ACTION_TYPE_DEC_TTL
 566                         ),
 567                         .funct = add_dec_ttl,
 568                 },
 569                 {
 570                         .mask = FLOW_ACTION_MASK(
 571                                 RTE_FLOW_ACTION_TYPE_SET_IPV4_DSCP
 572                         ),
 573                         .funct = add_set_ipv4_dscp,
 574                 },
 575                 {
 576                         .mask = FLOW_ACTION_MASK(
 577                                 RTE_FLOW_ACTION_TYPE_SET_IPV6_DSCP
 578                         ),
 579                         .funct = add_set_ipv6_dscp,
 580                 },
 581                 {
 582                         .mask = FLOW_ACTION_MASK(RTE_FLOW_ACTION_TYPE_QUEUE),
 583                         .funct = add_queue,
 584                 },
 585                 {
 586                         .mask = FLOW_ACTION_MASK(RTE_FLOW_ACTION_TYPE_RSS),
 587                         .funct = add_rss,
 588                 },
 589                 {
 590                         .mask = FLOW_ACTION_MASK(RTE_FLOW_ACTION_TYPE_JUMP),
 591                         .funct = add_jump,
 592                 },
 593                 {
 594                         .mask = FLOW_ACTION_MASK(RTE_FLOW_ACTION_TYPE_PORT_ID),
 595                         .funct = add_port_id
 596                 },
 597                 {
 598                         .mask = FLOW_ACTION_MASK(RTE_FLOW_ACTION_TYPE_DROP),
 599                         .funct = add_drop,
 600                 },
 601                 {
 602                         .mask = HAIRPIN_QUEUE_ACTION,
 603                         .funct = add_queue,
 604                 },
 605                 {
 606                         .mask = HAIRPIN_RSS_ACTION,
 607                         .funct = add_rss,
 608                 },
 609         };
 610
 611         for (j = 0; j < MAX_ACTIONS_NUM; j++) {
 612                 if (flow_actions[j] == 0)
 613                         break;
 614                 for (i = 0; i < RTE_DIM(actions_list); i++) {
 615                         if ((flow_actions[j] &
 616                                 actions_list[i].mask) == 0)
 617                                 continue;
 618                         actions_list[i].funct(
 619                                 actions, actions_counter++,
 620                                 additional_para_data
 621                         );
 622                         break;
 623                 }
 624         }
 625         actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_END;
 626 }