examples/ip_pipeline/thread.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2018 Intel Corporation
   3  */
   4
   5 #include <stdlib.h>
   6
   7 #include <rte_common.h>
   8 #include <rte_cycles.h>
   9 #include <rte_lcore.h>
  10 #include <rte_ring.h>
  11
  12 #include <rte_table_acl.h>
  13 #include <rte_table_array.h>
  14 #include <rte_table_hash.h>
  15 #include <rte_table_lpm.h>
  16 #include <rte_table_lpm_ipv6.h>
  17
  18 #include "common.h"
  19 #include "thread.h"
  20 #include "pipeline.h"
  21
  22 #ifndef THREAD_PIPELINES_MAX
  23 #define THREAD_PIPELINES_MAX                               256
  24 #endif
  25
  26 #ifndef THREAD_MSGQ_SIZE
  27 #define THREAD_MSGQ_SIZE                                   64
  28 #endif
  29
  30 #ifndef THREAD_TIMER_PERIOD_MS
  31 #define THREAD_TIMER_PERIOD_MS                             100
  32 #endif
  33
  34 /**
  35  * Master thead: data plane thread context
  36  */
  37 struct thread {
  38         struct rte_ring *msgq_req;
  39         struct rte_ring *msgq_rsp;
  40
  41         uint32_t enabled;
  42 };
  43
  44 static struct thread thread[RTE_MAX_LCORE];
  45
  46 /**
  47  * Data plane threads: context
  48  */
  49 struct table_data {
  50         struct rte_table_action *a;
  51 };
  52
  53 struct pipeline_data {
  54         struct rte_pipeline *p;
  55         struct table_data table_data[RTE_PIPELINE_TABLE_MAX];
  56         uint32_t n_tables;
  57
  58         struct rte_ring *msgq_req;
  59         struct rte_ring *msgq_rsp;
  60         uint64_t timer_period; /* Measured in CPU cycles. */
  61         uint64_t time_next;
  62
  63         uint8_t buffer[TABLE_RULE_ACTION_SIZE_MAX];
  64 };
  65
  66 struct thread_data {
  67         struct rte_pipeline *p[THREAD_PIPELINES_MAX];
  68         uint32_t n_pipelines;
  69
  70         struct pipeline_data pipeline_data[THREAD_PIPELINES_MAX];
  71         struct rte_ring *msgq_req;
  72         struct rte_ring *msgq_rsp;
  73         uint64_t timer_period; /* Measured in CPU cycles. */
  74         uint64_t time_next;
  75         uint64_t time_next_min;
  76 } __rte_cache_aligned;
  77
  78 static struct thread_data thread_data[RTE_MAX_LCORE];
  79
  80 /**
  81  * Master thread: data plane thread init
  82  */
  83 static void
  84 thread_free(void)
  85 {
  86         uint32_t i;
  87
  88         for (i = 0; i < RTE_MAX_LCORE; i++) {
  89                 struct thread *t = &thread[i];
  90
  91                 if (!rte_lcore_is_enabled(i))
  92                         continue;
  93
  94                 /* MSGQs */
  95                 if (t->msgq_req)
  96                         rte_ring_free(t->msgq_req);
  97
  98                 if (t->msgq_rsp)
  99                         rte_ring_free(t->msgq_rsp);
 100         }
 101 }
 102
 103 int
 104 thread_init(void)
 105 {
 106         uint32_t i;
 107
 108         RTE_LCORE_FOREACH_SLAVE(i) {
 109                 char name[NAME_MAX];
 110                 struct rte_ring *msgq_req, *msgq_rsp;
 111                 struct thread *t = &thread[i];
 112                 struct thread_data *t_data = &thread_data[i];
 113                 uint32_t cpu_id = rte_lcore_to_socket_id(i);
 114
 115                 /* MSGQs */
 116                 snprintf(name, sizeof(name), "THREAD-%04x-MSGQ-REQ", i);
 117
 118                 msgq_req = rte_ring_create(name,
 119                         THREAD_MSGQ_SIZE,
 120                         cpu_id,
 121                         RING_F_SP_ENQ | RING_F_SC_DEQ);
 122
 123                 if (msgq_req == NULL) {
 124                         thread_free();
 125                         return -1;
 126                 }
 127
 128                 snprintf(name, sizeof(name), "THREAD-%04x-MSGQ-RSP", i);
 129
 130                 msgq_rsp = rte_ring_create(name,
 131                         THREAD_MSGQ_SIZE,
 132                         cpu_id,
 133                         RING_F_SP_ENQ | RING_F_SC_DEQ);
 134
 135                 if (msgq_rsp == NULL) {
 136                         thread_free();
 137                         return -1;
 138                 }
 139
 140                 /* Master thread records */
 141                 t->msgq_req = msgq_req;
 142                 t->msgq_rsp = msgq_rsp;
 143                 t->enabled = 1;
 144
 145                 /* Data plane thread records */
 146                 t_data->n_pipelines = 0;
 147                 t_data->msgq_req = msgq_req;
 148                 t_data->msgq_rsp = msgq_rsp;
 149                 t_data->timer_period =
 150                         (rte_get_tsc_hz() * THREAD_TIMER_PERIOD_MS) / 1000;
 151                 t_data->time_next = rte_get_tsc_cycles() + t_data->timer_period;
 152                 t_data->time_next_min = t_data->time_next;
 153         }
 154
 155         return 0;
 156 }
 157
 158 /**
 159  * Master thread & data plane threads: message passing
 160  */
 161 enum thread_req_type {
 162         THREAD_REQ_PIPELINE_ENABLE = 0,
 163         THREAD_REQ_PIPELINE_DISABLE,
 164         THREAD_REQ_MAX
 165 };
 166
 167 struct thread_msg_req {
 168         enum thread_req_type type;
 169
 170         union {
 171                 struct {
 172                         struct rte_pipeline *p;
 173                         struct {
 174                                 struct rte_table_action *a;
 175                         } table[RTE_PIPELINE_TABLE_MAX];
 176                         struct rte_ring *msgq_req;
 177                         struct rte_ring *msgq_rsp;
 178                         uint32_t timer_period_ms;
 179                         uint32_t n_tables;
 180                 } pipeline_enable;
 181
 182                 struct {
 183                         struct rte_pipeline *p;
 184                 } pipeline_disable;
 185         };
 186 };
 187
 188 struct thread_msg_rsp {
 189         int status;
 190 };
 191
 192 /**
 193  * Master thread
 194  */
 195 static struct thread_msg_req *
 196 thread_msg_alloc(void)
 197 {
 198         size_t size = RTE_MAX(sizeof(struct thread_msg_req),
 199                 sizeof(struct thread_msg_rsp));
 200
 201         return calloc(1, size);
 202 }
 203
 204 static void
 205 thread_msg_free(struct thread_msg_rsp *rsp)
 206 {
 207         free(rsp);
 208 }
 209
 210 static struct thread_msg_rsp *
 211 thread_msg_send_recv(uint32_t thread_id,
 212         struct thread_msg_req *req)
 213 {
 214         struct thread *t = &thread[thread_id];
 215         struct rte_ring *msgq_req = t->msgq_req;
 216         struct rte_ring *msgq_rsp = t->msgq_rsp;
 217         struct thread_msg_rsp *rsp;
 218         int status;
 219
 220         /* send */
 221         do {
 222                 status = rte_ring_sp_enqueue(msgq_req, req);
 223         } while (status == -ENOBUFS);
 224
 225         /* recv */
 226         do {
 227                 status = rte_ring_sc_dequeue(msgq_rsp, (void **) &rsp);
 228         } while (status != 0);
 229
 230         return rsp;
 231 }
 232
 233 int
 234 thread_pipeline_enable(uint32_t thread_id,
 235         const char *pipeline_name)
 236 {
 237         struct pipeline *p = pipeline_find(pipeline_name);
 238         struct thread *t;
 239         struct thread_msg_req *req;
 240         struct thread_msg_rsp *rsp;
 241         uint32_t i;
 242         int status;
 243
 244         /* Check input params */
 245         if ((thread_id >= RTE_MAX_LCORE) ||
 246                 (p == NULL) ||
 247                 (p->n_ports_in == 0) ||
 248                 (p->n_ports_out == 0) ||
 249                 (p->n_tables == 0))
 250                 return -1;
 251
 252         t = &thread[thread_id];
 253         if ((t->enabled == 0) ||
 254                 p->enabled)
 255                 return -1;
 256
 257         /* Allocate request */
 258         req = thread_msg_alloc();
 259         if (req == NULL)
 260                 return -1;
 261
 262         /* Write request */
 263         req->type = THREAD_REQ_PIPELINE_ENABLE;
 264         req->pipeline_enable.p = p->p;
 265         for (i = 0; i < p->n_tables; i++)
 266                 req->pipeline_enable.table[i].a =
 267                         p->table[i].a;
 268         req->pipeline_enable.msgq_req = p->msgq_req;
 269         req->pipeline_enable.msgq_rsp = p->msgq_rsp;
 270         req->pipeline_enable.timer_period_ms = p->timer_period_ms;
 271         req->pipeline_enable.n_tables = p->n_tables;
 272
 273         /* Send request and wait for response */
 274         rsp = thread_msg_send_recv(thread_id, req);
 275         if (rsp == NULL)
 276                 return -1;
 277
 278         /* Read response */
 279         status = rsp->status;
 280
 281         /* Free response */
 282         thread_msg_free(rsp);
 283
 284         /* Request completion */
 285         if (status)
 286                 return status;
 287
 288         p->thread_id = thread_id;
 289         p->enabled = 1;
 290
 291         return 0;
 292 }
 293
 294 int
 295 thread_pipeline_disable(uint32_t thread_id,
 296         const char *pipeline_name)
 297 {
 298         struct pipeline *p = pipeline_find(pipeline_name);
 299         struct thread *t;
 300         struct thread_msg_req *req;
 301         struct thread_msg_rsp *rsp;
 302         int status;
 303
 304         /* Check input params */
 305         if ((thread_id >= RTE_MAX_LCORE) ||
 306                 (p == NULL))
 307                 return -1;
 308
 309         t = &thread[thread_id];
 310         if (t->enabled == 0)
 311                 return -1;
 312
 313         if (p->enabled == 0)
 314                 return 0;
 315
 316         if (p->thread_id != thread_id)
 317                 return -1;
 318
 319         /* Allocate request */
 320         req = thread_msg_alloc();
 321         if (req == NULL)
 322                 return -1;
 323
 324         /* Write request */
 325         req->type = THREAD_REQ_PIPELINE_DISABLE;
 326         req->pipeline_disable.p = p->p;
 327
 328         /* Send request and wait for response */
 329         rsp = thread_msg_send_recv(thread_id, req);
 330         if (rsp == NULL)
 331                 return -1;
 332
 333         /* Read response */
 334         status = rsp->status;
 335
 336         /* Free response */
 337         thread_msg_free(rsp);
 338
 339         /* Request completion */
 340         if (status)
 341                 return status;
 342
 343         p->enabled = 0;
 344
 345         return 0;
 346 }
 347
 348 /**
 349  * Data plane threads: message handling
 350  */
 351 static inline struct thread_msg_req *
 352 thread_msg_recv(struct rte_ring *msgq_req)
 353 {
 354         struct thread_msg_req *req;
 355
 356         int status = rte_ring_sc_dequeue(msgq_req, (void **) &req);
 357
 358         if (status != 0)
 359                 return NULL;
 360
 361         return req;
 362 }
 363
 364 static inline void
 365 thread_msg_send(struct rte_ring *msgq_rsp,
 366         struct thread_msg_rsp *rsp)
 367 {
 368         int status;
 369
 370         do {
 371                 status = rte_ring_sp_enqueue(msgq_rsp, rsp);
 372         } while (status == -ENOBUFS);
 373 }
 374
 375 static struct thread_msg_rsp *
 376 thread_msg_handle_pipeline_enable(struct thread_data *t,
 377         struct thread_msg_req *req)
 378 {
 379         struct thread_msg_rsp *rsp = (struct thread_msg_rsp *) req;
 380         struct pipeline_data *p = &t->pipeline_data[t->n_pipelines];
 381         uint32_t i;
 382
 383         /* Request */
 384         if (t->n_pipelines >= THREAD_PIPELINES_MAX) {
 385                 rsp->status = -1;
 386                 return rsp;
 387         }
 388
 389         t->p[t->n_pipelines] = req->pipeline_enable.p;
 390
 391         p->p = req->pipeline_enable.p;
 392         for (i = 0; i < req->pipeline_enable.n_tables; i++)
 393                 p->table_data[i].a =
 394                         req->pipeline_enable.table[i].a;
 395
 396         p->n_tables = req->pipeline_enable.n_tables;
 397
 398         p->msgq_req = req->pipeline_enable.msgq_req;
 399         p->msgq_rsp = req->pipeline_enable.msgq_rsp;
 400         p->timer_period =
 401                 (rte_get_tsc_hz() * req->pipeline_enable.timer_period_ms) / 1000;
 402         p->time_next = rte_get_tsc_cycles() + p->timer_period;
 403
 404         t->n_pipelines++;
 405
 406         /* Response */
 407         rsp->status = 0;
 408         return rsp;
 409 }
 410
 411 static struct thread_msg_rsp *
 412 thread_msg_handle_pipeline_disable(struct thread_data *t,
 413         struct thread_msg_req *req)
 414 {
 415         struct thread_msg_rsp *rsp = (struct thread_msg_rsp *) req;
 416         uint32_t n_pipelines = t->n_pipelines;
 417         struct rte_pipeline *pipeline = req->pipeline_disable.p;
 418         uint32_t i;
 419
 420         /* find pipeline */
 421         for (i = 0; i < n_pipelines; i++) {
 422                 struct pipeline_data *p = &t->pipeline_data[i];
 423
 424                 if (p->p != pipeline)
 425                         continue;
 426
 427                 if (i < n_pipelines - 1) {
 428                         struct rte_pipeline *pipeline_last =
 429                                 t->p[n_pipelines - 1];
 430                         struct pipeline_data *p_last =
 431                                 &t->pipeline_data[n_pipelines - 1];
 432
 433                         t->p[i] = pipeline_last;
 434                         memcpy(p, p_last, sizeof(*p));
 435                 }
 436
 437                 t->n_pipelines--;
 438
 439                 rsp->status = 0;
 440                 return rsp;
 441         }
 442
 443         /* should not get here */
 444         rsp->status = 0;
 445         return rsp;
 446 }
 447
 448 static void
 449 thread_msg_handle(struct thread_data *t)
 450 {
 451         for ( ; ; ) {
 452                 struct thread_msg_req *req;
 453                 struct thread_msg_rsp *rsp;
 454
 455                 req = thread_msg_recv(t->msgq_req);
 456                 if (req == NULL)
 457                         break;
 458
 459                 switch (req->type) {
 460                 case THREAD_REQ_PIPELINE_ENABLE:
 461                         rsp = thread_msg_handle_pipeline_enable(t, req);
 462                         break;
 463
 464                 case THREAD_REQ_PIPELINE_DISABLE:
 465                         rsp = thread_msg_handle_pipeline_disable(t, req);
 466                         break;
 467
 468                 default:
 469                         rsp = (struct thread_msg_rsp *) req;
 470                         rsp->status = -1;
 471                 }
 472
 473                 thread_msg_send(t->msgq_rsp, rsp);
 474         }
 475 }
 476
 477 /**
 478  * Master thread & data plane threads: message passing
 479  */
 480 enum pipeline_req_type {
 481         /* Port IN */
 482         PIPELINE_REQ_PORT_IN_STATS_READ,
 483         PIPELINE_REQ_PORT_IN_ENABLE,
 484         PIPELINE_REQ_PORT_IN_DISABLE,
 485
 486         /* Port OUT */
 487         PIPELINE_REQ_PORT_OUT_STATS_READ,
 488
 489         /* Table */
 490         PIPELINE_REQ_TABLE_STATS_READ,
 491         PIPELINE_REQ_TABLE_RULE_ADD,
 492         PIPELINE_REQ_TABLE_RULE_ADD_DEFAULT,
 493         PIPELINE_REQ_TABLE_RULE_ADD_BULK,
 494         PIPELINE_REQ_TABLE_RULE_DELETE,
 495         PIPELINE_REQ_TABLE_RULE_DELETE_DEFAULT,
 496         PIPELINE_REQ_TABLE_RULE_STATS_READ,
 497         PIPELINE_REQ_TABLE_MTR_PROFILE_ADD,
 498         PIPELINE_REQ_TABLE_MTR_PROFILE_DELETE,
 499         PIPELINE_REQ_TABLE_RULE_MTR_READ,
 500         PIPELINE_REQ_TABLE_DSCP_TABLE_UPDATE,
 501         PIPELINE_REQ_TABLE_RULE_TTL_READ,
 502         PIPELINE_REQ_MAX
 503 };
 504
 505 struct pipeline_msg_req_port_in_stats_read {
 506         int clear;
 507 };
 508
 509 struct pipeline_msg_req_port_out_stats_read {
 510         int clear;
 511 };
 512
 513 struct pipeline_msg_req_table_stats_read {
 514         int clear;
 515 };
 516
 517 struct pipeline_msg_req_table_rule_add {
 518         struct table_rule_match match;
 519         struct table_rule_action action;
 520 };
 521
 522 struct pipeline_msg_req_table_rule_add_default {
 523         struct table_rule_action action;
 524 };
 525
 526 struct pipeline_msg_req_table_rule_add_bulk {
 527         struct table_rule_match *match;
 528         struct table_rule_action *action;
 529         void **data;
 530         uint32_t n_rules;
 531         int bulk;
 532 };
 533
 534 struct pipeline_msg_req_table_rule_delete {
 535         struct table_rule_match match;
 536 };
 537
 538 struct pipeline_msg_req_table_rule_stats_read {
 539         void *data;
 540         int clear;
 541 };
 542
 543 struct pipeline_msg_req_table_mtr_profile_add {
 544         uint32_t meter_profile_id;
 545         struct rte_table_action_meter_profile profile;
 546 };
 547
 548 struct pipeline_msg_req_table_mtr_profile_delete {
 549         uint32_t meter_profile_id;
 550 };
 551
 552 struct pipeline_msg_req_table_rule_mtr_read {
 553         void *data;
 554         uint32_t tc_mask;
 555         int clear;
 556 };
 557
 558 struct pipeline_msg_req_table_dscp_table_update {
 559         uint64_t dscp_mask;
 560         struct rte_table_action_dscp_table dscp_table;
 561 };
 562
 563 struct pipeline_msg_req_table_rule_ttl_read {
 564         void *data;
 565         int clear;
 566 };
 567
 568 struct pipeline_msg_req {
 569         enum pipeline_req_type type;
 570         uint32_t id; /* Port IN, port OUT or table ID */
 571
 572         RTE_STD_C11
 573         union {
 574                 struct pipeline_msg_req_port_in_stats_read port_in_stats_read;
 575                 struct pipeline_msg_req_port_out_stats_read port_out_stats_read;
 576                 struct pipeline_msg_req_table_stats_read table_stats_read;
 577                 struct pipeline_msg_req_table_rule_add table_rule_add;
 578                 struct pipeline_msg_req_table_rule_add_default table_rule_add_default;
 579                 struct pipeline_msg_req_table_rule_add_bulk table_rule_add_bulk;
 580                 struct pipeline_msg_req_table_rule_delete table_rule_delete;
 581                 struct pipeline_msg_req_table_rule_stats_read table_rule_stats_read;
 582                 struct pipeline_msg_req_table_mtr_profile_add table_mtr_profile_add;
 583                 struct pipeline_msg_req_table_mtr_profile_delete table_mtr_profile_delete;
 584                 struct pipeline_msg_req_table_rule_mtr_read table_rule_mtr_read;
 585                 struct pipeline_msg_req_table_dscp_table_update table_dscp_table_update;
 586                 struct pipeline_msg_req_table_rule_ttl_read table_rule_ttl_read;
 587         };
 588 };
 589
 590 struct pipeline_msg_rsp_port_in_stats_read {
 591         struct rte_pipeline_port_in_stats stats;
 592 };
 593
 594 struct pipeline_msg_rsp_port_out_stats_read {
 595         struct rte_pipeline_port_out_stats stats;
 596 };
 597
 598 struct pipeline_msg_rsp_table_stats_read {
 599         struct rte_pipeline_table_stats stats;
 600 };
 601
 602 struct pipeline_msg_rsp_table_rule_add {
 603         void *data;
 604 };
 605
 606 struct pipeline_msg_rsp_table_rule_add_default {
 607         void *data;
 608 };
 609
 610 struct pipeline_msg_rsp_table_rule_add_bulk {
 611         uint32_t n_rules;
 612 };
 613
 614 struct pipeline_msg_rsp_table_rule_stats_read {
 615         struct rte_table_action_stats_counters stats;
 616 };
 617
 618 struct pipeline_msg_rsp_table_rule_mtr_read {
 619         struct rte_table_action_mtr_counters stats;
 620 };
 621
 622 struct pipeline_msg_rsp_table_rule_ttl_read {
 623         struct rte_table_action_ttl_counters stats;
 624 };
 625
 626 struct pipeline_msg_rsp {
 627         int status;
 628
 629         RTE_STD_C11
 630         union {
 631                 struct pipeline_msg_rsp_port_in_stats_read port_in_stats_read;
 632                 struct pipeline_msg_rsp_port_out_stats_read port_out_stats_read;
 633                 struct pipeline_msg_rsp_table_stats_read table_stats_read;
 634                 struct pipeline_msg_rsp_table_rule_add table_rule_add;
 635                 struct pipeline_msg_rsp_table_rule_add_default table_rule_add_default;
 636                 struct pipeline_msg_rsp_table_rule_add_bulk table_rule_add_bulk;
 637                 struct pipeline_msg_rsp_table_rule_stats_read table_rule_stats_read;
 638                 struct pipeline_msg_rsp_table_rule_mtr_read table_rule_mtr_read;
 639                 struct pipeline_msg_rsp_table_rule_ttl_read table_rule_ttl_read;
 640         };
 641 };
 642
 643 /**
 644  * Master thread
 645  */
 646 static struct pipeline_msg_req *
 647 pipeline_msg_alloc(void)
 648 {
 649         size_t size = RTE_MAX(sizeof(struct pipeline_msg_req),
 650                 sizeof(struct pipeline_msg_rsp));
 651
 652         return calloc(1, size);
 653 }
 654
 655 static void
 656 pipeline_msg_free(struct pipeline_msg_rsp *rsp)
 657 {
 658         free(rsp);
 659 }
 660
 661 static struct pipeline_msg_rsp *
 662 pipeline_msg_send_recv(struct pipeline *p,
 663         struct pipeline_msg_req *req)
 664 {
 665         struct rte_ring *msgq_req = p->msgq_req;
 666         struct rte_ring *msgq_rsp = p->msgq_rsp;
 667         struct pipeline_msg_rsp *rsp;
 668         int status;
 669
 670         /* send */
 671         do {
 672                 status = rte_ring_sp_enqueue(msgq_req, req);
 673         } while (status == -ENOBUFS);
 674
 675         /* recv */
 676         do {
 677                 status = rte_ring_sc_dequeue(msgq_rsp, (void **) &rsp);
 678         } while (status != 0);
 679
 680         return rsp;
 681 }
 682
 683 int
 684 pipeline_port_in_stats_read(const char *pipeline_name,
 685         uint32_t port_id,
 686         struct rte_pipeline_port_in_stats *stats,
 687         int clear)
 688 {
 689         struct pipeline *p;
 690         struct pipeline_msg_req *req;
 691         struct pipeline_msg_rsp *rsp;
 692         int status;
 693
 694         /* Check input params */
 695         if ((pipeline_name == NULL) ||
 696                 (stats == NULL))
 697                 return -1;
 698
 699         p = pipeline_find(pipeline_name);
 700         if ((p == NULL) ||
 701                 (p->enabled == 0) ||
 702                 (port_id >= p->n_ports_in))
 703                 return -1;
 704
 705         /* Allocate request */
 706         req = pipeline_msg_alloc();
 707         if (req == NULL)
 708                 return -1;
 709
 710         /* Write request */
 711         req->type = PIPELINE_REQ_PORT_IN_STATS_READ;
 712         req->id = port_id;
 713         req->port_in_stats_read.clear = clear;
 714
 715         /* Send request and wait for response */
 716         rsp = pipeline_msg_send_recv(p, req);
 717         if (rsp == NULL)
 718                 return -1;
 719
 720         /* Read response */
 721         status = rsp->status;
 722         if (status)
 723                 memcpy(stats, &rsp->port_in_stats_read.stats, sizeof(*stats));
 724
 725         /* Free response */
 726         pipeline_msg_free(rsp);
 727
 728         return status;
 729 }
 730
 731 int
 732 pipeline_port_in_enable(const char *pipeline_name,
 733         uint32_t port_id)
 734 {
 735         struct pipeline *p;
 736         struct pipeline_msg_req *req;
 737         struct pipeline_msg_rsp *rsp;
 738         int status;
 739
 740         /* Check input params */
 741         if (pipeline_name == NULL)
 742                 return -1;
 743
 744         p = pipeline_find(pipeline_name);
 745         if ((p == NULL) ||
 746                 (p->enabled == 0) ||
 747                 (port_id >= p->n_ports_in))
 748                 return -1;
 749
 750         /* Allocate request */
 751         req = pipeline_msg_alloc();
 752         if (req == NULL)
 753                 return -1;
 754
 755         /* Write request */
 756         req->type = PIPELINE_REQ_PORT_IN_ENABLE;
 757         req->id = port_id;
 758
 759         /* Send request and wait for response */
 760         rsp = pipeline_msg_send_recv(p, req);
 761         if (rsp == NULL)
 762                 return -1;
 763
 764         /* Read response */
 765         status = rsp->status;
 766
 767         /* Free response */
 768         pipeline_msg_free(rsp);
 769
 770         return status;
 771 }
 772
 773 int
 774 pipeline_port_in_disable(const char *pipeline_name,
 775         uint32_t port_id)
 776 {
 777         struct pipeline *p;
 778         struct pipeline_msg_req *req;
 779         struct pipeline_msg_rsp *rsp;
 780         int status;
 781
 782         /* Check input params */
 783         if (pipeline_name == NULL)
 784                 return -1;
 785
 786         p = pipeline_find(pipeline_name);
 787         if ((p == NULL) ||
 788                 (p->enabled == 0) ||
 789                 (port_id >= p->n_ports_in))
 790                 return -1;
 791
 792         /* Allocate request */
 793         req = pipeline_msg_alloc();
 794         if (req == NULL)
 795                 return -1;
 796
 797         /* Write request */
 798         req->type = PIPELINE_REQ_PORT_IN_DISABLE;
 799         req->id = port_id;
 800
 801         /* Send request and wait for response */
 802         rsp = pipeline_msg_send_recv(p, req);
 803         if (rsp == NULL)
 804                 return -1;
 805
 806         /* Read response */
 807         status = rsp->status;
 808
 809         /* Free response */
 810         pipeline_msg_free(rsp);
 811
 812         return status;
 813 }
 814
 815 int
 816 pipeline_port_out_stats_read(const char *pipeline_name,
 817         uint32_t port_id,
 818         struct rte_pipeline_port_out_stats *stats,
 819         int clear)
 820 {
 821         struct pipeline *p;
 822         struct pipeline_msg_req *req;
 823         struct pipeline_msg_rsp *rsp;
 824         int status;
 825
 826         /* Check input params */
 827         if ((pipeline_name == NULL) ||
 828                 (stats == NULL))
 829                 return -1;
 830
 831         p = pipeline_find(pipeline_name);
 832         if ((p == NULL) ||
 833                 (p->enabled == 0) ||
 834                 (port_id >= p->n_ports_out))
 835                 return -1;
 836
 837         /* Allocate request */
 838         req = pipeline_msg_alloc();
 839         if (req == NULL)
 840                 return -1;
 841
 842         /* Write request */
 843         req->type = PIPELINE_REQ_PORT_OUT_STATS_READ;
 844         req->id = port_id;
 845         req->port_out_stats_read.clear = clear;
 846
 847         /* Send request and wait for response */
 848         rsp = pipeline_msg_send_recv(p, req);
 849         if (rsp == NULL)
 850                 return -1;
 851
 852         /* Read response */
 853         status = rsp->status;
 854         if (status)
 855                 memcpy(stats, &rsp->port_out_stats_read.stats, sizeof(*stats));
 856
 857         /* Free response */
 858         pipeline_msg_free(rsp);
 859
 860         return status;
 861 }
 862
 863 int
 864 pipeline_table_stats_read(const char *pipeline_name,
 865         uint32_t table_id,
 866         struct rte_pipeline_table_stats *stats,
 867         int clear)
 868 {
 869         struct pipeline *p;
 870         struct pipeline_msg_req *req;
 871         struct pipeline_msg_rsp *rsp;
 872         int status;
 873
 874         /* Check input params */
 875         if ((pipeline_name == NULL) ||
 876                 (stats == NULL))
 877                 return -1;
 878
 879         p = pipeline_find(pipeline_name);
 880         if ((p == NULL) ||
 881                 (p->enabled == 0) ||
 882                 (table_id >= p->n_tables))
 883                 return -1;
 884
 885         /* Allocate request */
 886         req = pipeline_msg_alloc();
 887         if (req == NULL)
 888                 return -1;
 889
 890         /* Write request */
 891         req->type = PIPELINE_REQ_TABLE_STATS_READ;
 892         req->id = table_id;
 893         req->table_stats_read.clear = clear;
 894
 895         /* Send request and wait for response */
 896         rsp = pipeline_msg_send_recv(p, req);
 897         if (rsp == NULL)
 898                 return -1;
 899
 900         /* Read response */
 901         status = rsp->status;
 902         if (status)
 903                 memcpy(stats, &rsp->table_stats_read.stats, sizeof(*stats));
 904
 905         /* Free response */
 906         pipeline_msg_free(rsp);
 907
 908         return status;
 909 }
 910
 911 static int
 912 match_check(struct table_rule_match *match,
 913         struct pipeline *p,
 914         uint32_t table_id)
 915 {
 916         struct table *table;
 917
 918         if ((match == NULL) ||
 919                 (p == NULL) ||
 920                 (table_id >= p->n_tables))
 921                 return -1;
 922
 923         table = &p->table[table_id];
 924         if (match->match_type != table->params.match_type)
 925                 return -1;
 926
 927         switch (match->match_type) {
 928         case TABLE_ACL:
 929         {
 930                 struct table_acl_params *t = &table->params.match.acl;
 931                 struct table_rule_match_acl *r = &match->match.acl;
 932
 933                 if ((r->ip_version && (t->ip_version == 0)) ||
 934                         ((r->ip_version == 0) && t->ip_version))
 935                         return -1;
 936
 937                 if (r->ip_version) {
 938                         if ((r->sa_depth > 32) ||
 939                                 (r->da_depth > 32))
 940                                 return -1;
 941                 } else {
 942                         if ((r->sa_depth > 128) ||
 943                                 (r->da_depth > 128))
 944                                 return -1;
 945                 }
 946                 return 0;
 947         }
 948
 949         case TABLE_ARRAY:
 950                 return 0;
 951
 952         case TABLE_HASH:
 953                 return 0;
 954
 955         case TABLE_LPM:
 956         {
 957                 struct table_lpm_params *t = &table->params.match.lpm;
 958                 struct table_rule_match_lpm *r = &match->match.lpm;
 959
 960                 if ((r->ip_version && (t->key_size != 4)) ||
 961                         ((r->ip_version == 0) && (t->key_size != 16)))
 962                         return -1;
 963
 964                 if (r->ip_version) {
 965                         if (r->depth > 32)
 966                                 return -1;
 967                 } else {
 968                         if (r->depth > 128)
 969                                 return -1;
 970                 }
 971                 return 0;
 972         }
 973
 974         case TABLE_STUB:
 975                 return -1;
 976
 977         default:
 978                 return -1;
 979         }
 980 }
 981
 982 static int
 983 action_check(struct table_rule_action *action,
 984         struct pipeline *p,
 985         uint32_t table_id)
 986 {
 987         struct table_action_profile *ap;
 988
 989         if ((action == NULL) ||
 990                 (p == NULL) ||
 991                 (table_id >= p->n_tables))
 992                 return -1;
 993
 994         ap = p->table[table_id].ap;
 995         if (action->action_mask != ap->params.action_mask)
 996                 return -1;
 997
 998         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_FWD)) {
 999                 if ((action->fwd.action == RTE_PIPELINE_ACTION_PORT) &&
1000                         (action->fwd.id >= p->n_ports_out))
1001                         return -1;
1002
1003                 if ((action->fwd.action == RTE_PIPELINE_ACTION_TABLE) &&
1004                         (action->fwd.id >= p->n_tables))
1005                         return -1;
1006         }
1007
1008         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_MTR)) {
1009                 uint32_t tc_mask0 = (1 << ap->params.mtr.n_tc) - 1;
1010                 uint32_t tc_mask1 = action->mtr.tc_mask;
1011
1012                 if (tc_mask1 != tc_mask0)
1013                         return -1;
1014         }
1015
1016         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_TM)) {
1017                 uint32_t n_subports_per_port =
1018                         ap->params.tm.n_subports_per_port;
1019                 uint32_t n_pipes_per_subport =
1020                         ap->params.tm.n_pipes_per_subport;
1021                 uint32_t subport_id = action->tm.subport_id;
1022                 uint32_t pipe_id = action->tm.pipe_id;
1023
1024                 if ((subport_id >= n_subports_per_port) ||
1025                         (pipe_id >= n_pipes_per_subport))
1026                         return -1;
1027         }
1028
1029         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_ENCAP)) {
1030                 uint64_t encap_mask = ap->params.encap.encap_mask;
1031                 enum rte_table_action_encap_type type = action->encap.type;
1032
1033                 if ((encap_mask & (1LLU << type)) == 0)
1034                         return -1;
1035         }
1036
1037         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_NAT)) {
1038                 int ip_version0 = ap->params.common.ip_version;
1039                 int ip_version1 = action->nat.ip_version;
1040
1041                 if ((ip_version1 && (ip_version0 == 0)) ||
1042                         ((ip_version1 == 0) && ip_version0))
1043                         return -1;
1044         }
1045
1046         return 0;
1047 }
1048
1049 static int
1050 action_default_check(struct table_rule_action *action,
1051         struct pipeline *p,
1052         uint32_t table_id)
1053 {
1054         if ((action == NULL) ||
1055                 (action->action_mask != (1LLU << RTE_TABLE_ACTION_FWD)) ||
1056                 (p == NULL) ||
1057                 (table_id >= p->n_tables))
1058                 return -1;
1059
1060         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_FWD)) {
1061                 if ((action->fwd.action == RTE_PIPELINE_ACTION_PORT) &&
1062                         (action->fwd.id >= p->n_ports_out))
1063                         return -1;
1064
1065                 if ((action->fwd.action == RTE_PIPELINE_ACTION_TABLE) &&
1066                         (action->fwd.id >= p->n_tables))
1067                         return -1;
1068         }
1069
1070         return 0;
1071 }
1072
1073 int
1074 pipeline_table_rule_add(const char *pipeline_name,
1075         uint32_t table_id,
1076         struct table_rule_match *match,
1077         struct table_rule_action *action,
1078         void **data)
1079 {
1080         struct pipeline *p;
1081         struct pipeline_msg_req *req;
1082         struct pipeline_msg_rsp *rsp;
1083         int status;
1084
1085         /* Check input params */
1086         if ((pipeline_name == NULL) ||
1087                 (match == NULL) ||
1088                 (action == NULL) ||
1089                 (data == NULL))
1090                 return -1;
1091
1092         p = pipeline_find(pipeline_name);
1093         if ((p == NULL) ||
1094                 (p->enabled == 0) ||
1095                 (table_id >= p->n_tables) ||
1096                 match_check(match, p, table_id) ||
1097                 action_check(action, p, table_id))
1098                 return -1;
1099
1100         /* Allocate request */
1101         req = pipeline_msg_alloc();
1102         if (req == NULL)
1103                 return -1;
1104
1105         /* Write request */
1106         req->type = PIPELINE_REQ_TABLE_RULE_ADD;
1107         req->id = table_id;
1108         memcpy(&req->table_rule_add.match, match, sizeof(*match));
1109         memcpy(&req->table_rule_add.action, action, sizeof(*action));
1110
1111         /* Send request and wait for response */
1112         rsp = pipeline_msg_send_recv(p, req);
1113         if (rsp == NULL)
1114                 return -1;
1115
1116         /* Read response */
1117         status = rsp->status;
1118         if (status == 0)
1119                 *data = rsp->table_rule_add.data;
1120
1121         /* Free response */
1122         pipeline_msg_free(rsp);
1123
1124         return status;
1125 }
1126
1127 int
1128 pipeline_table_rule_add_default(const char *pipeline_name,
1129         uint32_t table_id,
1130         struct table_rule_action *action,
1131         void **data)
1132 {
1133         struct pipeline *p;
1134         struct pipeline_msg_req *req;
1135         struct pipeline_msg_rsp *rsp;
1136         int status;
1137
1138         /* Check input params */
1139         if ((pipeline_name == NULL) ||
1140                 (action == NULL) ||
1141                 (data == NULL))
1142                 return -1;
1143
1144         p = pipeline_find(pipeline_name);
1145         if ((p == NULL) ||
1146                 (p->enabled == 0) ||
1147                 (table_id >= p->n_tables) ||
1148                 action_default_check(action, p, table_id))
1149                 return -1;
1150
1151         /* Allocate request */
1152         req = pipeline_msg_alloc();
1153         if (req == NULL)
1154                 return -1;
1155
1156         /* Write request */
1157         req->type = PIPELINE_REQ_TABLE_RULE_ADD_DEFAULT;
1158         req->id = table_id;
1159         memcpy(&req->table_rule_add_default.action, action, sizeof(*action));
1160
1161         /* Send request and wait for response */
1162         rsp = pipeline_msg_send_recv(p, req);
1163         if (rsp == NULL)
1164                 return -1;
1165
1166         /* Read response */
1167         status = rsp->status;
1168         if (status == 0)
1169                 *data = rsp->table_rule_add_default.data;
1170
1171         /* Free response */
1172         pipeline_msg_free(rsp);
1173
1174         return status;
1175 }
1176
1177 int
1178 pipeline_table_rule_add_bulk(const char *pipeline_name,
1179         uint32_t table_id,
1180         struct table_rule_match *match,
1181         struct table_rule_action *action,
1182         void **data,
1183         uint32_t *n_rules)
1184 {
1185         struct pipeline *p;
1186         struct pipeline_msg_req *req;
1187         struct pipeline_msg_rsp *rsp;
1188         uint32_t i;
1189         int status;
1190
1191         /* Check input params */
1192         if ((pipeline_name == NULL) ||
1193                 (match == NULL) ||
1194                 (action == NULL) ||
1195                 (data == NULL) ||
1196                 (n_rules == NULL) ||
1197                 (*n_rules == 0))
1198                 return -1;
1199
1200         p = pipeline_find(pipeline_name);
1201         if ((p == NULL) ||
1202                 (p->enabled == 0) ||
1203                 (table_id >= p->n_tables))
1204                 return -1;
1205
1206         for (i = 0; i < *n_rules; i++)
1207                 if (match_check(match, p, table_id) ||
1208                         action_check(action, p, table_id))
1209                         return -1;
1210
1211         /* Allocate request */
1212         req = pipeline_msg_alloc();
1213         if (req == NULL)
1214                 return -1;
1215
1216         /* Write request */
1217         req->type = PIPELINE_REQ_TABLE_RULE_ADD_BULK;
1218         req->id = table_id;
1219         req->table_rule_add_bulk.match = match;
1220         req->table_rule_add_bulk.action = action;
1221         req->table_rule_add_bulk.data = data;
1222         req->table_rule_add_bulk.n_rules = *n_rules;
1223         req->table_rule_add_bulk.bulk =
1224                 (p->table[table_id].params.match_type == TABLE_ACL) ? 1 : 0;
1225
1226         /* Send request and wait for response */
1227         rsp = pipeline_msg_send_recv(p, req);
1228         if (rsp == NULL)
1229                 return -1;
1230
1231         /* Read response */
1232         status = rsp->status;
1233         if (status == 0)
1234                 *n_rules = rsp->table_rule_add_bulk.n_rules;
1235
1236         /* Free response */
1237         pipeline_msg_free(rsp);
1238
1239         return status;
1240 }
1241
1242 int
1243 pipeline_table_rule_delete(const char *pipeline_name,
1244         uint32_t table_id,
1245         struct table_rule_match *match)
1246 {
1247         struct pipeline *p;
1248         struct pipeline_msg_req *req;
1249         struct pipeline_msg_rsp *rsp;
1250         int status;
1251
1252         /* Check input params */
1253         if ((pipeline_name == NULL) ||
1254                 (match == NULL))
1255                 return -1;
1256
1257         p = pipeline_find(pipeline_name);
1258         if ((p == NULL) ||
1259                 (p->enabled == 0) ||
1260                 (table_id >= p->n_tables) ||
1261                 match_check(match, p, table_id))
1262                 return -1;
1263
1264         /* Allocate request */
1265         req = pipeline_msg_alloc();
1266         if (req == NULL)
1267                 return -1;
1268
1269         /* Write request */
1270         req->type = PIPELINE_REQ_TABLE_RULE_DELETE;
1271         req->id = table_id;
1272         memcpy(&req->table_rule_delete.match, match, sizeof(*match));
1273
1274         /* Send request and wait for response */
1275         rsp = pipeline_msg_send_recv(p, req);
1276         if (rsp == NULL)
1277                 return -1;
1278
1279         /* Read response */
1280         status = rsp->status;
1281
1282         /* Free response */
1283         pipeline_msg_free(rsp);
1284
1285         return status;
1286 }
1287
1288 int
1289 pipeline_table_rule_delete_default(const char *pipeline_name,
1290         uint32_t table_id)
1291 {
1292         struct pipeline *p;
1293         struct pipeline_msg_req *req;
1294         struct pipeline_msg_rsp *rsp;
1295         int status;
1296
1297         /* Check input params */
1298         if (pipeline_name == NULL)
1299                 return -1;
1300
1301         p = pipeline_find(pipeline_name);
1302         if ((p == NULL) ||
1303                 (p->enabled == 0) ||
1304                 (table_id >= p->n_tables))
1305                 return -1;
1306
1307         /* Allocate request */
1308         req = pipeline_msg_alloc();
1309         if (req == NULL)
1310                 return -1;
1311
1312         /* Write request */
1313         req->type = PIPELINE_REQ_TABLE_RULE_DELETE_DEFAULT;
1314         req->id = table_id;
1315
1316         /* Send request and wait for response */
1317         rsp = pipeline_msg_send_recv(p, req);
1318         if (rsp == NULL)
1319                 return -1;
1320
1321         /* Read response */
1322         status = rsp->status;
1323
1324         /* Free response */
1325         pipeline_msg_free(rsp);
1326
1327         return status;
1328 }
1329
1330 int
1331 pipeline_table_rule_stats_read(const char *pipeline_name,
1332         uint32_t table_id,
1333         void *data,
1334         struct rte_table_action_stats_counters *stats,
1335         int clear)
1336 {
1337         struct pipeline *p;
1338         struct pipeline_msg_req *req;
1339         struct pipeline_msg_rsp *rsp;
1340         int status;
1341
1342         /* Check input params */
1343         if ((pipeline_name == NULL) ||
1344                 (data == NULL) ||
1345                 (stats == NULL))
1346                 return -1;
1347
1348         p = pipeline_find(pipeline_name);
1349         if ((p == NULL) ||
1350                 (p->enabled == 0) ||
1351                 (table_id >= p->n_tables))
1352                 return -1;
1353
1354         /* Allocate request */
1355         req = pipeline_msg_alloc();
1356         if (req == NULL)
1357                 return -1;
1358
1359         /* Write request */
1360         req->type = PIPELINE_REQ_TABLE_RULE_STATS_READ;
1361         req->id = table_id;
1362         req->table_rule_stats_read.data = data;
1363         req->table_rule_stats_read.clear = clear;
1364
1365         /* Send request and wait for response */
1366         rsp = pipeline_msg_send_recv(p, req);
1367         if (rsp == NULL)
1368                 return -1;
1369
1370         /* Read response */
1371         status = rsp->status;
1372         if (status)
1373                 memcpy(stats, &rsp->table_rule_stats_read.stats, sizeof(*stats));
1374
1375         /* Free response */
1376         pipeline_msg_free(rsp);
1377
1378         return status;
1379 }
1380
1381 int
1382 pipeline_table_mtr_profile_add(const char *pipeline_name,
1383         uint32_t table_id,
1384         uint32_t meter_profile_id,
1385         struct rte_table_action_meter_profile *profile)
1386 {
1387         struct pipeline *p;
1388         struct pipeline_msg_req *req;
1389         struct pipeline_msg_rsp *rsp;
1390         int status;
1391
1392         /* Check input params */
1393         if ((pipeline_name == NULL) ||
1394                 (profile == NULL))
1395                 return -1;
1396
1397         p = pipeline_find(pipeline_name);
1398         if ((p == NULL) ||
1399                 (p->enabled == 0) ||
1400                 (table_id >= p->n_tables))
1401                 return -1;
1402
1403         /* Allocate request */
1404         req = pipeline_msg_alloc();
1405         if (req == NULL)
1406                 return -1;
1407
1408         /* Write request */
1409         req->type = PIPELINE_REQ_TABLE_MTR_PROFILE_ADD;
1410         req->id = table_id;
1411         req->table_mtr_profile_add.meter_profile_id = meter_profile_id;
1412         memcpy(&req->table_mtr_profile_add.profile, profile, sizeof(*profile));
1413
1414         /* Send request and wait for response */
1415         rsp = pipeline_msg_send_recv(p, req);
1416         if (rsp == NULL)
1417                 return -1;
1418
1419         /* Read response */
1420         status = rsp->status;
1421
1422         /* Free response */
1423         pipeline_msg_free(rsp);
1424
1425         return status;
1426 }
1427
1428 int
1429 pipeline_table_mtr_profile_delete(const char *pipeline_name,
1430         uint32_t table_id,
1431         uint32_t meter_profile_id)
1432 {
1433         struct pipeline *p;
1434         struct pipeline_msg_req *req;
1435         struct pipeline_msg_rsp *rsp;
1436         int status;
1437
1438         /* Check input params */
1439         if (pipeline_name == NULL)
1440                 return -1;
1441
1442         p = pipeline_find(pipeline_name);
1443         if ((p == NULL) ||
1444                 (p->enabled == 0) ||
1445                 (table_id >= p->n_tables))
1446                 return -1;
1447
1448         /* Allocate request */
1449         req = pipeline_msg_alloc();
1450         if (req == NULL)
1451                 return -1;
1452
1453         /* Write request */
1454         req->type = PIPELINE_REQ_TABLE_MTR_PROFILE_DELETE;
1455         req->id = table_id;
1456         req->table_mtr_profile_delete.meter_profile_id = meter_profile_id;
1457
1458         /* Send request and wait for response */
1459         rsp = pipeline_msg_send_recv(p, req);
1460         if (rsp == NULL)
1461                 return -1;
1462
1463         /* Read response */
1464         status = rsp->status;
1465
1466         /* Free response */
1467         pipeline_msg_free(rsp);
1468
1469         return status;
1470 }
1471
1472 int
1473 pipeline_table_rule_mtr_read(const char *pipeline_name,
1474         uint32_t table_id,
1475         void *data,
1476         uint32_t tc_mask,
1477         struct rte_table_action_mtr_counters *stats,
1478         int clear)
1479 {
1480         struct pipeline *p;
1481         struct pipeline_msg_req *req;
1482         struct pipeline_msg_rsp *rsp;
1483         int status;
1484
1485         /* Check input params */
1486         if ((pipeline_name == NULL) ||
1487                 (data == NULL) ||
1488                 (stats == NULL))
1489                 return -1;
1490
1491         p = pipeline_find(pipeline_name);
1492         if ((p == NULL) ||
1493                 (p->enabled == 0) ||
1494                 (table_id >= p->n_tables))
1495                 return -1;
1496
1497         /* Allocate request */
1498         req = pipeline_msg_alloc();
1499         if (req == NULL)
1500                 return -1;
1501
1502         /* Write request */
1503         req->type = PIPELINE_REQ_TABLE_RULE_MTR_READ;
1504         req->id = table_id;
1505         req->table_rule_mtr_read.data = data;
1506         req->table_rule_mtr_read.tc_mask = tc_mask;
1507         req->table_rule_mtr_read.clear = clear;
1508
1509         /* Send request and wait for response */
1510         rsp = pipeline_msg_send_recv(p, req);
1511         if (rsp == NULL)
1512                 return -1;
1513
1514         /* Read response */
1515         status = rsp->status;
1516         if (status)
1517                 memcpy(stats, &rsp->table_rule_mtr_read.stats, sizeof(*stats));
1518
1519         /* Free response */
1520         pipeline_msg_free(rsp);
1521
1522         return status;
1523 }
1524
1525 int
1526 pipeline_table_dscp_table_update(const char *pipeline_name,
1527         uint32_t table_id,
1528         uint64_t dscp_mask,
1529         struct rte_table_action_dscp_table *dscp_table)
1530 {
1531         struct pipeline *p;
1532         struct pipeline_msg_req *req;
1533         struct pipeline_msg_rsp *rsp;
1534         int status;
1535
1536         /* Check input params */
1537         if ((pipeline_name == NULL) ||
1538                 (dscp_table == NULL))
1539                 return -1;
1540
1541         p = pipeline_find(pipeline_name);
1542         if ((p == NULL) ||
1543                 (p->enabled == 0) ||
1544                 (table_id >= p->n_tables))
1545                 return -1;
1546
1547         /* Allocate request */
1548         req = pipeline_msg_alloc();
1549         if (req == NULL)
1550                 return -1;
1551
1552         /* Write request */
1553         req->type = PIPELINE_REQ_TABLE_DSCP_TABLE_UPDATE;
1554         req->id = table_id;
1555         req->table_dscp_table_update.dscp_mask = dscp_mask;
1556         memcpy(&req->table_dscp_table_update.dscp_table,
1557                 dscp_table, sizeof(*dscp_table));
1558
1559         /* Send request and wait for response */
1560         rsp = pipeline_msg_send_recv(p, req);
1561         if (rsp == NULL)
1562                 return -1;
1563
1564         /* Read response */
1565         status = rsp->status;
1566
1567         /* Free response */
1568         pipeline_msg_free(rsp);
1569
1570         return status;
1571 }
1572
1573 int
1574 pipeline_table_rule_ttl_read(const char *pipeline_name,
1575         uint32_t table_id,
1576         void *data,
1577         struct rte_table_action_ttl_counters *stats,
1578         int clear)
1579 {
1580         struct pipeline *p;
1581         struct pipeline_msg_req *req;
1582         struct pipeline_msg_rsp *rsp;
1583         int status;
1584
1585         /* Check input params */
1586         if ((pipeline_name == NULL) ||
1587                 (data == NULL) ||
1588                 (stats == NULL))
1589                 return -1;
1590
1591         p = pipeline_find(pipeline_name);
1592         if ((p == NULL) ||
1593                 (p->enabled == 0) ||
1594                 (table_id >= p->n_tables))
1595                 return -1;
1596
1597         /* Allocate request */
1598         req = pipeline_msg_alloc();
1599         if (req == NULL)
1600                 return -1;
1601
1602         /* Write request */
1603         req->type = PIPELINE_REQ_TABLE_RULE_TTL_READ;
1604         req->id = table_id;
1605         req->table_rule_ttl_read.data = data;
1606         req->table_rule_ttl_read.clear = clear;
1607
1608         /* Send request and wait for response */
1609         rsp = pipeline_msg_send_recv(p, req);
1610         if (rsp == NULL)
1611                 return -1;
1612
1613         /* Read response */
1614         status = rsp->status;
1615         if (status)
1616                 memcpy(stats, &rsp->table_rule_ttl_read.stats, sizeof(*stats));
1617
1618         /* Free response */
1619         pipeline_msg_free(rsp);
1620
1621         return status;
1622 }
1623
1624 /**
1625  * Data plane threads: message handling
1626  */
1627 static inline struct pipeline_msg_req *
1628 pipeline_msg_recv(struct rte_ring *msgq_req)
1629 {
1630         struct pipeline_msg_req *req;
1631
1632         int status = rte_ring_sc_dequeue(msgq_req, (void **) &req);
1633
1634         if (status != 0)
1635                 return NULL;
1636
1637         return req;
1638 }
1639
1640 static inline void
1641 pipeline_msg_send(struct rte_ring *msgq_rsp,
1642         struct pipeline_msg_rsp *rsp)
1643 {
1644         int status;
1645
1646         do {
1647                 status = rte_ring_sp_enqueue(msgq_rsp, rsp);
1648         } while (status == -ENOBUFS);
1649 }
1650
1651 static struct pipeline_msg_rsp *
1652 pipeline_msg_handle_port_in_stats_read(struct pipeline_data *p,
1653         struct pipeline_msg_req *req)
1654 {
1655         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
1656         uint32_t port_id = req->id;
1657         int clear = req->port_in_stats_read.clear;
1658
1659         rsp->status = rte_pipeline_port_in_stats_read(p->p,
1660                 port_id,
1661                 &rsp->port_in_stats_read.stats,
1662                 clear);
1663
1664         return rsp;
1665 }
1666
1667 static struct pipeline_msg_rsp *
1668 pipeline_msg_handle_port_in_enable(struct pipeline_data *p,
1669         struct pipeline_msg_req *req)
1670 {
1671         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
1672         uint32_t port_id = req->id;
1673
1674         rsp->status = rte_pipeline_port_in_enable(p->p,
1675                 port_id);
1676
1677         return rsp;
1678 }
1679
1680 static struct pipeline_msg_rsp *
1681 pipeline_msg_handle_port_in_disable(struct pipeline_data *p,
1682         struct pipeline_msg_req *req)
1683 {
1684         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
1685         uint32_t port_id = req->id;
1686
1687         rsp->status = rte_pipeline_port_in_disable(p->p,
1688                 port_id);
1689
1690         return rsp;
1691 }
1692
1693 static struct pipeline_msg_rsp *
1694 pipeline_msg_handle_port_out_stats_read(struct pipeline_data *p,
1695         struct pipeline_msg_req *req)
1696 {
1697         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
1698         uint32_t port_id = req->id;
1699         int clear = req->port_out_stats_read.clear;
1700
1701         rsp->status = rte_pipeline_port_out_stats_read(p->p,
1702                 port_id,
1703                 &rsp->port_out_stats_read.stats,
1704                 clear);
1705
1706         return rsp;
1707 }
1708
1709 static struct pipeline_msg_rsp *
1710 pipeline_msg_handle_table_stats_read(struct pipeline_data *p,
1711         struct pipeline_msg_req *req)
1712 {
1713         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
1714         uint32_t port_id = req->id;
1715         int clear = req->table_stats_read.clear;
1716
1717         rsp->status = rte_pipeline_table_stats_read(p->p,
1718                 port_id,
1719                 &rsp->table_stats_read.stats,
1720                 clear);
1721
1722         return rsp;
1723 }
1724
1725 union table_rule_match_low_level {
1726         struct rte_table_acl_rule_add_params acl_add;
1727         struct rte_table_acl_rule_delete_params acl_delete;
1728         struct rte_table_array_key array;
1729         uint8_t hash[TABLE_RULE_MATCH_SIZE_MAX];
1730         struct rte_table_lpm_key lpm_ipv4;
1731         struct rte_table_lpm_ipv6_key lpm_ipv6;
1732 };
1733
1734 static int
1735 match_convert_ipv6_depth(uint32_t depth, uint32_t *depth32)
1736 {
1737         if (depth > 128)
1738                 return -1;
1739
1740         switch (depth / 32) {
1741         case 0:
1742                 depth32[0] = depth;
1743                 depth32[1] = 0;
1744                 depth32[2] = 0;
1745                 depth32[3] = 0;
1746                 return 0;
1747
1748         case 1:
1749                 depth32[0] = 32;
1750                 depth32[1] = depth - 32;
1751                 depth32[2] = 0;
1752                 depth32[3] = 0;
1753                 return 0;
1754
1755         case 2:
1756                 depth32[0] = 32;
1757                 depth32[1] = 32;
1758                 depth32[2] = depth - 64;
1759                 depth32[3] = 0;
1760                 return 0;
1761
1762         case 3:
1763                 depth32[0] = 32;
1764                 depth32[1] = 32;
1765                 depth32[2] = 32;
1766                 depth32[3] = depth - 96;
1767                 return 0;
1768
1769         case 4:
1770                 depth32[0] = 32;
1771                 depth32[1] = 32;
1772                 depth32[2] = 32;
1773                 depth32[3] = 32;
1774                 return 0;
1775
1776         default:
1777                 return -1;
1778         }
1779 }
1780
1781 static int
1782 match_convert(struct table_rule_match *mh,
1783         union table_rule_match_low_level *ml,
1784         int add)
1785 {
1786         memset(ml, 0, sizeof(*ml));
1787
1788         switch (mh->match_type) {
1789         case TABLE_ACL:
1790                 if (mh->match.acl.ip_version)
1791                         if (add) {
1792                                 ml->acl_add.field_value[0].value.u8 =
1793                                         mh->match.acl.proto;
1794                                 ml->acl_add.field_value[0].mask_range.u8 =
1795                                         mh->match.acl.proto_mask;
1796
1797                                 ml->acl_add.field_value[1].value.u32 =
1798                                         mh->match.acl.ipv4.sa;
1799                                 ml->acl_add.field_value[1].mask_range.u32 =
1800                                         mh->match.acl.sa_depth;
1801
1802                                 ml->acl_add.field_value[2].value.u32 =
1803                                         mh->match.acl.ipv4.da;
1804                                 ml->acl_add.field_value[2].mask_range.u32 =
1805                                         mh->match.acl.da_depth;
1806
1807                                 ml->acl_add.field_value[3].value.u16 =
1808                                         mh->match.acl.sp0;
1809                                 ml->acl_add.field_value[3].mask_range.u16 =
1810                                         mh->match.acl.sp1;
1811
1812                                 ml->acl_add.field_value[4].value.u16 =
1813                                         mh->match.acl.dp0;
1814                                 ml->acl_add.field_value[4].mask_range.u16 =
1815                                         mh->match.acl.dp1;
1816
1817                                 ml->acl_add.priority =
1818                                         (int32_t) mh->match.acl.priority;
1819                         } else {
1820                                 ml->acl_delete.field_value[0].value.u8 =
1821                                         mh->match.acl.proto;
1822                                 ml->acl_delete.field_value[0].mask_range.u8 =
1823                                         mh->match.acl.proto_mask;
1824
1825                                 ml->acl_delete.field_value[1].value.u32 =
1826                                         mh->match.acl.ipv4.sa;
1827                                 ml->acl_delete.field_value[1].mask_range.u32 =
1828                                         mh->match.acl.sa_depth;
1829
1830                                 ml->acl_delete.field_value[2].value.u32 =
1831                                         mh->match.acl.ipv4.da;
1832                                 ml->acl_delete.field_value[2].mask_range.u32 =
1833                                         mh->match.acl.da_depth;
1834
1835                                 ml->acl_delete.field_value[3].value.u16 =
1836                                         mh->match.acl.sp0;
1837                                 ml->acl_delete.field_value[3].mask_range.u16 =
1838                                         mh->match.acl.sp1;
1839
1840                                 ml->acl_delete.field_value[4].value.u16 =
1841                                         mh->match.acl.dp0;
1842                                 ml->acl_delete.field_value[4].mask_range.u16 =
1843                                         mh->match.acl.dp1;
1844                         }
1845                 else
1846                         if (add) {
1847                                 uint32_t *sa32 =
1848                                         (uint32_t *) mh->match.acl.ipv6.sa;
1849                                 uint32_t *da32 =
1850                                         (uint32_t *) mh->match.acl.ipv6.da;
1851                                 uint32_t sa32_depth[4], da32_depth[4];
1852                                 int status;
1853
1854                                 status = match_convert_ipv6_depth(
1855                                         mh->match.acl.sa_depth,
1856                                         sa32_depth);
1857                                 if (status)
1858                                         return status;
1859
1860                                 status = match_convert_ipv6_depth(
1861                                         mh->match.acl.da_depth,
1862                                         da32_depth);
1863                                 if (status)
1864                                         return status;
1865
1866                                 ml->acl_add.field_value[0].value.u8 =
1867                                         mh->match.acl.proto;
1868                                 ml->acl_add.field_value[0].mask_range.u8 =
1869                                         mh->match.acl.proto_mask;
1870
1871                                 ml->acl_add.field_value[1].value.u32 = sa32[0];
1872                                 ml->acl_add.field_value[1].mask_range.u32 =
1873                                         sa32_depth[0];
1874                                 ml->acl_add.field_value[2].value.u32 = sa32[1];
1875                                 ml->acl_add.field_value[2].mask_range.u32 =
1876                                         sa32_depth[1];
1877                                 ml->acl_add.field_value[3].value.u32 = sa32[2];
1878                                 ml->acl_add.field_value[3].mask_range.u32 =
1879                                         sa32_depth[2];
1880                                 ml->acl_add.field_value[4].value.u32 = sa32[3];
1881                                 ml->acl_add.field_value[4].mask_range.u32 =
1882                                         sa32_depth[3];
1883
1884                                 ml->acl_add.field_value[5].value.u32 = da32[0];
1885                                 ml->acl_add.field_value[5].mask_range.u32 =
1886                                         da32_depth[0];
1887                                 ml->acl_add.field_value[6].value.u32 = da32[1];
1888                                 ml->acl_add.field_value[6].mask_range.u32 =
1889                                         da32_depth[1];
1890                                 ml->acl_add.field_value[7].value.u32 = da32[2];
1891                                 ml->acl_add.field_value[7].mask_range.u32 =
1892                                         da32_depth[2];
1893                                 ml->acl_add.field_value[8].value.u32 = da32[3];
1894                                 ml->acl_add.field_value[8].mask_range.u32 =
1895                                         da32_depth[3];
1896
1897                                 ml->acl_add.field_value[9].value.u16 =
1898                                         mh->match.acl.sp0;
1899                                 ml->acl_add.field_value[9].mask_range.u16 =
1900                                         mh->match.acl.sp1;
1901
1902                                 ml->acl_add.field_value[10].value.u16 =
1903                                         mh->match.acl.dp0;
1904                                 ml->acl_add.field_value[10].mask_range.u16 =
1905                                         mh->match.acl.dp1;
1906
1907                                 ml->acl_add.priority =
1908                                         (int32_t) mh->match.acl.priority;
1909                         } else {
1910                                 uint32_t *sa32 =
1911                                         (uint32_t *) mh->match.acl.ipv6.sa;
1912                                 uint32_t *da32 =
1913                                         (uint32_t *) mh->match.acl.ipv6.da;
1914                                 uint32_t sa32_depth[4], da32_depth[4];
1915                                 int status;
1916
1917                                 status = match_convert_ipv6_depth(
1918                                         mh->match.acl.sa_depth,
1919                                         sa32_depth);
1920                                 if (status)
1921                                         return status;
1922
1923                                 status = match_convert_ipv6_depth(
1924                                         mh->match.acl.da_depth,
1925                                         da32_depth);
1926                                 if (status)
1927                                         return status;
1928
1929                                 ml->acl_delete.field_value[0].value.u8 =
1930                                         mh->match.acl.proto;
1931                                 ml->acl_delete.field_value[0].mask_range.u8 =
1932                                         mh->match.acl.proto_mask;
1933
1934                                 ml->acl_delete.field_value[1].value.u32 =
1935                                         sa32[0];
1936                                 ml->acl_delete.field_value[1].mask_range.u32 =
1937                                         sa32_depth[0];
1938                                 ml->acl_delete.field_value[2].value.u32 =
1939                                         sa32[1];
1940                                 ml->acl_delete.field_value[2].mask_range.u32 =
1941                                         sa32_depth[1];
1942                                 ml->acl_delete.field_value[3].value.u32 =
1943                                         sa32[2];
1944                                 ml->acl_delete.field_value[3].mask_range.u32 =
1945                                         sa32_depth[2];
1946                                 ml->acl_delete.field_value[4].value.u32 =
1947                                         sa32[3];
1948                                 ml->acl_delete.field_value[4].mask_range.u32 =
1949                                         sa32_depth[3];
1950
1951                                 ml->acl_delete.field_value[5].value.u32 =
1952                                         da32[0];
1953                                 ml->acl_delete.field_value[5].mask_range.u32 =
1954                                         da32_depth[0];
1955                                 ml->acl_delete.field_value[6].value.u32 =
1956                                         da32[1];
1957                                 ml->acl_delete.field_value[6].mask_range.u32 =
1958                                         da32_depth[1];
1959                                 ml->acl_delete.field_value[7].value.u32 =
1960                                         da32[2];
1961                                 ml->acl_delete.field_value[7].mask_range.u32 =
1962                                         da32_depth[2];
1963                                 ml->acl_delete.field_value[8].value.u32 =
1964                                         da32[3];
1965                                 ml->acl_delete.field_value[8].mask_range.u32 =
1966                                         da32_depth[3];
1967
1968                                 ml->acl_delete.field_value[9].value.u16 =
1969                                         mh->match.acl.sp0;
1970                                 ml->acl_delete.field_value[9].mask_range.u16 =
1971                                         mh->match.acl.sp1;
1972
1973                                 ml->acl_delete.field_value[10].value.u16 =
1974                                         mh->match.acl.dp0;
1975                                 ml->acl_delete.field_value[10].mask_range.u16 =
1976                                         mh->match.acl.dp1;
1977                         }
1978                 return 0;
1979
1980         case TABLE_ARRAY:
1981                 ml->array.pos = mh->match.array.pos;
1982                 return 0;
1983
1984         case TABLE_HASH:
1985                 memcpy(ml->hash, mh->match.hash.key, sizeof(ml->hash));
1986                 return 0;
1987
1988         case TABLE_LPM:
1989                 if (mh->match.lpm.ip_version) {
1990                         ml->lpm_ipv4.ip = mh->match.lpm.ipv4;
1991                         ml->lpm_ipv4.depth = mh->match.lpm.depth;
1992                 } else {
1993                         memcpy(ml->lpm_ipv6.ip,
1994                                 mh->match.lpm.ipv6, sizeof(ml->lpm_ipv6.ip));
1995                         ml->lpm_ipv6.depth = mh->match.lpm.depth;
1996                 }
1997
1998                 return 0;
1999
2000         default:
2001                 return -1;
2002         }
2003 }
2004
2005 static struct pipeline_msg_rsp *
2006 pipeline_msg_handle_table_rule_add(struct pipeline_data *p,
2007         struct pipeline_msg_req *req)
2008 {
2009         union table_rule_match_low_level match_ll;
2010         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2011         struct table_rule_match *match = &req->table_rule_add.match;
2012         struct table_rule_action *action = &req->table_rule_add.action;
2013         struct rte_pipeline_table_entry *data_in, *data_out;
2014         uint32_t table_id = req->id;
2015         int key_found, status;
2016         struct rte_table_action *a = p->table_data[table_id].a;
2017
2018         /* Apply actions */
2019         memset(p->buffer, 0, sizeof(p->buffer));
2020         data_in = (struct rte_pipeline_table_entry *) p->buffer;
2021
2022         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_FWD)) {
2023                 status = rte_table_action_apply(a,
2024                         data_in,
2025                         RTE_TABLE_ACTION_FWD,
2026                         &action->fwd);
2027
2028                 if (status) {
2029                         rsp->status = -1;
2030                         return rsp;
2031                 }
2032         }
2033
2034         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_LB)) {
2035                 status = rte_table_action_apply(a,
2036                         data_in,
2037                         RTE_TABLE_ACTION_LB,
2038                         &action->lb);
2039
2040                 if (status) {
2041                         rsp->status = -1;
2042                         return rsp;
2043                 }
2044         }
2045
2046         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_MTR)) {
2047                 status = rte_table_action_apply(a,
2048                         data_in,
2049                         RTE_TABLE_ACTION_MTR,
2050                         &action->mtr);
2051
2052                 if (status) {
2053                         rsp->status = -1;
2054                         return rsp;
2055                 }
2056         }
2057
2058         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_TM)) {
2059                 status = rte_table_action_apply(a,
2060                         data_in,
2061                         RTE_TABLE_ACTION_TM,
2062                         &action->tm);
2063
2064                 if (status) {
2065                         rsp->status = -1;
2066                         return rsp;
2067                 }
2068         }
2069
2070         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_ENCAP)) {
2071                 status = rte_table_action_apply(a,
2072                         data_in,
2073                         RTE_TABLE_ACTION_ENCAP,
2074                         &action->encap);
2075
2076                 if (status) {
2077                         rsp->status = -1;
2078                         return rsp;
2079                 }
2080         }
2081
2082         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_NAT)) {
2083                 status = rte_table_action_apply(a,
2084                         data_in,
2085                         RTE_TABLE_ACTION_NAT,
2086                         &action->nat);
2087
2088                 if (status) {
2089                         rsp->status = -1;
2090                         return rsp;
2091                 }
2092         }
2093
2094         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_TTL)) {
2095                 status = rte_table_action_apply(a,
2096                         data_in,
2097                         RTE_TABLE_ACTION_TTL,
2098                         &action->ttl);
2099
2100                 if (status) {
2101                         rsp->status = -1;
2102                         return rsp;
2103                 }
2104         }
2105
2106         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_STATS)) {
2107                 status = rte_table_action_apply(a,
2108                         data_in,
2109                         RTE_TABLE_ACTION_STATS,
2110                         &action->stats);
2111
2112                 if (status) {
2113                         rsp->status = -1;
2114                         return rsp;
2115                 }
2116         }
2117
2118         if (action->action_mask & (1LLU << RTE_TABLE_ACTION_TIME)) {
2119                 status = rte_table_action_apply(a,
2120                         data_in,
2121                         RTE_TABLE_ACTION_TIME,
2122                         &action->time);
2123
2124                 if (status) {
2125                         rsp->status = -1;
2126                         return rsp;
2127                 }
2128         }
2129
2130         /* Add rule (match, action) to table */
2131         status = match_convert(match, &match_ll, 1);
2132         if (status) {
2133                 rsp->status = -1;
2134                 return rsp;
2135         }
2136
2137         status = rte_pipeline_table_entry_add(p->p,
2138                 table_id,
2139                 &match_ll,
2140                 data_in,
2141                 &key_found,
2142                 &data_out);
2143         if (status) {
2144                 rsp->status = -1;
2145                 return rsp;
2146         }
2147
2148         /* Write response */
2149         rsp->status = 0;
2150         rsp->table_rule_add.data = data_out;
2151
2152         return rsp;
2153 }
2154
2155 static struct pipeline_msg_rsp *
2156 pipeline_msg_handle_table_rule_add_default(struct pipeline_data *p,
2157         struct pipeline_msg_req *req)
2158 {
2159         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2160         struct table_rule_action *action = &req->table_rule_add_default.action;
2161         struct rte_pipeline_table_entry *data_in, *data_out;
2162         uint32_t table_id = req->id;
2163         int status;
2164
2165         /* Apply actions */
2166         memset(p->buffer, 0, sizeof(p->buffer));
2167         data_in = (struct rte_pipeline_table_entry *) p->buffer;
2168
2169         data_in->action = action->fwd.action;
2170         if (action->fwd.action == RTE_PIPELINE_ACTION_PORT)
2171                 data_in->port_id = action->fwd.id;
2172         if (action->fwd.action == RTE_PIPELINE_ACTION_TABLE)
2173                 data_in->table_id = action->fwd.id;
2174
2175         /* Add default rule to table */
2176         status = rte_pipeline_table_default_entry_add(p->p,
2177                 table_id,
2178                 data_in,
2179                 &data_out);
2180         if (status) {
2181                 rsp->status = -1;
2182                 return rsp;
2183         }
2184
2185         /* Write response */
2186         rsp->status = 0;
2187         rsp->table_rule_add_default.data = data_out;
2188
2189         return rsp;
2190 }
2191
2192 static struct pipeline_msg_rsp *
2193 pipeline_msg_handle_table_rule_add_bulk(struct pipeline_data *p,
2194         struct pipeline_msg_req *req)
2195 {
2196
2197         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2198
2199         uint32_t table_id = req->id;
2200         struct table_rule_match *match = req->table_rule_add_bulk.match;
2201         struct table_rule_action *action = req->table_rule_add_bulk.action;
2202         struct rte_pipeline_table_entry **data =
2203                 (struct rte_pipeline_table_entry **)req->table_rule_add_bulk.data;
2204         uint32_t n_rules = req->table_rule_add_bulk.n_rules;
2205         uint32_t bulk = req->table_rule_add_bulk.bulk;
2206
2207         struct rte_table_action *a = p->table_data[table_id].a;
2208         union table_rule_match_low_level *match_ll;
2209         uint8_t *action_ll;
2210         void **match_ll_ptr;
2211         struct rte_pipeline_table_entry **action_ll_ptr;
2212         int *found, status;
2213         uint32_t i;
2214
2215         /* Memory allocation */
2216         match_ll = calloc(n_rules, sizeof(union table_rule_match_low_level));
2217         action_ll = calloc(n_rules, TABLE_RULE_ACTION_SIZE_MAX);
2218         match_ll_ptr = calloc(n_rules, sizeof(void *));
2219         action_ll_ptr =
2220                 calloc(n_rules, sizeof(struct rte_pipeline_table_entry *));
2221         found = calloc(n_rules, sizeof(int));
2222
2223         if ((match_ll == NULL) ||
2224                 (action_ll == NULL) ||
2225                 (match_ll_ptr == NULL) ||
2226                 (action_ll_ptr == NULL) ||
2227                 (found == NULL))
2228                 goto fail;
2229
2230         for (i = 0; i < n_rules; i++) {
2231                 match_ll_ptr[i] = (void *)&match_ll[i];
2232                 action_ll_ptr[i] =
2233                         (struct rte_pipeline_table_entry *)&action_ll[i * TABLE_RULE_ACTION_SIZE_MAX];
2234         }
2235
2236         /* Rule match conversion */
2237         for (i = 0; i < n_rules; i++) {
2238                 status = match_convert(&match[i], match_ll_ptr[i], 1);
2239                 if (status)
2240                         goto fail;
2241         }
2242
2243         /* Rule action conversion */
2244         for (i = 0; i < n_rules; i++) {
2245                 void *data_in = action_ll_ptr[i];
2246                 struct table_rule_action *act = &action[i];
2247
2248                 if (act->action_mask & (1LLU << RTE_TABLE_ACTION_FWD)) {
2249                         status = rte_table_action_apply(a,
2250                                 data_in,
2251                                 RTE_TABLE_ACTION_FWD,
2252                                 &act->fwd);
2253
2254                         if (status)
2255                                 goto fail;
2256                 }
2257
2258                 if (act->action_mask & (1LLU << RTE_TABLE_ACTION_LB)) {
2259                         status = rte_table_action_apply(a,
2260                                 data_in,
2261                                 RTE_TABLE_ACTION_LB,
2262                                 &act->lb);
2263
2264                         if (status)
2265                                 goto fail;
2266                 }
2267
2268                 if (act->action_mask & (1LLU << RTE_TABLE_ACTION_MTR)) {
2269                         status = rte_table_action_apply(a,
2270                                 data_in,
2271                                 RTE_TABLE_ACTION_MTR,
2272                                 &act->mtr);
2273
2274                         if (status)
2275                                 goto fail;
2276                 }
2277
2278                 if (act->action_mask & (1LLU << RTE_TABLE_ACTION_TM)) {
2279                         status = rte_table_action_apply(a,
2280                                 data_in,
2281                                 RTE_TABLE_ACTION_TM,
2282                                 &act->tm);
2283
2284                         if (status)
2285                                 goto fail;
2286                 }
2287
2288                 if (act->action_mask & (1LLU << RTE_TABLE_ACTION_ENCAP)) {
2289                         status = rte_table_action_apply(a,
2290                                 data_in,
2291                                 RTE_TABLE_ACTION_ENCAP,
2292                                 &act->encap);
2293
2294                         if (status)
2295                                 goto fail;
2296                 }
2297
2298                 if (act->action_mask & (1LLU << RTE_TABLE_ACTION_NAT)) {
2299                         status = rte_table_action_apply(a,
2300                                 data_in,
2301                                 RTE_TABLE_ACTION_NAT,
2302                                 &act->nat);
2303
2304                         if (status)
2305                                 goto fail;
2306                 }
2307
2308                 if (act->action_mask & (1LLU << RTE_TABLE_ACTION_TTL)) {
2309                         status = rte_table_action_apply(a,
2310                                 data_in,
2311                                 RTE_TABLE_ACTION_TTL,
2312                                 &act->ttl);
2313
2314                         if (status)
2315                                 goto fail;
2316                 }
2317
2318                 if (act->action_mask & (1LLU << RTE_TABLE_ACTION_STATS)) {
2319                         status = rte_table_action_apply(a,
2320                                 data_in,
2321                                 RTE_TABLE_ACTION_STATS,
2322                                 &act->stats);
2323
2324                         if (status)
2325                                 goto fail;
2326                 }
2327
2328                 if (act->action_mask & (1LLU << RTE_TABLE_ACTION_TIME)) {
2329                         status = rte_table_action_apply(a,
2330                                 data_in,
2331                                 RTE_TABLE_ACTION_TIME,
2332                                 &act->time);
2333
2334                         if (status)
2335                                 goto fail;
2336                 }
2337         }
2338
2339         /* Add rule (match, action) to table */
2340         if (bulk) {
2341                 status = rte_pipeline_table_entry_add_bulk(p->p,
2342                         table_id,
2343                         match_ll_ptr,
2344                         action_ll_ptr,
2345                         n_rules,
2346                         found,
2347                         data);
2348                 if (status)
2349                         n_rules = 0;
2350         } else
2351                 for (i = 0; i < n_rules; i++) {
2352                         status = rte_pipeline_table_entry_add(p->p,
2353                                 table_id,
2354                                 match_ll_ptr[i],
2355                                 action_ll_ptr[i],
2356                                 &found[i],
2357                                 &data[i]);
2358                         if (status) {
2359                                 n_rules = i;
2360                                 break;
2361                         }
2362                 }
2363
2364         /* Write response */
2365         rsp->status = 0;
2366         rsp->table_rule_add_bulk.n_rules = n_rules;
2367
2368         /* Free */
2369         free(found);
2370         free(action_ll_ptr);
2371         free(match_ll_ptr);
2372         free(action_ll);
2373         free(match_ll);
2374
2375         return rsp;
2376
2377 fail:
2378         free(found);
2379         free(action_ll_ptr);
2380         free(match_ll_ptr);
2381         free(action_ll);
2382         free(match_ll);
2383
2384         rsp->status = -1;
2385         rsp->table_rule_add_bulk.n_rules = 0;
2386         return rsp;
2387 }
2388
2389 static struct pipeline_msg_rsp *
2390 pipeline_msg_handle_table_rule_delete(struct pipeline_data *p,
2391         struct pipeline_msg_req *req)
2392 {
2393         union table_rule_match_low_level match_ll;
2394         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2395         struct table_rule_match *match = &req->table_rule_delete.match;
2396         uint32_t table_id = req->id;
2397         int key_found, status;
2398
2399         status = match_convert(match, &match_ll, 0);
2400         if (status) {
2401                 rsp->status = -1;
2402                 return rsp;
2403         }
2404
2405         rsp->status = rte_pipeline_table_entry_delete(p->p,
2406                 table_id,
2407                 &match_ll,
2408                 &key_found,
2409                 NULL);
2410
2411         return rsp;
2412 }
2413
2414 static struct pipeline_msg_rsp *
2415 pipeline_msg_handle_table_rule_delete_default(struct pipeline_data *p,
2416         struct pipeline_msg_req *req)
2417 {
2418         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2419         uint32_t table_id = req->id;
2420
2421         rsp->status = rte_pipeline_table_default_entry_delete(p->p,
2422                 table_id,
2423                 NULL);
2424
2425         return rsp;
2426 }
2427
2428 static struct pipeline_msg_rsp *
2429 pipeline_msg_handle_table_rule_stats_read(struct pipeline_data *p,
2430         struct pipeline_msg_req *req)
2431 {
2432         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2433         uint32_t table_id = req->id;
2434         void *data = req->table_rule_stats_read.data;
2435         int clear = req->table_rule_stats_read.clear;
2436         struct rte_table_action *a = p->table_data[table_id].a;
2437
2438         rsp->status = rte_table_action_stats_read(a,
2439                 data,
2440                 &rsp->table_rule_stats_read.stats,
2441                 clear);
2442
2443         return rsp;
2444 }
2445
2446 static struct pipeline_msg_rsp *
2447 pipeline_msg_handle_table_mtr_profile_add(struct pipeline_data *p,
2448         struct pipeline_msg_req *req)
2449 {
2450         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2451         uint32_t table_id = req->id;
2452         uint32_t meter_profile_id = req->table_mtr_profile_add.meter_profile_id;
2453         struct rte_table_action_meter_profile *profile =
2454                 &req->table_mtr_profile_add.profile;
2455         struct rte_table_action *a = p->table_data[table_id].a;
2456
2457         rsp->status = rte_table_action_meter_profile_add(a,
2458                 meter_profile_id,
2459                 profile);
2460
2461         return rsp;
2462 }
2463
2464 static struct pipeline_msg_rsp *
2465 pipeline_msg_handle_table_mtr_profile_delete(struct pipeline_data *p,
2466         struct pipeline_msg_req *req)
2467 {
2468         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2469         uint32_t table_id = req->id;
2470         uint32_t meter_profile_id =
2471                 req->table_mtr_profile_delete.meter_profile_id;
2472         struct rte_table_action *a = p->table_data[table_id].a;
2473
2474         rsp->status = rte_table_action_meter_profile_delete(a,
2475                 meter_profile_id);
2476
2477         return rsp;
2478 }
2479
2480 static struct pipeline_msg_rsp *
2481 pipeline_msg_handle_table_rule_mtr_read(struct pipeline_data *p,
2482         struct pipeline_msg_req *req)
2483 {
2484         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2485         uint32_t table_id = req->id;
2486         void *data = req->table_rule_mtr_read.data;
2487         uint32_t tc_mask = req->table_rule_mtr_read.tc_mask;
2488         int clear = req->table_rule_mtr_read.clear;
2489         struct rte_table_action *a = p->table_data[table_id].a;
2490
2491         rsp->status = rte_table_action_meter_read(a,
2492                 data,
2493                 tc_mask,
2494                 &rsp->table_rule_mtr_read.stats,
2495                 clear);
2496
2497         return rsp;
2498 }
2499
2500 static struct pipeline_msg_rsp *
2501 pipeline_msg_handle_table_dscp_table_update(struct pipeline_data *p,
2502         struct pipeline_msg_req *req)
2503 {
2504         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2505         uint32_t table_id = req->id;
2506         uint64_t dscp_mask = req->table_dscp_table_update.dscp_mask;
2507         struct rte_table_action_dscp_table *dscp_table =
2508                 &req->table_dscp_table_update.dscp_table;
2509         struct rte_table_action *a = p->table_data[table_id].a;
2510
2511         rsp->status = rte_table_action_dscp_table_update(a,
2512                 dscp_mask,
2513                 dscp_table);
2514
2515         return rsp;
2516 }
2517
2518 static struct pipeline_msg_rsp *
2519 pipeline_msg_handle_table_rule_ttl_read(struct pipeline_data *p,
2520         struct pipeline_msg_req *req)
2521 {
2522         struct pipeline_msg_rsp *rsp = (struct pipeline_msg_rsp *) req;
2523         uint32_t table_id = req->id;
2524         void *data = req->table_rule_ttl_read.data;
2525         int clear = req->table_rule_ttl_read.clear;
2526         struct rte_table_action *a = p->table_data[table_id].a;
2527
2528         rsp->status = rte_table_action_ttl_read(a,
2529                 data,
2530                 &rsp->table_rule_ttl_read.stats,
2531                 clear);
2532
2533         return rsp;
2534 }
2535
2536 static void
2537 pipeline_msg_handle(struct pipeline_data *p)
2538 {
2539         for ( ; ; ) {
2540                 struct pipeline_msg_req *req;
2541                 struct pipeline_msg_rsp *rsp;
2542
2543                 req = pipeline_msg_recv(p->msgq_req);
2544                 if (req == NULL)
2545                         break;
2546
2547                 switch (req->type) {
2548                 case PIPELINE_REQ_PORT_IN_STATS_READ:
2549                         rsp = pipeline_msg_handle_port_in_stats_read(p, req);
2550                         break;
2551
2552                 case PIPELINE_REQ_PORT_IN_ENABLE:
2553                         rsp = pipeline_msg_handle_port_in_enable(p, req);
2554                         break;
2555
2556                 case PIPELINE_REQ_PORT_IN_DISABLE:
2557                         rsp = pipeline_msg_handle_port_in_disable(p, req);
2558                         break;
2559
2560                 case PIPELINE_REQ_PORT_OUT_STATS_READ:
2561                         rsp = pipeline_msg_handle_port_out_stats_read(p, req);
2562                         break;
2563
2564                 case PIPELINE_REQ_TABLE_STATS_READ:
2565                         rsp = pipeline_msg_handle_table_stats_read(p, req);
2566                         break;
2567
2568                 case PIPELINE_REQ_TABLE_RULE_ADD:
2569                         rsp = pipeline_msg_handle_table_rule_add(p, req);
2570                         break;
2571
2572                 case PIPELINE_REQ_TABLE_RULE_ADD_DEFAULT:
2573                         rsp = pipeline_msg_handle_table_rule_add_default(p,     req);
2574                         break;
2575
2576                 case PIPELINE_REQ_TABLE_RULE_ADD_BULK:
2577                         rsp = pipeline_msg_handle_table_rule_add_bulk(p, req);
2578                         break;
2579
2580                 case PIPELINE_REQ_TABLE_RULE_DELETE:
2581                         rsp = pipeline_msg_handle_table_rule_delete(p, req);
2582                         break;
2583
2584                 case PIPELINE_REQ_TABLE_RULE_DELETE_DEFAULT:
2585                         rsp = pipeline_msg_handle_table_rule_delete_default(p, req);
2586                         break;
2587
2588                 case PIPELINE_REQ_TABLE_RULE_STATS_READ:
2589                         rsp = pipeline_msg_handle_table_rule_stats_read(p, req);
2590                         break;
2591
2592                 case PIPELINE_REQ_TABLE_MTR_PROFILE_ADD:
2593                         rsp = pipeline_msg_handle_table_mtr_profile_add(p, req);
2594                         break;
2595
2596                 case PIPELINE_REQ_TABLE_MTR_PROFILE_DELETE:
2597                         rsp = pipeline_msg_handle_table_mtr_profile_delete(p, req);
2598                         break;
2599
2600                 case PIPELINE_REQ_TABLE_RULE_MTR_READ:
2601                         rsp = pipeline_msg_handle_table_rule_mtr_read(p, req);
2602                         break;
2603
2604                 case PIPELINE_REQ_TABLE_DSCP_TABLE_UPDATE:
2605                         rsp = pipeline_msg_handle_table_dscp_table_update(p, req);
2606                         break;
2607
2608                 case PIPELINE_REQ_TABLE_RULE_TTL_READ:
2609                         rsp = pipeline_msg_handle_table_rule_ttl_read(p, req);
2610                         break;
2611
2612                 default:
2613                         rsp = (struct pipeline_msg_rsp *) req;
2614                         rsp->status = -1;
2615                 }
2616
2617                 pipeline_msg_send(p->msgq_rsp, rsp);
2618         }
2619 }
2620
2621 /**
2622  * Data plane threads: main
2623  */
2624 int
2625 thread_main(void *arg __rte_unused)
2626 {
2627         struct thread_data *t;
2628         uint32_t thread_id, i;
2629
2630         thread_id = rte_lcore_id();
2631         t = &thread_data[thread_id];
2632
2633         /* Dispatch loop */
2634         for (i = 0; ; i++) {
2635                 uint32_t j;
2636
2637                 /* Data Plane */
2638                 for (j = 0; j < t->n_pipelines; j++)
2639                         rte_pipeline_run(t->p[j]);
2640
2641                 /* Control Plane */
2642                 if ((i & 0xF) == 0) {
2643                         uint64_t time = rte_get_tsc_cycles();
2644                         uint64_t time_next_min = UINT64_MAX;
2645
2646                         if (time < t->time_next_min)
2647                                 continue;
2648
2649                         /* Pipeline message queues */
2650                         for (j = 0; j < t->n_pipelines; j++) {
2651                                 struct pipeline_data *p =
2652                                         &t->pipeline_data[j];
2653                                 uint64_t time_next = p->time_next;
2654
2655                                 if (time_next <= time) {
2656                                         pipeline_msg_handle(p);
2657                                         rte_pipeline_flush(p->p);
2658                                         time_next = time + p->timer_period;
2659                                         p->time_next = time_next;
2660                                 }
2661
2662                                 if (time_next < time_next_min)
2663                                         time_next_min = time_next;
2664                         }
2665
2666                         /* Thread message queues */
2667                         {
2668                                 uint64_t time_next = t->time_next;
2669
2670                                 if (time_next <= time) {
2671                                         thread_msg_handle(t);
2672                                         time_next = time + t->timer_period;
2673                                         t->time_next = time_next;
2674                                 }
2675
2676                                 if (time_next < time_next_min)
2677                                         time_next_min = time_next;
2678                         }
2679
2680                         t->time_next_min = time_next_min;
2681                 }
2682         }
2683
2684         return 0;
2685 }