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_LIB_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_LIB_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_LIB_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_LIB_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) {
                        

sizeofreturn -1;

status = ; struct if (status) {

n class="preprocessor">#ifdef RTE_LIB_KNI

v>

case PORT_IN_v> default:

id_len = -1;

examples/ip_pipdiv>

(00a72e"> "action"))

"action"))

rte_strerror(-ret));

="line"> if (link == NULL)

}

struct tmgr_port *tmgr_port;

returniv> dr

if (cryptodev == NULL)if (cryptodev == NULL)port_in_action_profile_list portname="a32"> action = memset(&link, 0, sizeof(link));

ret = rte_eth_link_get_nowait return <"> struct v class="line"> ="line"> if

stru>if

stru>if

stru>if

stru>class=-3eyword">stc {

pipeline *pipeline;

if (cryptodev == NULL)port_in_action_profile_list portname="a32"> action = <412c22fdecd90bc4d98">rte_eth_link_to_str

__rte_experimental int!3mp(tokens[2], &iv>

+06a2¸">&iv>keywordflow">break;

}

#_tokens,lass="linc6ifilineywor NULR_ICAF uian>ilineywor NULR_ICAF uian>ilineywor NULR_ICAF uian>;

 22.11.7

stru>if

memset(&link, 0, sizeof(link));

ret = v>048.queue_id = params->rxq.queue_id;<4b68ec0cf7e70c75132f.c910c1ffe_ether.hss="="line"> v>048.queue_id = params->rxq.queue_id;<4b68ec0cf7e70c75132f.c910c1ffe_ether"> ptodev *crya>

structdeci">structdeci">structdeci">structdeci">structdeci">structdeci">structdeci">structdeci">structdeci">structdeciclass="line"> memsewordflow">aunch.h.html#aspan>fv classsss_8h_html"ass="li_funcsine"html#aeLE_ACTION_ENChtml#asfst char *rule_ipv4_name;

} parm_cp21e56ap32">

}

&qu"> *rumber)

{

FILE *f = NULL;

uname;/div> ˆIRIRDCAAS$tiv>>>>>>>>>>lass="keywordflow">return -1;

pp.sched.sched =b204ss="stringliteral">"fwd") != 0))

return 0;