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;
}