examples/ip_pipeline/pipeline.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2018 Intel Corporation
 */

#include <stdlib.h>
#include <string.h>

#include <rte_common.h>
#include <rte_ip.h>
#include <rte_tcp.h>

#include <rte_string_fns.h>
#include <rte_port_ethdev.h>
#ifdef RTE_LIBRTE_KNI
#include <rte_port_kni.h>
#endif
#include <rte_port_ring.h>
#include <rte_port_source_sink.h>
#include <rte_port_fd.h>
#include <rte_port_sched.h>
#include <rte_port_sym_crypto.h>

#include <rte_table_acl.h>
#include <rte_table_array.h>
#include <rte_table_hash.h>
#include <rte_table_hash_func.h>
#include <rte_table_lpm.h>
#include <rte_table_lpm_ipv6.h>
#include <rte_table_stub.h>

#ifdef RTE_LIBRTE_KNI
#include "kni.h"
#endif
#include "link.h"
#include "mempool.h"
#include "pipeline.h"
#include "tap.h"
#include "tmgr.h"
#include "swq.h"
#include "cryptodev.h"

#ifndef PIPELINE_MSGQ_SIZE
#define PIPELINE_MSGQ_SIZE                                 64
#endif

#ifndef TABLE_LPM_NUMBER_TBL8
#define TABLE_LPM_NUMBER_TBL8                              256
#endif

static struct pipeline_list pipeline_list;

int
pipeline_init(void)
{
        TAILQ_INIT(&pipeline_list);

        return 0;
}

struct pipeline *
pipeline_find(const char *name)
{
        struct pipeline *pipeline;

        if (name == NULL)
                return NULL;

        TAILQ_FOREACH(pipeline, &pipeline_list, node)
                if (strcmp(name, pipeline->name) == 0)
                        return pipeline;

        return NULL;
}

struct pipeline *
pipeline_create(const char *name, struct pipeline_params *params)
{
        char msgq_name[NAME_MAX];
        struct rte_pipeline_params pp;
        struct pipeline *pipeline;
        struct rte_pipeline *p;
        struct rte_ring *msgq_req;
        struct rte_ring *msgq_rsp;

        /* Check input params */
        if ((name == NULL) ||
                pipeline_find(name) ||
                (params == NULL) ||
                (params->timer_period_ms == 0))
                return NULL;

        /* Resource create */
        snprintf(msgq_name, sizeof(msgq_name), "%s-MSGQ-REQ", name);

        msgq_req = rte_ring_create(msgq_name,
                PIPELINE_MSGQ_SIZE,
                params->cpu_id,
                RING_F_SP_ENQ | RING_F_SC_DEQ);
        if (msgq_req == NULL)
                return NULL;

        snprintf(msgq_name, sizeof(msgq_name), "%s-MSGQ-RSP", name);

        msgq_rsp = rte_ring_create(msgq_name,
                PIPELINE_MSGQ_SIZE,
                params->cpu_id,
                RING_F_SP_ENQ | RING_F_SC_DEQ);
        if (msgq_rsp == NULL) {
                rte_ring_free(msgq_req);
                return NULL;
        }

        pp.name = name;
        pp.socket_id = (int) params->cpu_id;
        pp.offset_port_id = params->offset_port_id;

        p = rte_pipeline_create(&pp);
        if (p == NULL) {
                rte_ring_free(msgq_rsp);
                rte_ring_free(msgq_req);
                return NULL;
        }

        /* Node allocation */
        pipeline = calloc(1, sizeof(struct pipeline));
        if (pipeline == NULL) {
                rte_pipeline_free(p);
                rte_ring_free(msgq_rsp);
                rte_ring_free(msgq_req);
                return NULL;
        }

        /* Node fill in */
        strlcpy(pipeline->name, name, sizeof(pipeline->name));
        pipeline->p = p;
        pipeline->n_ports_in = 0;
        pipeline->n_ports_out = 0;
        pipeline->n_tables = 0;
        pipeline->msgq_req = msgq_req;
        pipeline->msgq_rsp = msgq_rsp;
        pipeline->timer_period_ms = params->timer_period_ms;
        pipeline->enabled = 0;
        pipeline->cpu_id = params->cpu_id;

        /* Node add to list */
        TAILQ_INSERT_TAIL(&pipeline_list, pipeline, node);

        return pipeline;
}

int
pipeline_port_in_create(const char *pipeline_name,
        struct port_in_params *params,
        int enabled)
{
        struct rte_pipeline_port_in_params p;

        union {
                struct rte_port_ethdev_reader_params ethdev;
                struct rte_port_ring_reader_params ring;
                struct rte_port_sched_reader_params sched;
                struct rte_port_fd_reader_params fd;
#ifdef RTE_LIBRTE_KNI
                struct rte_port_kni_reader_params kni;
#endif
                struct rte_port_source_params source;
                struct rte_port_sym_crypto_reader_params sym_crypto;
        } pp;

        struct pipeline *pipeline;
        struct port_in *port_in;
        struct port_in_action_profile *ap;
        struct rte_port_in_action *action;
        uint32_t port_id;
        int status;

        memset(&p, 0, sizeof(p));
        memset(&pp, 0, sizeof(pp));

        /* Check input params */
        if ((pipeline_name == NULL) ||
                (params == NULL) ||
                (params->burst_size == 0) ||
                (params->burst_size > RTE_PORT_IN_BURST_SIZE_MAX))
                return -1;

        pipeline = pipeline_find(pipeline_name);
        if (pipeline == NULL)
                return -1;

        ap = NULL;
        if (params->action_profile_name) {
                ap = port_in_action_profile_find(params->action_profile_name);
                if (ap == NULL)
                        return -1;
        }

        switch (params->type) {
        case PORT_IN_RXQ:
        {
                struct link *link;

                link = link_find(params->dev_name);
                if (link == NULL)
                        return -1;

                if (params->rxq.queue_id >= link->n_rxq)
                        return -1;

                pp.ethdev.port_id = link->port_id;
                pp.ethdev.queue_id = params->rxq.queue_id;

                p.ops = &rte_port_ethdev_reader_ops;
                p.arg_create = &pp.ethdev;
                break;
        }

        case PORT_IN_SWQ:
        {
                struct swq *swq;

                swq = swq_find(params->dev_name);
                if (swq == NULL)
                        return -1;

                pp.ring.ring = swq->r;

                p.ops = &rte_port_ring_reader_ops;
                p.arg_create = &pp.ring;
                break;
        }

        case PORT_IN_TMGR:
        {
                struct tmgr_port *tmgr_port;

                tmgr_port = tmgr_port_find(params->dev_name);
                if (tmgr_port == NULL)
                        return -1;

                pp.sched.sched = tmgr_port->s;

                p.ops = &rte_port_sched_reader_ops;
                p.arg_create = &pp.sched;
                break;
        }

        case PORT_IN_TAP:
        {
                struct tap *tap;
                struct mempool *mempool;

                tap = tap_find(params->dev_name);
                mempool = mempool_find(params->tap.mempool_name);
                if ((tap == NULL) || (mempool == NULL))
                        return -1;

                pp.fd.fd = tap->fd;
                pp.fd.mempool = mempool->m;
                pp.fd.mtu = params->tap.mtu;

                p.ops = &rte_port_fd_reader_ops;
                p.arg_create = &pp.fd;
                break;
        }

#ifdef RTE_LIBRTE_KNI
        case PORT_IN_KNI:
        {
                struct kni *kni;

                kni = kni_find(params->dev_name);
                if (kni == NULL)
                        return -1;

                pp.kni.kni = kni->k;

                p.ops = &rte_port_kni_reader_ops;
                p.arg_create = &pp.kni;
                break;
        }
#endif

        case PORT_IN_SOURCE:
        {
                struct mempool *mempool;

                mempool = mempool_find(params->source.mempool_name);
                if (mempool == NULL)
                        return -1;

                pp.source.mempool = mempool->m;
                pp.source.file_name = params->source.file_name;
                pp.source.n_bytes_per_pkt = params->source.n_bytes_per_pkt;

                p.ops = &rte_port_source_ops;
                p.arg_create = &pp.source;
                break;
        }

        case PORT_IN_CRYPTODEV:
        {
                struct cryptodev *cryptodev;

                cryptodev = cryptodev_find(params->dev_name);
                if (cryptodev == NULL)
                        return -1;

                if (params->rxq.queue_id > cryptodev->n_queues - 1)
                        return -1;

                pp.sym_crypto.cryptodev_id = cryptodev->dev_id;
                pp.sym_crypto.queue_id = params->cryptodev.queue_id;
                pp.sym_crypto.f_callback = params->cryptodev.f_callback;
                pp.sym_crypto.arg_callback = params->cryptodev.arg_callback;
                p.ops = &rte_port_sym_crypto_reader_ops;
                p.arg_create = &pp.sym_crypto;

                break;
        }

        default:
                return -1;
        }

        p.burst_size = params->burst_size;

        /* Resource create */
        action = NULL;
        p.f_action = NULL;
        p.arg_ah = NULL;

        if (ap) {
                action = rte_port_in_action_create(ap->ap,
                        pipeline->cpu_id);
                if (action == NULL)
                        return -1;

                status = rte_port_in_action_params_get(
                        action,
                        &p);
                if (status) {
                        rte_port_in_action_free(action);
                        return -1;
                }
        }

        status = rte_pipeline_port_in_create(pipeline->p,
                &p,
                &port_id);
        if (status) {
                rte_port_in_action_free(action);
                return -1;
        }

        if (enabled)
                rte_pipeline_port_in_enable(pipeline->p, port_id);

        /* Pipeline */
        port_in = &pipeline->port_in[pipeline->n_ports_in];
        memcpy(&port_in->params, params, sizeof(*params));
        port_in->ap = ap;
        port_in->a = action;
        pipeline->n_ports_in++;

        return 0;
}

int
pipeline_port_in_connect_to_table(const char *pipeline_name,
        uint32_t port_id,
        uint32_t table_id)
{
        struct pipeline *pipeline;
        int status;

        /* Check input params */
        if (pipeline_name == NULL)
                return -1;

        pipeline = pipeline_find(pipeline_name);
        if ((pipeline == NULL) ||
                (port_id >= pipeline->n_ports_in) ||
                (table_id >= pipeline->n_tables))
                return -1;

        /* Resource */
        status = rte_pipeline_port_in_connect_to_table(pipeline->p,
                port_id,
                table_id);

        return status;

}

int
pipeline_port_out_create(const char *pipeline_name,
        struct port_out_params *params)
{
        struct rte_pipeline_port_out_params p;

        union {
                struct rte_port_ethdev_writer_params ethdev;
                struct rte_port_ring_writer_params ring;
                struct rte_port_sched_writer_params sched;
                struct rte_port_fd_writer_params fd;
#ifdef RTE_LIBRTE_KNI
                struct rte_port_kni_writer_params kni;
#endif
                struct rte_port_sink_params sink;
                struct rte_port_sym_crypto_writer_params sym_crypto;
        } pp;

        union {
                struct rte_port_ethdev_writer_nodrop_params ethdev;
                struct rte_port_ring_writer_nodrop_params ring;
                struct rte_port_fd_writer_nodrop_params fd;
#ifdef RTE_LIBRTE_KNI
                struct rte_port_kni_writer_nodrop_params kni;
#endif
                struct rte_port_sym_crypto_writer_nodrop_params sym_crypto;
        } pp_nodrop;

        struct pipeline *pipeline;
        uint32_t port_id;
        int status;

        memset(&p, 0, sizeof(p));
        memset(&pp, 0, sizeof(pp));
        memset(&pp_nodrop, 0, sizeof(pp_nodrop));

        /* Check input params */
        if ((pipeline_name == NULL) ||
                (params == NULL) ||
                (params->burst_size == 0) ||
                (params->burst_size > RTE_PORT_IN_BURST_SIZE_MAX))
                return -1;

        pipeline = pipeline_find(pipeline_name);
        if (pipeline == NULL)
                return -1;

        switch (params->type) {
        case PORT_OUT_TXQ:
        {
                struct link *link;

                link = link_find(params->dev_name);
                if (link == NULL)
                        return -1;

                if (params->txq.queue_id >= link->n_txq)
                        return -1;

                pp.ethdev.port_id = link->port_id;
                pp.ethdev.queue_id = params->txq.queue_id;
                pp.ethdev.tx_burst_sz = params->burst_size;

                pp_nodrop.ethdev.port_id = link->port_id;
                pp_nodrop.ethdev.queue_id = params->txq.queue_id;
                pp_nodrop.ethdev.tx_burst_sz = params->burst_size;
                pp_nodrop.ethdev.n_retries = params->n_retries;

                if (params->retry == 0) {
                        p.ops = &rte_port_ethdev_writer_ops;
                        p.arg_create = &pp.ethdev;
                } else {
                        p.ops = &rte_port_ethdev_writer_nodrop_ops;
                        p.arg_create = &pp_nodrop.ethdev;
                }
                break;
        }

        case PORT_OUT_SWQ:
        {
                struct swq *swq;

                swq = swq_find(params->dev_name);
                if (swq == NULL)
                        return -1;

                pp.ring.ring = swq->r;
                pp.ring.tx_burst_sz = params->burst_size;

                pp_nodrop.ring.ring = swq->r;
                pp_nodrop.ring.tx_burst_sz = params->burst_size;
                pp_nodrop.ring.n_retries = params->n_retries;

                if (params->retry == 0) {
                        p.ops = &rte_port_ring_writer_ops;
                        p.arg_create = &pp.ring;
                } else {
                        p.ops = &rte_port_ring_writer_nodrop_ops;
                        p.arg_create = &pp_nodrop.ring;
                }
                break;
        }

        case PORT_OUT_TMGR:
        {
                struct tmgr_port *tmgr_port;

                tmgr_port = tmgr_port_find(params->dev_name);
                if (tmgr_port == NULL)
                        return -1;

                pp.sched.sched = tmgr_port->s;
                pp.sched.tx_burst_sz = params->burst_size;

                p.ops = &rte_port_sched_writer_ops;
                p.arg_create = &pp.sched;
                break;
        }

        case PORT_OUT_TAP:
        {
                struct tap *tap;

                tap = tap_find(params->dev_name);
                if (tap == NULL)
                        return -1;

                pp.fd.fd = tap->fd;
                pp.fd.tx_burst_sz = params->burst_size;

                pp_nodrop.fd.fd = tap->fd;
                pp_nodrop.fd.tx_burst_sz = params->burst_size;
                pp_nodrop.fd.n_retries = params->n_retries;

                if (params->retry == 0) {
                        p.ops = &rte_port_fd_writer_ops;
                        p.arg_create = &pp.fd;
                } else {
                        p.ops = &rte_port_fd_writer_nodrop_ops;
                        p.arg_create = &pp_nodrop.fd;
                }
                break;
        }

#ifdef RTE_LIBRTE_KNI
        case PORT_OUT_KNI:
        {
                struct kni *kni;

                kni = kni_find(params->dev_name);
                if (kni == NULL)
                        return -1;

                pp.kni.kni = kni->k;
                pp.kni.tx_burst_sz = params->burst_size;

                pp_nodrop.kni.kni = kni->k;
                pp_nodrop.kni.tx_burst_sz = params->burst_size;
                pp_nodrop.kni.n_retries = params->n_retries;

                if (params->retry == 0) {
                        p.ops = &rte_port_kni_writer_ops;
                        p.arg_create = &pp.kni;
                } else {
                        p.ops = &rte_port_kni_writer_nodrop_ops;
                        p.arg_create = &pp_nodrop.kni;
                }
                break;
        }
#endif

        case PORT_OUT_SINK:
        {
                pp.sink.file_name = params->sink.file_name;
                pp.sink.max_n_pkts = params->sink.max_n_pkts;

                p.ops = &rte_port_sink_ops;
                p.arg_create = &pp.sink;
                break;
        }

        case PORT_OUT_CRYPTODEV:
        {
                struct cryptodev *cryptodev;

                cryptodev = cryptodev_find(params->dev_name);
                if (cryptodev == NULL)
                        return -1;

                if (params->cryptodev.queue_id >= cryptodev->n_queues)
                        return -1;

                pp.sym_crypto.cryptodev_id = cryptodev->dev_id;
                pp.sym_crypto.queue_id = params->cryptodev.queue_id;
                pp.sym_crypto.tx_burst_sz = params->burst_size;
                pp.sym_crypto.crypto_op_offset = params->cryptodev.op_offset;

                pp_nodrop.sym_crypto.cryptodev_id = cryptodev->dev_id;
                pp_nodrop.sym_crypto.queue_id = params->cryptodev.queue_id;
                pp_nodrop.sym_crypto.tx_burst_sz = params->burst_size;
                pp_nodrop.sym_crypto.n_retries = params->retry;
                pp_nodrop.sym_crypto.crypto_op_offset =
                                params->cryptodev.op_offset;

                if (params->retry == 0) {
                        p.ops = &rte_port_sym_crypto_writer_ops;
                        p.arg_create = &pp.sym_crypto;
                } else {
                        p.ops = &rte_port_sym_crypto_writer_nodrop_ops;
                        p.arg_create = &pp_nodrop.sym_crypto;
                }

                break;
        }

        default:
                return -1;
        }

        p.f_action = NULL;
        p.arg_ah = NULL;

        /* Resource create */
        status = rte_pipeline_port_out_create(pipeline->p,
                &p,
                &port_id);

        if (status)
                return -1;

        /* Pipeline */
        pipeline->n_ports_out++;

        return 0;
}

static const struct rte_acl_field_def table_acl_field_format_ipv4[] = {
        /* Protocol */
        [0] = {
                .type = RTE_ACL_FIELD_TYPE_BITMASK,
                .size = sizeof(uint8_t),
                .field_index = 0,
                .input_index = 0,
                .offset = offsetof(struct ipv4_hdr, next_proto_id),
        },

        /* Source IP address (IPv4) */
        [1] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 1,
                .input_index = 1,
                .offset = offsetof(struct ipv4_hdr, src_addr),
        },

        /* Destination IP address (IPv4) */
        [2] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 2,
                .input_index = 2,
                .offset = offsetof(struct ipv4_hdr, dst_addr),
        },

        /* Source Port */
        [3] = {
                .type = RTE_ACL_FIELD_TYPE_RANGE,
                .size = sizeof(uint16_t),
                .field_index = 3,
                .input_index = 3,
                .offset = sizeof(struct ipv4_hdr) +
                        offsetof(struct tcp_hdr, src_port),
        },

        /* Destination Port */
        [4] = {
                .type = RTE_ACL_FIELD_TYPE_RANGE,
                .size = sizeof(uint16_t),
                .field_index = 4,
                .input_index = 3,
                .offset = sizeof(struct ipv4_hdr) +
                        offsetof(struct tcp_hdr, dst_port),
        },
};

static const struct rte_acl_field_def table_acl_field_format_ipv6[] = {
        /* Protocol */
        [0] = {
                .type = RTE_ACL_FIELD_TYPE_BITMASK,
                .size = sizeof(uint8_t),
                .field_index = 0,
                .input_index = 0,
                .offset = offsetof(struct ipv6_hdr, proto),
        },

        /* Source IP address (IPv6) */
        [1] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 1,
                .input_index = 1,
                .offset = offsetof(struct ipv6_hdr, src_addr[0]),
        },

        [2] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 2,
                .input_index = 2,
                .offset = offsetof(struct ipv6_hdr, src_addr[4]),
        },

        [3] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 3,
                .input_index = 3,
                .offset = offsetof(struct ipv6_hdr, src_addr[8]),
        },

        [4] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 4,
                .input_index = 4,
                .offset = offsetof(struct ipv6_hdr, src_addr[12]),
        },

        /* Destination IP address (IPv6) */
        [5] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 5,
                .input_index = 5,
                .offset = offsetof(struct ipv6_hdr, dst_addr[0]),
        },

        [6] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 6,
                .input_index = 6,
                .offset = offsetof(struct ipv6_hdr, dst_addr[4]),
        },

        [7] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 7,
                .input_index = 7,
                .offset = offsetof(struct ipv6_hdr, dst_addr[8]),
        },

        [8] = {
                .type = RTE_ACL_FIELD_TYPE_MASK,
                .size = sizeof(uint32_t),
                .field_index = 8,
                .input_index = 8,
                .offset = offsetof(struct ipv6_hdr, dst_addr[12]),
        },

        /* Source Port */
        [9] = {
                .type = RTE_ACL_FIELD_TYPE_RANGE,
                .size = sizeof(uint16_t),
                .field_index = 9,
                .input_index = 9,
                .offset = sizeof(struct ipv6_hdr) +
                        offsetof(struct tcp_hdr, src_port),
        },

        /* Destination Port */
        [10] = {
                .type = RTE_ACL_FIELD_TYPE_RANGE,
                .size = sizeof(uint16_t),
                .field_index = 10,
                .input_index = 9,
                .offset = sizeof(struct ipv6_hdr) +
                        offsetof(struct tcp_hdr, dst_port),
        },
};

int
pipeline_table_create(const char *pipeline_name,
        struct table_params *params)
{
        char name[NAME_MAX];
        struct rte_pipeline_table_params p;

        union {
                struct rte_table_acl_params acl;
                struct rte_table_array_params array;
                struct rte_table_hash_params hash;
                struct rte_table_lpm_params lpm;
                struct rte_table_lpm_ipv6_params lpm_ipv6;
        } pp;

        struct pipeline *pipeline;
        struct table *table;
        struct table_action_profile *ap;
        struct rte_table_action *action;
        uint32_t table_id;
        int status;

        memset(&p, 0, sizeof(p));
        memset(&pp, 0, sizeof(pp));

        /* Check input params */
        if ((pipeline_name == NULL) ||
                (params == NULL))
                return -1;

        pipeline = pipeline_find(pipeline_name);
        if ((pipeline == NULL) ||
                (pipeline->n_tables >= RTE_PIPELINE_TABLE_MAX))
                return -1;

        ap = NULL;
        if (params->action_profile_name) {
                ap = table_action_profile_find(params->action_profile_name);
                if (ap == NULL)
                        return -1;
        }

        snprintf(name, NAME_MAX, "%s_table%u",
                pipeline_name, pipeline->n_tables);

        switch (params->match_type) {
        case TABLE_ACL:
        {
                uint32_t ip_header_offset = params->match.acl.ip_header_offset -
                        (sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM);
                uint32_t i;

                if (params->match.acl.n_rules == 0)
                        return -1;

                pp.acl.name = name;
                pp.acl.n_rules = params->match.acl.n_rules;
                if (params->match.acl.ip_version) {
                        memcpy(&pp.acl.field_format,
                                &table_acl_field_format_ipv4,
                                sizeof(table_acl_field_format_ipv4));
                        pp.acl.n_rule_fields =
                                RTE_DIM(table_acl_field_format_ipv4);
                } else {
                        memcpy(&pp.acl.field_format,
                                &table_acl_field_format_ipv6,
                                sizeof(table_acl_field_format_ipv6));
                        pp.acl.n_rule_fields =
                                RTE_DIM(table_acl_field_format_ipv6);
                }

                for (i = 0; i < pp.acl.n_rule_fields; i++)
                        pp.acl.field_format[i].offset += ip_header_offset;

                p.ops = &rte_table_acl_ops;
                p.arg_create = &pp.acl;
                break;
        }

        case TABLE_ARRAY:
        {
                if (params->match.array.n_keys == 0)
                        return -1;

                pp.array.n_entries = params->match.array.n_keys;
                pp.array.offset = params->match.array.key_offset;

                p.ops = &rte_table_array_ops;
                p.arg_create = &pp.array;
                break;
        }

        case TABLE_HASH:
        {
                struct rte_table_ops *ops;
                rte_table_hash_op_hash f_hash;

                if (params->match.hash.n_keys == 0)
                        return -1;

                switch (params->match.hash.key_size) {
                case  8:
                        f_hash = rte_table_hash_crc_key8;
                        break;
                case 16:
                        f_hash = rte_table_hash_crc_key16;
                        break;
                case 24:
                        f_hash = rte_table_hash_crc_key24;
                        break;
                case 32:
                        f_hash = rte_table_hash_crc_key32;
                        break;
                case 40:
                        f_hash = rte_table_hash_crc_key40;
                        break;
                case 48:
                        f_hash = rte_table_hash_crc_key48;
                        break;
                case 56:
                        f_hash = rte_table_hash_crc_key56;
                        break;
                case 64:
                        f_hash = rte_table_hash_crc_key64;
                        break;
                default:
                        return -1;
                }

                pp.hash.name = name;
                pp.hash.key_size = params->match.hash.key_size;
                pp.hash.key_offset = params->match.hash.key_offset;
                pp.hash.key_mask = params->match.hash.key_mask;
                pp.hash.n_keys = params->match.hash.n_keys;
                pp.hash.n_buckets = params->match.hash.n_buckets;
                pp.hash.f_hash = f_hash;
                pp.hash.seed = 0;

                if (params->match.hash.extendable_bucket)
                        switch (params->match.hash.key_size) {
                        case  8:
                                ops = &rte_table_hash_key8_ext_ops;
                                break;
                        case 16:
                                ops = &rte_table_hash_key16_ext_ops;
                                break;
                        default:
                                ops = &rte_table_hash_ext_ops;
                        }
                else
                        switch (params->match.hash.key_size) {
                        case  8:
                                ops = &rte_table_hash_key8_lru_ops;
                                break;
                        case 16:
                                ops = &rte_table_hash_key16_lru_ops;
                                break;
                        default:
                                ops = &rte_table_hash_lru_ops;
                        }

                p.ops = ops;
                p.arg_create = &pp.hash;
                break;
        }

        case TABLE_LPM:
        {
                if (params->match.lpm.n_rules == 0)
                        return -1;

                switch (params->match.lpm.key_size) {
                case 4:
                {
                        pp.lpm.name = name;
                        pp.lpm.n_rules = params->match.lpm.n_rules;
                        pp.lpm.number_tbl8s = TABLE_LPM_NUMBER_TBL8;
                        pp.lpm.flags = 0;
                        pp.lpm.entry_unique_size = p.action_data_size +
                                sizeof(struct rte_pipeline_table_entry);
                        pp.lpm.offset = params->match.lpm.key_offset;

                        p.ops = &rte_table_lpm_ops;
                        p.arg_create = &pp.lpm;
                        break;
                }

                case 16:
                {
                        pp.lpm_ipv6.name = name;
                        pp.lpm_ipv6.n_rules = params->match.lpm.n_rules;
                        pp.lpm_ipv6.number_tbl8s = TABLE_LPM_NUMBER_TBL8;
                        pp.lpm_ipv6.entry_unique_size = p.action_data_size +
                                sizeof(struct rte_pipeline_table_entry);
                        pp.lpm_ipv6.offset = params->match.lpm.key_offset;

                        p.ops = &rte_table_lpm_ipv6_ops;
                        p.arg_create = &pp.lpm_ipv6;
                        break;
                }

                default:
                        return -1;
                }

                break;
        }

        case TABLE_STUB:
        {
                p.ops = &rte_table_stub_ops;
                p.arg_create = NULL;
                break;
        }

        default:
                return -1;
        }

        /* Resource create */
        action = NULL;
        p.f_action_hit = NULL;
        p.f_action_miss = NULL;
        p.arg_ah = NULL;

        if (ap) {
                action = rte_table_action_create(ap->ap,
                        pipeline->cpu_id);
                if (action == NULL)
                        return -1;

                status = rte_table_action_table_params_get(
                        action,
                        &p);
                if (status ||
                        ((p.action_data_size +
                        sizeof(struct rte_pipeline_table_entry)) >
                        TABLE_RULE_ACTION_SIZE_MAX)) {
                        rte_table_action_free(action);
                        return -1;
                }
        }

        if (params->match_type == TABLE_LPM) {
                if (params->match.lpm.key_size == 4)
                        pp.lpm.entry_unique_size = p.action_data_size +
                                sizeof(struct rte_pipeline_table_entry);

                if (params->match.lpm.key_size == 16)
                        pp.lpm_ipv6.entry_unique_size = p.action_data_size +
                                sizeof(struct rte_pipeline_table_entry);
        }

        status = rte_pipeline_table_create(pipeline->p,
                &p,
                &table_id);
        if (status) {
                rte_table_action_free(action);
                return -1;
        }

        /* Pipeline */
        table = &pipeline->table[pipeline->n_tables];
        memcpy(&table->params, params, sizeof(*params));
        table->ap = ap;
        table->a = action;
        TAILQ_INIT(&table->rules);
        table->rule_default = NULL;

        pipeline->n_tables++;

        return 0;
}

struct table_rule *
table_rule_find(struct table *table,
    struct table_rule_match *match)
{
        struct table_rule *rule;

        TAILQ_FOREACH(rule, &table->rules, node)
                if (memcmp(&rule->match, match, sizeof(*match)) == 0)
                        return rule;

        return NULL;
}

void
table_rule_add(struct table *table,
    struct table_rule *new_rule)
{
        struct table_rule *existing_rule;

        existing_rule = table_rule_find(table, &new_rule->match);
        if (existing_rule == NULL)
                TAILQ_INSERT_TAIL(&table->rules, new_rule, node);
        else {
                TAILQ_INSERT_AFTER(&table->rules, existing_rule, new_rule, node);
                TAILQ_REMOVE(&table->rules, existing_rule, node);
                free(existing_rule);
        }
}

void
table_rule_add_bulk(struct table *table,
    struct table_rule_list *list,
    uint32_t n_rules)
{
        uint32_t i;

        for (i = 0; i < n_rules; i++) {
                struct table_rule *existing_rule, *new_rule;

                new_rule = TAILQ_FIRST(list);
                if (new_rule == NULL)
                        break;

                TAILQ_REMOVE(list, new_rule, node);

                existing_rule = table_rule_find(table, &new_rule->match);
                if (existing_rule == NULL)
                        TAILQ_INSERT_TAIL(&table->rules, new_rule, node);
                else {
                        TAILQ_INSERT_AFTER(&table->rules, existing_rule, new_rule, node);
                        TAILQ_REMOVE(&table->rules, existing_rule, node);
                        free(existing_rule);
                }
        }
}

void
table_rule_delete(struct table *table,
    struct table_rule_match *match)
{
        struct table_rule *rule;

        rule = table_rule_find(table, match);
        if (rule == NULL)
                return;

        TAILQ_REMOVE(&table->rules, rule, node);
        free(rule);
}

void
table_rule_default_add(struct table *table,
        struct table_rule *rule)
{
        free(table->rule_default);
        table->rule_default = rule;
}

void
table_rule_default_delete(struct table *table)
{
        free(table->rule_default);
        table->rule_default = NULL;
}