DPDK 25.03.0-rc0
examples/ip_pipeline/cli.c
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2010-2018 Intel Corporation
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <rte_common.h>
#include <rte_cycles.h>
#include <rte_ethdev.h>
#include "cli.h"
#include "cryptodev.h"
#include "link.h"
#include "mempool.h"
#include "parser.h"
#include "pipeline.h"
#include "swq.h"
#include "tap.h"
#include "thread.h"
#include "tmgr.h"
#ifndef CMD_MAX_TOKENS
#define CMD_MAX_TOKENS 256
#endif
#define MSG_OUT_OF_MEMORY "Not enough memory.\n"
#define MSG_CMD_UNKNOWN "Unknown command \"%s\".\n"
#define MSG_CMD_UNIMPLEM "Command \"%s\" not implemented.\n"
#define MSG_ARG_NOT_ENOUGH "Not enough arguments for command \"%s\".\n"
#define MSG_ARG_TOO_MANY "Too many arguments for command \"%s\".\n"
#define MSG_ARG_MISMATCH "Wrong number of arguments for command \"%s\".\n"
#define MSG_ARG_NOT_FOUND "Argument \"%s\" not found.\n"
#define MSG_ARG_INVALID "Invalid value for argument \"%s\".\n"
#define MSG_FILE_ERR "Error in file \"%s\" at line %u.\n"
#define MSG_FILE_NOT_ENOUGH "Not enough rules in file \"%s\".\n"
#define MSG_CMD_FAIL "Command \"%s\" failed.\n"
static int
is_comment(char *in)
{
if ((strlen(in) && index("!#%;", in[0])) ||
(strncmp(in, "//", 2) == 0) ||
(strncmp(in, "--", 2) == 0))
return 1;
return 0;
}
static const char cmd_mempool_help[] =
"mempool <mempool_name>\n"
" buffer <buffer_size>\n"
" pool <pool_size>\n"
" cache <cache_size>\n"
" cpu <cpu_id>\n";
static void
cmd_mempool(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct mempool_params p;
char *name;
struct mempool *mempool;
if (n_tokens != 10) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
name = tokens[1];
if (strcmp(tokens[2], "buffer") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "buffer");
return;
}
if (parser_read_uint32(&p.buffer_size, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "buffer_size");
return;
}
if (strcmp(tokens[4], "pool") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pool");
return;
}
if (parser_read_uint32(&p.pool_size, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "pool_size");
return;
}
if (strcmp(tokens[6], "cache") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cache");
return;
}
if (parser_read_uint32(&p.cache_size, tokens[7]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "cache_size");
return;
}
if (strcmp(tokens[8], "cpu") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu");
return;
}
if (parser_read_uint32(&p.cpu_id, tokens[9]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id");
return;
}
mempool = mempool_create(name, &p);
if (mempool == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_link_help[] =
"link <link_name>\n"
" dev <device_name> | port <port_id>\n"
" rxq <n_queues> <queue_size> <mempool_name>\n"
" txq <n_queues> <queue_size>\n"
" promiscuous on | off\n"
" [rss <qid_0> ... <qid_n>]\n";
static void
cmd_link(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct link_params p;
struct link_params_rss rss;
struct link *link;
char *name;
memset(&p, 0, sizeof(p));
if ((n_tokens < 13) || (n_tokens > 14 + LINK_RXQ_RSS_MAX)) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
name = tokens[1];
if (strcmp(tokens[2], "dev") == 0)
p.dev_name = tokens[3];
else if (strcmp(tokens[2], "port") == 0) {
p.dev_name = NULL;
if (parser_read_uint16(&p.port_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
return;
}
} else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "dev or port");
return;
}
if (strcmp(tokens[4], "rxq") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rxq");
return;
}
if (parser_read_uint32(&p.rx.n_queues, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_queues");
return;
}
if (parser_read_uint32(&p.rx.queue_size, tokens[6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "queue_size");
return;
}
p.rx.mempool_name = tokens[7];
if (strcmp(tokens[8], "txq") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "txq");
return;
}
if (parser_read_uint32(&p.tx.n_queues, tokens[9]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_queues");
return;
}
if (parser_read_uint32(&p.tx.queue_size, tokens[10]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "queue_size");
return;
}
if (strcmp(tokens[11], "promiscuous") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "promiscuous");
return;
}
if (strcmp(tokens[12], "on") == 0)
p.promiscuous = 1;
else if (strcmp(tokens[12], "off") == 0)
p.promiscuous = 0;
else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "on or off");
return;
}
/* RSS */
p.rx.rss = NULL;
if (n_tokens > 13) {
uint32_t queue_id, i;
if (strcmp(tokens[13], "rss") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rss");
return;
}
p.rx.rss = &rss;
rss.n_queues = 0;
for (i = 14; i < n_tokens; i++) {
if (parser_read_uint32(&queue_id, tokens[i]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"queue_id");
return;
}
rss.queue_id[rss.n_queues] = queue_id;
rss.n_queues++;
}
}
link = link_create(name, &p);
if (link == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
/* Print the link stats and info */
static void
print_link_info(struct link *link, char *out, size_t out_size)
{
struct rte_eth_stats stats;
struct rte_ether_addr mac_addr;
struct rte_eth_link eth_link;
uint16_t mtu;
int ret;
memset(&stats, 0, sizeof(stats));
rte_eth_stats_get(link->port_id, &stats);
ret = rte_eth_macaddr_get(link->port_id, &mac_addr);
if (ret != 0) {
snprintf(out, out_size, "\n%s: MAC address get failed: %s",
link->name, rte_strerror(-ret));
return;
}
ret = rte_eth_link_get(link->port_id, &eth_link);
if (ret < 0) {
snprintf(out, out_size, "\n%s: link get failed: %s",
link->name, rte_strerror(-ret));
return;
}
rte_eth_dev_get_mtu(link->port_id, &mtu);
snprintf(out, out_size,
"\n"
"%s: flags=<%s> mtu %u\n"
"\tether " RTE_ETHER_ADDR_PRT_FMT " rxqueues %u txqueues %u\n"
"\tport# %u speed %s\n"
"\tRX packets %" PRIu64" bytes %" PRIu64"\n"
"\tRX errors %" PRIu64" missed %" PRIu64" no-mbuf %" PRIu64"\n"
"\tTX packets %" PRIu64" bytes %" PRIu64"\n"
"\tTX errors %" PRIu64"\n",
link->name,
eth_link.link_status == 0 ? "DOWN" : "UP",
mtu,
RTE_ETHER_ADDR_BYTES(&mac_addr),
link->n_rxq,
link->n_txq,
link->port_id,
rte_eth_link_speed_to_str(eth_link.link_speed),
stats.ipackets,
stats.ibytes,
stats.ierrors,
stats.imissed,
stats.rx_nombuf,
stats.opackets,
stats.obytes,
stats.oerrors);
}
/*
* link show [<link_name>]
*/
static void
cmd_link_show(char **tokens, uint32_t n_tokens, char *out, size_t out_size)
{
struct link *link;
char *link_name;
if (n_tokens != 2 && n_tokens != 3) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
if (n_tokens == 2) {
link = link_next(NULL);
while (link != NULL) {
out_size = out_size - strlen(out);
out = &out[strlen(out)];
print_link_info(link, out, out_size);
link = link_next(link);
}
} else {
out_size = out_size - strlen(out);
out = &out[strlen(out)];
link_name = tokens[2];
link = link_find(link_name);
if (link == NULL) {
snprintf(out, out_size, MSG_ARG_INVALID,
"Link does not exist");
return;
}
print_link_info(link, out, out_size);
}
}
static const char cmd_swq_help[] =
"swq <swq_name>\n"
" size <size>\n"
" cpu <cpu_id>\n";
static void
cmd_swq(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct swq_params p;
char *name;
struct swq *swq;
if (n_tokens != 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
name = tokens[1];
if (strcmp(tokens[2], "size") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
return;
}
if (parser_read_uint32(&p.size, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "size");
return;
}
if (strcmp(tokens[4], "cpu") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu");
return;
}
if (parser_read_uint32(&p.cpu_id, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id");
return;
}
swq = swq_create(name, &p);
if (swq == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_tmgr_subport_profile_help[] =
"tmgr subport profile\n"
" <tb_rate> <tb_size>\n"
" <tc0_rate> <tc1_rate> <tc2_rate> <tc3_rate> <tc4_rate>"
" <tc5_rate> <tc6_rate> <tc7_rate> <tc8_rate>"
" <tc9_rate> <tc10_rate> <tc11_rate> <tc12_rate>\n"
" <tc_period>\n";
static void
cmd_tmgr_subport_profile(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct rte_sched_subport_profile_params subport_profile;
int status, i;
if (n_tokens != 19) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
if (parser_read_uint64(&subport_profile.tb_rate, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "tb_rate");
return;
}
if (parser_read_uint64(&subport_profile.tb_size, tokens[4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "tb_size");
return;
}
for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++)
if (parser_read_uint64(&subport_profile.tc_rate[i],
tokens[5 + i]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "tc_rate");
return;
}
if (parser_read_uint64(&subport_profile.tc_period, tokens[18]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "tc_period");
return;
}
status = tmgr_subport_profile_add(&subport_profile);
if (status != 0) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_tmgr_pipe_profile_help[] =
"tmgr pipe profile\n"
" <tb_rate> <tb_size>\n"
" <tc0_rate> <tc1_rate> <tc2_rate> <tc3_rate> <tc4_rate>"
" <tc5_rate> <tc6_rate> <tc7_rate> <tc8_rate>"
" <tc9_rate> <tc10_rate> <tc11_rate> <tc12_rate>\n"
" <tc_period>\n"
" <tc_ov_weight>\n"
" <wrr_weight0..3>\n";
static void
cmd_tmgr_pipe_profile(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct rte_sched_pipe_params p;
int status, i;
if (n_tokens != 24) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
if (parser_read_uint64(&p.tb_rate, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "tb_rate");
return;
}
if (parser_read_uint64(&p.tb_size, tokens[4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "tb_size");
return;
}
for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++)
if (parser_read_uint64(&p.tc_rate[i], tokens[5 + i]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "tc_rate");
return;
}
if (parser_read_uint64(&p.tc_period, tokens[18]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "tc_period");
return;
}
if (parser_read_uint8(&p.tc_ov_weight, tokens[19]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "tc_ov_weight");
return;
}
for (i = 0; i < RTE_SCHED_BE_QUEUES_PER_PIPE; i++)
if (parser_read_uint8(&p.wrr_weights[i], tokens[20 + i]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "wrr_weights");
return;
}
status = tmgr_pipe_profile_add(&p);
if (status != 0) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_tmgr_help[] =
"tmgr <tmgr_name>\n"
" rate <rate>\n"
" spp <n_subports_per_port>\n"
" pps <n_pipes_per_subport>\n"
" fo <frame_overhead>\n"
" mtu <mtu>\n"
" cpu <cpu_id>\n";
static void
cmd_tmgr(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct tmgr_port_params p;
char *name;
struct tmgr_port *tmgr_port;
if (n_tokens != 14) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
name = tokens[1];
if (strcmp(tokens[2], "rate") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rate");
return;
}
if (parser_read_uint64(&p.rate, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "rate");
return;
}
if (strcmp(tokens[4], "spp") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "spp");
return;
}
if (parser_read_uint32(&p.n_subports_per_port, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_subports_per_port");
return;
}
if (strcmp(tokens[6], "pps") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "spp");
return;
}
if (parser_read_uint32(&p.n_pipes_per_subport, tokens[7]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_pipes_per_subport");
return;
}
if (strcmp(tokens[8], "fo") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "fo");
return;
}
if (parser_read_uint32(&p.frame_overhead, tokens[9]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "frame_overhead");
return;
}
if (strcmp(tokens[10], "mtu") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mtu");
return;
}
if (parser_read_uint32(&p.mtu, tokens[11]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "mtu");
return;
}
if (strcmp(tokens[12], "cpu") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu");
return;
}
if (parser_read_uint32(&p.cpu_id, tokens[13]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id");
return;
}
tmgr_port = tmgr_port_create(name, &p);
if (tmgr_port == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_tmgr_subport_help[] =
"tmgr <tmgr_name> subport <subport_id>\n"
" profile <subport_profile_id>\n";
static void
cmd_tmgr_subport(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
uint32_t subport_id, subport_profile_id;
int status;
char *name;
if (n_tokens != 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
name = tokens[1];
if (parser_read_uint32(&subport_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "subport_id");
return;
}
if (parser_read_uint32(&subport_profile_id, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "subport_profile_id");
return;
}
status = tmgr_subport_config(name, subport_id, subport_profile_id);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_tmgr_subport_pipe_help[] =
"tmgr <tmgr_name> subport <subport_id> pipe\n"
" from <pipe_id_first> to <pipe_id_last>\n"
" profile <pipe_profile_id>\n";
static void
cmd_tmgr_subport_pipe(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
uint32_t subport_id, pipe_id_first, pipe_id_last, pipe_profile_id;
int status;
char *name;
if (n_tokens != 11) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
name = tokens[1];
if (parser_read_uint32(&subport_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "subport_id");
return;
}
if (strcmp(tokens[4], "pipe") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipe");
return;
}
if (strcmp(tokens[5], "from") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "from");
return;
}
if (parser_read_uint32(&pipe_id_first, tokens[6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "pipe_id_first");
return;
}
if (strcmp(tokens[7], "to") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "to");
return;
}
if (parser_read_uint32(&pipe_id_last, tokens[8]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "pipe_id_last");
return;
}
if (strcmp(tokens[9], "profile") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
return;
}
if (parser_read_uint32(&pipe_profile_id, tokens[10]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "pipe_profile_id");
return;
}
status = tmgr_pipe_config(name, subport_id, pipe_id_first,
pipe_id_last, pipe_profile_id);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_tap_help[] =
"tap <tap_name>\n";
static void
cmd_tap(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
char *name;
struct tap *tap;
if (n_tokens != 2) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
name = tokens[1];
tap = tap_create(name);
if (tap == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_cryptodev_help[] =
"cryptodev <cryptodev_name>\n"
" dev <device_name> | dev_id <device_id>\n"
" queue <n_queues> <queue_size>\n"
" max_sessions <n_sessions>";
static void
cmd_cryptodev(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct cryptodev_params params;
char *name;
memset(&params, 0, sizeof(params));
if (n_tokens != 9) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
name = tokens[1];
if (strcmp(tokens[2], "dev") == 0)
params.dev_name = tokens[3];
else if (strcmp(tokens[2], "dev_id") == 0) {
if (parser_read_uint32(&params.dev_id, tokens[3]) < 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"dev_id");
return;
}
} else {
snprintf(out, out_size, MSG_ARG_INVALID,
"cryptodev");
return;
}
if (strcmp(tokens[4], "queue")) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"queue");
return;
}
if (parser_read_uint32(&params.n_queues, tokens[5]) < 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"q");
return;
}
if (parser_read_uint32(&params.queue_size, tokens[6]) < 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"queue_size");
return;
}
if (strcmp(tokens[7], "max_sessions")) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"max_sessions");
return;
}
if (parser_read_uint32(&params.session_pool_size, tokens[8]) < 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"queue_size");
return;
}
if (cryptodev_create(name, &params) == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_port_in_action_profile_help[] =
"port in action profile <profile_name>\n"
" [filter match | mismatch offset <key_offset> mask <key_mask> key <key_value> port <port_id>]\n"
" [balance offset <key_offset> mask <key_mask> port <port_id0> ... <port_id15>]\n";
static void
cmd_port_in_action_profile(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct port_in_action_profile_params p;
struct port_in_action_profile *ap;
char *name;
uint32_t t0;
memset(&p, 0, sizeof(p));
if (n_tokens < 5) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
if (strcmp(tokens[1], "in") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
return;
}
if (strcmp(tokens[2], "action") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "action");
return;
}
if (strcmp(tokens[3], "profile") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
return;
}
name = tokens[4];
t0 = 5;
if ((t0 < n_tokens) && (strcmp(tokens[t0], "filter") == 0)) {
uint32_t size;
if (n_tokens < t0 + 10) {
snprintf(out, out_size, MSG_ARG_MISMATCH, "port in action profile filter");
return;
}
if (strcmp(tokens[t0 + 1], "match") == 0)
p.fltr.filter_on_match = 1;
else if (strcmp(tokens[t0 + 1], "mismatch") == 0)
p.fltr.filter_on_match = 0;
else {
snprintf(out, out_size, MSG_ARG_INVALID, "match or mismatch");
return;
}
if (strcmp(tokens[t0 + 2], "offset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
return;
}
if (parser_read_uint32(&p.fltr.key_offset, tokens[t0 + 3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
return;
}
if (strcmp(tokens[t0 + 4], "mask") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask");
return;
}
size = RTE_PORT_IN_ACTION_FLTR_KEY_SIZE;
if ((parse_hex_string(tokens[t0 + 5], p.fltr.key_mask, &size) != 0) ||
(size != RTE_PORT_IN_ACTION_FLTR_KEY_SIZE)) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_mask");
return;
}
if (strcmp(tokens[t0 + 6], "key") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "key");
return;
}
size = RTE_PORT_IN_ACTION_FLTR_KEY_SIZE;
if ((parse_hex_string(tokens[t0 + 7], p.fltr.key, &size) != 0) ||
(size != RTE_PORT_IN_ACTION_FLTR_KEY_SIZE)) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_value");
return;
}
if (strcmp(tokens[t0 + 8], "port") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (parser_read_uint32(&p.fltr.port_id, tokens[t0 + 9]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
return;
}
p.action_mask |= 1LLU << RTE_PORT_IN_ACTION_FLTR;
t0 += 10;
} /* filter */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "balance") == 0)) {
uint32_t i;
if (n_tokens < t0 + 22) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"port in action profile balance");
return;
}
if (strcmp(tokens[t0 + 1], "offset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
return;
}
if (parser_read_uint32(&p.lb.key_offset, tokens[t0 + 2]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
return;
}
if (strcmp(tokens[t0 + 3], "mask") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask");
return;
}
p.lb.key_size = RTE_PORT_IN_ACTION_LB_KEY_SIZE_MAX;
if (parse_hex_string(tokens[t0 + 4], p.lb.key_mask, &p.lb.key_size) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_mask");
return;
}
if (strcmp(tokens[t0 + 5], "port") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
for (i = 0; i < 16; i++)
if (parser_read_uint32(&p.lb.port_id[i], tokens[t0 + 6 + i]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
return;
}
p.action_mask |= 1LLU << RTE_PORT_IN_ACTION_LB;
t0 += 22;
} /* balance */
if (t0 < n_tokens) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
ap = port_in_action_profile_create(name, &p);
if (ap == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_table_action_profile_help[] =
"table action profile <profile_name>\n"
" ipv4 | ipv6\n"
" offset <ip_offset>\n"
" fwd\n"
" [balance offset <key_offset> mask <key_mask> outoffset <out_offset>]\n"
" [meter srtcm | trtcm\n"
" tc <n_tc>\n"
" stats none | pkts | bytes | both]\n"
" [tm spp <n_subports_per_port> pps <n_pipes_per_subport>]\n"
" [encap ether | vlan | qinq | mpls | pppoe | qinq_pppoe \n"
" vxlan offset <ether_offset> ipv4 | ipv6 vlan on | off]\n"
" [nat src | dst\n"
" proto udp | tcp]\n"
" [ttl drop | fwd\n"
" stats none | pkts]\n"
" [stats pkts | bytes | both]\n"
" [time]\n"
" [sym_crypto dev <CRYPTODEV_NAME> offset <op_offset>]\n"
" [tag]\n"
" [decap]\n";
static void
cmd_table_action_profile(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct table_action_profile_params p;
struct table_action_profile *ap;
char *name;
uint32_t t0;
memset(&p, 0, sizeof(p));
if (n_tokens < 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
if (strcmp(tokens[1], "action") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "action");
return;
}
if (strcmp(tokens[2], "profile") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
return;
}
name = tokens[3];
if (strcmp(tokens[4], "ipv4") == 0)
p.common.ip_version = 1;
else if (strcmp(tokens[4], "ipv6") == 0)
p.common.ip_version = 0;
else {
snprintf(out, out_size, MSG_ARG_INVALID, "ipv4 or ipv6");
return;
}
if (strcmp(tokens[5], "offset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
return;
}
if (parser_read_uint32(&p.common.ip_offset, tokens[6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "ip_offset");
return;
}
if (strcmp(tokens[7], "fwd") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "fwd");
return;
}
p.action_mask |= 1LLU << RTE_TABLE_ACTION_FWD;
t0 = 8;
if ((t0 < n_tokens) && (strcmp(tokens[t0], "balance") == 0)) {
if (n_tokens < t0 + 7) {
snprintf(out, out_size, MSG_ARG_MISMATCH, "table action profile balance");
return;
}
if (strcmp(tokens[t0 + 1], "offset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
return;
}
if (parser_read_uint32(&p.lb.key_offset, tokens[t0 + 2]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
return;
}
if (strcmp(tokens[t0 + 3], "mask") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask");
return;
}
p.lb.key_size = RTE_PORT_IN_ACTION_LB_KEY_SIZE_MAX;
if (parse_hex_string(tokens[t0 + 4], p.lb.key_mask, &p.lb.key_size) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_mask");
return;
}
if (strcmp(tokens[t0 + 5], "outoffset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "outoffset");
return;
}
if (parser_read_uint32(&p.lb.out_offset, tokens[t0 + 6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "out_offset");
return;
}
p.action_mask |= 1LLU << RTE_TABLE_ACTION_LB;
t0 += 7;
} /* balance */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "meter") == 0)) {
if (n_tokens < t0 + 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"table action profile meter");
return;
}
if (strcmp(tokens[t0 + 1], "srtcm") == 0)
p.mtr.alg = RTE_TABLE_ACTION_METER_SRTCM;
else if (strcmp(tokens[t0 + 1], "trtcm") == 0)
p.mtr.alg = RTE_TABLE_ACTION_METER_TRTCM;
else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"srtcm or trtcm");
return;
}
if (strcmp(tokens[t0 + 2], "tc") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc");
return;
}
if (parser_read_uint32(&p.mtr.n_tc, tokens[t0 + 3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_tc");
return;
}
if (strcmp(tokens[t0 + 4], "stats") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
return;
}
if (strcmp(tokens[t0 + 5], "none") == 0) {
p.mtr.n_packets_enabled = 0;
p.mtr.n_bytes_enabled = 0;
} else if (strcmp(tokens[t0 + 5], "pkts") == 0) {
p.mtr.n_packets_enabled = 1;
p.mtr.n_bytes_enabled = 0;
} else if (strcmp(tokens[t0 + 5], "bytes") == 0) {
p.mtr.n_packets_enabled = 0;
p.mtr.n_bytes_enabled = 1;
} else if (strcmp(tokens[t0 + 5], "both") == 0) {
p.mtr.n_packets_enabled = 1;
p.mtr.n_bytes_enabled = 1;
} else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"none or pkts or bytes or both");
return;
}
p.action_mask |= 1LLU << RTE_TABLE_ACTION_MTR;
t0 += 6;
} /* meter */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "tm") == 0)) {
if (n_tokens < t0 + 5) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"table action profile tm");
return;
}
if (strcmp(tokens[t0 + 1], "spp") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "spp");
return;
}
if (parser_read_uint32(&p.tm.n_subports_per_port,
tokens[t0 + 2]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"n_subports_per_port");
return;
}
if (strcmp(tokens[t0 + 3], "pps") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pps");
return;
}
if (parser_read_uint32(&p.tm.n_pipes_per_subport,
tokens[t0 + 4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"n_pipes_per_subport");
return;
}
p.action_mask |= 1LLU << RTE_TABLE_ACTION_TM;
t0 += 5;
} /* tm */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "encap") == 0)) {
uint32_t n_extra_tokens = 0;
if (n_tokens < t0 + 2) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"action profile encap");
return;
}
if (strcmp(tokens[t0 + 1], "ether") == 0)
p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_ETHER;
else if (strcmp(tokens[t0 + 1], "vlan") == 0)
p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_VLAN;
else if (strcmp(tokens[t0 + 1], "qinq") == 0)
p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_QINQ;
else if (strcmp(tokens[t0 + 1], "mpls") == 0)
p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_MPLS;
else if (strcmp(tokens[t0 + 1], "pppoe") == 0)
p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_PPPOE;
else if (strcmp(tokens[t0 + 1], "vxlan") == 0) {
if (n_tokens < t0 + 2 + 5) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"action profile encap vxlan");
return;
}
if (strcmp(tokens[t0 + 2], "offset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"vxlan: offset");
return;
}
if (parser_read_uint32(&p.encap.vxlan.data_offset,
tokens[t0 + 2 + 1]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"vxlan: ether_offset");
return;
}
if (strcmp(tokens[t0 + 2 + 2], "ipv4") == 0)
p.encap.vxlan.ip_version = 1;
else if (strcmp(tokens[t0 + 2 + 2], "ipv6") == 0)
p.encap.vxlan.ip_version = 0;
else {
snprintf(out, out_size, MSG_ARG_INVALID,
"vxlan: ipv4 or ipv6");
return;
}
if (strcmp(tokens[t0 + 2 + 3], "vlan") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"vxlan: vlan");
return;
}
if (strcmp(tokens[t0 + 2 + 4], "on") == 0)
p.encap.vxlan.vlan = 1;
else if (strcmp(tokens[t0 + 2 + 4], "off") == 0)
p.encap.vxlan.vlan = 0;
else {
snprintf(out, out_size, MSG_ARG_INVALID,
"vxlan: on or off");
return;
}
p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_VXLAN;
n_extra_tokens = 5;
} else if (strcmp(tokens[t0 + 1], "qinq_pppoe") == 0)
p.encap.encap_mask =
1LLU << RTE_TABLE_ACTION_ENCAP_QINQ_PPPOE;
else {
snprintf(out, out_size, MSG_ARG_MISMATCH, "encap");
return;
}
p.action_mask |= 1LLU << RTE_TABLE_ACTION_ENCAP;
t0 += 2 + n_extra_tokens;
} /* encap */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "nat") == 0)) {
if (n_tokens < t0 + 4) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"table action profile nat");
return;
}
if (strcmp(tokens[t0 + 1], "src") == 0)
p.nat.source_nat = 1;
else if (strcmp(tokens[t0 + 1], "dst") == 0)
p.nat.source_nat = 0;
else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"src or dst");
return;
}
if (strcmp(tokens[t0 + 2], "proto") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "proto");
return;
}
if (strcmp(tokens[t0 + 3], "tcp") == 0)
p.nat.proto = 0x06;
else if (strcmp(tokens[t0 + 3], "udp") == 0)
p.nat.proto = 0x11;
else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"tcp or udp");
return;
}
p.action_mask |= 1LLU << RTE_TABLE_ACTION_NAT;
t0 += 4;
} /* nat */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "ttl") == 0)) {
if (n_tokens < t0 + 4) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"table action profile ttl");
return;
}
if (strcmp(tokens[t0 + 1], "drop") == 0)
p.ttl.drop = 1;
else if (strcmp(tokens[t0 + 1], "fwd") == 0)
p.ttl.drop = 0;
else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"drop or fwd");
return;
}
if (strcmp(tokens[t0 + 2], "stats") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
return;
}
if (strcmp(tokens[t0 + 3], "none") == 0)
p.ttl.n_packets_enabled = 0;
else if (strcmp(tokens[t0 + 3], "pkts") == 0)
p.ttl.n_packets_enabled = 1;
else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"none or pkts");
return;
}
p.action_mask |= 1LLU << RTE_TABLE_ACTION_TTL;
t0 += 4;
} /* ttl */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "stats") == 0)) {
if (n_tokens < t0 + 2) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"table action profile stats");
return;
}
if (strcmp(tokens[t0 + 1], "pkts") == 0) {
p.stats.n_packets_enabled = 1;
p.stats.n_bytes_enabled = 0;
} else if (strcmp(tokens[t0 + 1], "bytes") == 0) {
p.stats.n_packets_enabled = 0;
p.stats.n_bytes_enabled = 1;
} else if (strcmp(tokens[t0 + 1], "both") == 0) {
p.stats.n_packets_enabled = 1;
p.stats.n_bytes_enabled = 1;
} else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"pkts or bytes or both");
return;
}
p.action_mask |= 1LLU << RTE_TABLE_ACTION_STATS;
t0 += 2;
} /* stats */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "time") == 0)) {
p.action_mask |= 1LLU << RTE_TABLE_ACTION_TIME;
t0 += 1;
} /* time */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "sym_crypto") == 0)) {
struct cryptodev *cryptodev;
if (n_tokens < t0 + 5 ||
strcmp(tokens[t0 + 1], "dev") ||
strcmp(tokens[t0 + 3], "offset")) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"table action profile sym_crypto");
return;
}
cryptodev = cryptodev_find(tokens[t0 + 2]);
if (cryptodev == NULL) {
snprintf(out, out_size, MSG_ARG_INVALID,
"table action profile sym_crypto");
return;
}
p.sym_crypto.cryptodev_id = cryptodev->dev_id;
if (parser_read_uint32(&p.sym_crypto.op_offset,
tokens[t0 + 4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"table action profile sym_crypto");
return;
}
p.sym_crypto.mp_create = cryptodev->mp_create;
p.sym_crypto.mp_init = cryptodev->mp_init;
p.action_mask |= 1LLU << RTE_TABLE_ACTION_SYM_CRYPTO;
t0 += 5;
} /* sym_crypto */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "tag") == 0)) {
p.action_mask |= 1LLU << RTE_TABLE_ACTION_TAG;
t0 += 1;
} /* tag */
if ((t0 < n_tokens) && (strcmp(tokens[t0], "decap") == 0)) {
p.action_mask |= 1LLU << RTE_TABLE_ACTION_DECAP;
t0 += 1;
} /* decap */
if (t0 < n_tokens) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
ap = table_action_profile_create(name, &p);
if (ap == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_help[] =
"pipeline <pipeline_name>\n"
" period <timer_period_ms>\n"
" offset_port_id <offset_port_id>\n"
" cpu <cpu_id>\n";
static void
cmd_pipeline(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct pipeline_params p;
char *name;
struct pipeline *pipeline;
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
name = tokens[1];
if (strcmp(tokens[2], "period") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "period");
return;
}
if (parser_read_uint32(&p.timer_period_ms, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "timer_period_ms");
return;
}
if (strcmp(tokens[4], "offset_port_id") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset_port_id");
return;
}
if (parser_read_uint32(&p.offset_port_id, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "offset_port_id");
return;
}
if (strcmp(tokens[6], "cpu") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu");
return;
}
if (parser_read_uint32(&p.cpu_id, tokens[7]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id");
return;
}
pipeline = pipeline_create(name, &p);
if (pipeline == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_port_in_help[] =
"pipeline <pipeline_name> port in\n"
" bsz <burst_size>\n"
" link <link_name> rxq <queue_id>\n"
" | swq <swq_name>\n"
" | tmgr <tmgr_name>\n"
" | tap <tap_name> mempool <mempool_name> mtu <mtu>\n"
" | source mempool <mempool_name> file <file_name> bpp <n_bytes_per_pkt>\n"
" | cryptodev <cryptodev_name> rxq <queue_id>\n"
" [action <port_in_action_profile_name>]\n"
" [disabled]\n";
static void
cmd_pipeline_port_in(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct port_in_params p;
char *pipeline_name;
uint32_t t0;
int enabled, status;
if (n_tokens < 7) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "port") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (strcmp(tokens[3], "in") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
return;
}
if (strcmp(tokens[4], "bsz") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "bsz");
return;
}
if (parser_read_uint32(&p.burst_size, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "burst_size");
return;
}
t0 = 6;
if (strcmp(tokens[t0], "link") == 0) {
if (n_tokens < t0 + 4) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port in link");
return;
}
p.type = PORT_IN_RXQ;
p.dev_name = tokens[t0 + 1];
if (strcmp(tokens[t0 + 2], "rxq") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rxq");
return;
}
if (parser_read_uint16(&p.rxq.queue_id, tokens[t0 + 3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"queue_id");
return;
}
t0 += 4;
} else if (strcmp(tokens[t0], "swq") == 0) {
if (n_tokens < t0 + 2) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port in swq");
return;
}
p.type = PORT_IN_SWQ;
p.dev_name = tokens[t0 + 1];
t0 += 2;
} else if (strcmp(tokens[t0], "tmgr") == 0) {
if (n_tokens < t0 + 2) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port in tmgr");
return;
}
p.type = PORT_IN_TMGR;
p.dev_name = tokens[t0 + 1];
t0 += 2;
} else if (strcmp(tokens[t0], "tap") == 0) {
if (n_tokens < t0 + 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port in tap");
return;
}
p.type = PORT_IN_TAP;
p.dev_name = tokens[t0 + 1];
if (strcmp(tokens[t0 + 2], "mempool") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"mempool");
return;
}
p.tap.mempool_name = tokens[t0 + 3];
if (strcmp(tokens[t0 + 4], "mtu") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"mtu");
return;
}
if (parser_read_uint32(&p.tap.mtu, tokens[t0 + 5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "mtu");
return;
}
t0 += 6;
} else if (strcmp(tokens[t0], "source") == 0) {
if (n_tokens < t0 + 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port in source");
return;
}
p.type = PORT_IN_SOURCE;
p.dev_name = NULL;
if (strcmp(tokens[t0 + 1], "mempool") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"mempool");
return;
}
p.source.mempool_name = tokens[t0 + 2];
if (strcmp(tokens[t0 + 3], "file") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"file");
return;
}
p.source.file_name = tokens[t0 + 4];
if (strcmp(tokens[t0 + 5], "bpp") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"bpp");
return;
}
if (parser_read_uint32(&p.source.n_bytes_per_pkt, tokens[t0 + 6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"n_bytes_per_pkt");
return;
}
t0 += 7;
} else if (strcmp(tokens[t0], "cryptodev") == 0) {
if (n_tokens < t0 + 3) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port in cryptodev");
return;
}
p.type = PORT_IN_CRYPTODEV;
p.dev_name = tokens[t0 + 1];
if (parser_read_uint16(&p.rxq.queue_id, tokens[t0 + 3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"rxq");
return;
}
p.cryptodev.arg_callback = NULL;
p.cryptodev.f_callback = NULL;
t0 += 4;
} else {
snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
return;
}
p.action_profile_name = NULL;
if ((n_tokens > t0) && (strcmp(tokens[t0], "action") == 0)) {
if (n_tokens < t0 + 2) {
snprintf(out, out_size, MSG_ARG_MISMATCH, "action");
return;
}
p.action_profile_name = tokens[t0 + 1];
t0 += 2;
}
enabled = 1;
if ((n_tokens > t0) &&
(strcmp(tokens[t0], "disabled") == 0)) {
enabled = 0;
t0 += 1;
}
if (n_tokens != t0) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
status = pipeline_port_in_create(pipeline_name,
&p, enabled);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_port_out_help[] =
"pipeline <pipeline_name> port out\n"
" bsz <burst_size>\n"
" link <link_name> txq <txq_id>\n"
" | swq <swq_name>\n"
" | tmgr <tmgr_name>\n"
" | tap <tap_name>\n"
" | sink [file <file_name> pkts <max_n_pkts>]\n"
" | cryptodev <cryptodev_name> txq <txq_id> offset <crypto_op_offset>\n";
static void
cmd_pipeline_port_out(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct port_out_params p;
char *pipeline_name;
int status;
memset(&p, 0, sizeof(p));
if (n_tokens < 7) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "port") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (strcmp(tokens[3], "out") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "out");
return;
}
if (strcmp(tokens[4], "bsz") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "bsz");
return;
}
if (parser_read_uint32(&p.burst_size, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "burst_size");
return;
}
if (strcmp(tokens[6], "link") == 0) {
if (n_tokens != 10) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port out link");
return;
}
p.type = PORT_OUT_TXQ;
p.dev_name = tokens[7];
if (strcmp(tokens[8], "txq") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "txq");
return;
}
if (parser_read_uint16(&p.txq.queue_id, tokens[9]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "queue_id");
return;
}
} else if (strcmp(tokens[6], "swq") == 0) {
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port out swq");
return;
}
p.type = PORT_OUT_SWQ;
p.dev_name = tokens[7];
} else if (strcmp(tokens[6], "tmgr") == 0) {
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port out tmgr");
return;
}
p.type = PORT_OUT_TMGR;
p.dev_name = tokens[7];
} else if (strcmp(tokens[6], "tap") == 0) {
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port out tap");
return;
}
p.type = PORT_OUT_TAP;
p.dev_name = tokens[7];
} else if (strcmp(tokens[6], "sink") == 0) {
if ((n_tokens != 7) && (n_tokens != 11)) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port out sink");
return;
}
p.type = PORT_OUT_SINK;
p.dev_name = NULL;
if (n_tokens == 7) {
p.sink.file_name = NULL;
p.sink.max_n_pkts = 0;
} else {
if (strcmp(tokens[7], "file") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"file");
return;
}
p.sink.file_name = tokens[8];
if (strcmp(tokens[9], "pkts") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pkts");
return;
}
if (parser_read_uint32(&p.sink.max_n_pkts, tokens[10]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "max_n_pkts");
return;
}
}
} else if (strcmp(tokens[6], "cryptodev") == 0) {
if (n_tokens != 12) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port out cryptodev");
return;
}
p.type = PORT_OUT_CRYPTODEV;
p.dev_name = tokens[7];
if (strcmp(tokens[8], "txq")) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port out cryptodev");
return;
}
if (parser_read_uint16(&p.cryptodev.queue_id, tokens[9])
!= 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "queue_id");
return;
}
if (strcmp(tokens[10], "offset")) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline port out cryptodev");
return;
}
if (parser_read_uint32(&p.cryptodev.op_offset, tokens[11])
!= 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "queue_id");
return;
}
} else {
snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
return;
}
status = pipeline_port_out_create(pipeline_name, &p);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_table_help[] =
"pipeline <pipeline_name> table\n"
" match\n"
" acl\n"
" ipv4 | ipv6\n"
" offset <ip_header_offset>\n"
" size <n_rules>\n"
" | array\n"
" offset <key_offset>\n"
" size <n_keys>\n"
" | hash\n"
" ext | lru\n"
" key <key_size>\n"
" mask <key_mask>\n"
" offset <key_offset>\n"
" buckets <n_buckets>\n"
" size <n_keys>\n"
" | lpm\n"
" ipv4 | ipv6\n"
" offset <ip_header_offset>\n"
" size <n_rules>\n"
" | stub\n"
" [action <table_action_profile_name>]\n";
static void
cmd_pipeline_table(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
uint8_t key_mask[TABLE_RULE_MATCH_SIZE_MAX];
struct table_params p;
char *pipeline_name;
uint32_t t0;
int status;
if (n_tokens < 5) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (strcmp(tokens[3], "match") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
return;
}
t0 = 4;
if (strcmp(tokens[t0], "acl") == 0) {
if (n_tokens < t0 + 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline table acl");
return;
}
p.match_type = TABLE_ACL;
if (strcmp(tokens[t0 + 1], "ipv4") == 0)
p.match.acl.ip_version = 1;
else if (strcmp(tokens[t0 + 1], "ipv6") == 0)
p.match.acl.ip_version = 0;
else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"ipv4 or ipv6");
return;
}
if (strcmp(tokens[t0 + 2], "offset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
return;
}
if (parser_read_uint32(&p.match.acl.ip_header_offset,
tokens[t0 + 3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"ip_header_offset");
return;
}
if (strcmp(tokens[t0 + 4], "size") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
return;
}
if (parser_read_uint32(&p.match.acl.n_rules,
tokens[t0 + 5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_rules");
return;
}
t0 += 6;
} else if (strcmp(tokens[t0], "array") == 0) {
if (n_tokens < t0 + 5) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline table array");
return;
}
p.match_type = TABLE_ARRAY;
if (strcmp(tokens[t0 + 1], "offset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
return;
}
if (parser_read_uint32(&p.match.array.key_offset,
tokens[t0 + 2]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
return;
}
if (strcmp(tokens[t0 + 3], "size") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
return;
}
if (parser_read_uint32(&p.match.array.n_keys,
tokens[t0 + 4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_keys");
return;
}
t0 += 5;
} else if (strcmp(tokens[t0], "hash") == 0) {
uint32_t key_mask_size = TABLE_RULE_MATCH_SIZE_MAX;
if (n_tokens < t0 + 12) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline table hash");
return;
}
p.match_type = TABLE_HASH;
if (strcmp(tokens[t0 + 1], "ext") == 0)
p.match.hash.extendable_bucket = 1;
else if (strcmp(tokens[t0 + 1], "lru") == 0)
p.match.hash.extendable_bucket = 0;
else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"ext or lru");
return;
}
if (strcmp(tokens[t0 + 2], "key") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "key");
return;
}
if ((parser_read_uint32(&p.match.hash.key_size,
tokens[t0 + 3]) != 0) ||
(p.match.hash.key_size == 0) ||
(p.match.hash.key_size > TABLE_RULE_MATCH_SIZE_MAX)) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_size");
return;
}
if (strcmp(tokens[t0 + 4], "mask") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask");
return;
}
if ((parse_hex_string(tokens[t0 + 5],
key_mask, &key_mask_size) != 0) ||
(key_mask_size != p.match.hash.key_size)) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_mask");
return;
}
p.match.hash.key_mask = key_mask;
if (strcmp(tokens[t0 + 6], "offset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
return;
}
if (parser_read_uint32(&p.match.hash.key_offset,
tokens[t0 + 7]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
return;
}
if (strcmp(tokens[t0 + 8], "buckets") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "buckets");
return;
}
if (parser_read_uint32(&p.match.hash.n_buckets,
tokens[t0 + 9]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_buckets");
return;
}
if (strcmp(tokens[t0 + 10], "size") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
return;
}
if (parser_read_uint32(&p.match.hash.n_keys,
tokens[t0 + 11]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_keys");
return;
}
t0 += 12;
} else if (strcmp(tokens[t0], "lpm") == 0) {
if (n_tokens < t0 + 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"pipeline table lpm");
return;
}
p.match_type = TABLE_LPM;
if (strcmp(tokens[t0 + 1], "ipv4") == 0)
p.match.lpm.key_size = 4;
else if (strcmp(tokens[t0 + 1], "ipv6") == 0)
p.match.lpm.key_size = 16;
else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"ipv4 or ipv6");
return;
}
if (strcmp(tokens[t0 + 2], "offset") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
return;
}
if (parser_read_uint32(&p.match.lpm.key_offset,
tokens[t0 + 3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
return;
}
if (strcmp(tokens[t0 + 4], "size") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
return;
}
if (parser_read_uint32(&p.match.lpm.n_rules,
tokens[t0 + 5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "n_rules");
return;
}
t0 += 6;
} else if (strcmp(tokens[t0], "stub") == 0) {
p.match_type = TABLE_STUB;
t0 += 1;
} else {
snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
return;
}
p.action_profile_name = NULL;
if ((n_tokens > t0) && (strcmp(tokens[t0], "action") == 0)) {
if (n_tokens < t0 + 2) {
snprintf(out, out_size, MSG_ARG_MISMATCH, "action");
return;
}
p.action_profile_name = tokens[t0 + 1];
t0 += 2;
}
if (n_tokens > t0) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
status = pipeline_table_create(pipeline_name, &p);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_port_in_table_help[] =
"pipeline <pipeline_name> port in <port_id> table <table_id>\n";
static void
cmd_pipeline_port_in_table(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
char *pipeline_name;
uint32_t port_id, table_id;
int status;
if (n_tokens != 7) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "port") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (strcmp(tokens[3], "in") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
return;
}
if (parser_read_uint32(&port_id, tokens[4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
return;
}
if (strcmp(tokens[5], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
status = pipeline_port_in_connect_to_table(pipeline_name,
port_id,
table_id);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_port_in_stats_help[] =
"pipeline <pipeline_name> port in <port_id> stats read [clear]\n";
#define MSG_PIPELINE_PORT_IN_STATS \
"Pkts in: %" PRIu64 "\n" \
"Pkts dropped by AH: %" PRIu64 "\n" \
"Pkts dropped by other: %" PRIu64 "\n"
static void
cmd_pipeline_port_in_stats(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct rte_pipeline_port_in_stats stats;
char *pipeline_name;
uint32_t port_id;
int clear, status;
if ((n_tokens != 7) && (n_tokens != 8)) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "port") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (strcmp(tokens[3], "in") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
return;
}
if (parser_read_uint32(&port_id, tokens[4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
return;
}
if (strcmp(tokens[5], "stats") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
return;
}
if (strcmp(tokens[6], "read") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
return;
}
clear = 0;
if (n_tokens == 8) {
if (strcmp(tokens[7], "clear") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "clear");
return;
}
clear = 1;
}
status = pipeline_port_in_stats_read(pipeline_name,
port_id,
&stats,
clear);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
snprintf(out, out_size, MSG_PIPELINE_PORT_IN_STATS,
stats.stats.n_pkts_in,
stats.n_pkts_dropped_by_ah,
stats.stats.n_pkts_drop);
}
static const char cmd_pipeline_port_in_enable_help[] =
"pipeline <pipeline_name> port in <port_id> enable\n";
static void
cmd_pipeline_port_in_enable(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
char *pipeline_name;
uint32_t port_id;
int status;
if (n_tokens != 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "port") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (strcmp(tokens[3], "in") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
return;
}
if (parser_read_uint32(&port_id, tokens[4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
return;
}
if (strcmp(tokens[5], "enable") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "enable");
return;
}
status = pipeline_port_in_enable(pipeline_name, port_id);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_port_in_disable_help[] =
"pipeline <pipeline_name> port in <port_id> disable\n";
static void
cmd_pipeline_port_in_disable(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
char *pipeline_name;
uint32_t port_id;
int status;
if (n_tokens != 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "port") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (strcmp(tokens[3], "in") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
return;
}
if (parser_read_uint32(&port_id, tokens[4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
return;
}
if (strcmp(tokens[5], "disable") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "disable");
return;
}
status = pipeline_port_in_disable(pipeline_name, port_id);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_port_out_stats_help[] =
"pipeline <pipeline_name> port out <port_id> stats read [clear]\n";
#define MSG_PIPELINE_PORT_OUT_STATS \
"Pkts in: %" PRIu64 "\n" \
"Pkts dropped by AH: %" PRIu64 "\n" \
"Pkts dropped by other: %" PRIu64 "\n"
static void
cmd_pipeline_port_out_stats(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct rte_pipeline_port_out_stats stats;
char *pipeline_name;
uint32_t port_id;
int clear, status;
if ((n_tokens != 7) && (n_tokens != 8)) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "port") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (strcmp(tokens[3], "out") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "out");
return;
}
if (parser_read_uint32(&port_id, tokens[4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
return;
}
if (strcmp(tokens[5], "stats") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
return;
}
if (strcmp(tokens[6], "read") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
return;
}
clear = 0;
if (n_tokens == 8) {
if (strcmp(tokens[7], "clear") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "clear");
return;
}
clear = 1;
}
status = pipeline_port_out_stats_read(pipeline_name,
port_id,
&stats,
clear);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
snprintf(out, out_size, MSG_PIPELINE_PORT_OUT_STATS,
stats.stats.n_pkts_in,
stats.n_pkts_dropped_by_ah,
stats.stats.n_pkts_drop);
}
static const char cmd_pipeline_table_stats_help[] =
"pipeline <pipeline_name> table <table_id> stats read [clear]\n";
#define MSG_PIPELINE_TABLE_STATS \
"Pkts in: %" PRIu64 "\n" \
"Pkts in with lookup miss: %" PRIu64 "\n" \
"Pkts in with lookup hit dropped by AH: %" PRIu64 "\n" \
"Pkts in with lookup hit dropped by others: %" PRIu64 "\n" \
"Pkts in with lookup miss dropped by AH: %" PRIu64 "\n" \
"Pkts in with lookup miss dropped by others: %" PRIu64 "\n"
static void
cmd_pipeline_table_stats(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct rte_pipeline_table_stats stats;
char *pipeline_name;
uint32_t table_id;
int clear, status;
if ((n_tokens != 6) && (n_tokens != 7)) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "stats") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
return;
}
if (strcmp(tokens[5], "read") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
return;
}
clear = 0;
if (n_tokens == 7) {
if (strcmp(tokens[6], "clear") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "clear");
return;
}
clear = 1;
}
status = pipeline_table_stats_read(pipeline_name,
table_id,
&stats,
clear);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
snprintf(out, out_size, MSG_PIPELINE_TABLE_STATS,
stats.stats.n_pkts_in,
stats.stats.n_pkts_lookup_miss,
stats.n_pkts_dropped_by_lkp_hit_ah,
stats.n_pkts_dropped_lkp_hit,
stats.n_pkts_dropped_by_lkp_miss_ah,
stats.n_pkts_dropped_lkp_miss);
}
struct pkt_key_qinq {
uint16_t ethertype_svlan;
uint16_t svlan;
uint16_t ethertype_cvlan;
uint16_t cvlan;
} __rte_packed;
struct pkt_key_ipv4_5tuple {
uint8_t time_to_live;
uint8_t proto;
uint16_t hdr_checksum;
uint32_t sa;
uint32_t da;
uint16_t sp;
uint16_t dp;
} __rte_packed;
struct pkt_key_ipv6_5tuple {
uint16_t payload_length;
uint8_t proto;
uint8_t hop_limit;
struct rte_ipv6_addr sa;
struct rte_ipv6_addr da;
uint16_t sp;
uint16_t dp;
} __rte_packed;
struct pkt_key_ipv4_addr {
uint32_t addr;
} __rte_packed;
struct pkt_key_ipv6_addr {
struct rte_ipv6_addr addr;
} __rte_packed;
static uint32_t
parse_match(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size,
struct table_rule_match *m)
{
memset(m, 0, sizeof(*m));
if (n_tokens < 2)
return 0;
if (strcmp(tokens[0], "match") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
return 0;
}
if (strcmp(tokens[1], "acl") == 0) {
if (n_tokens < 14) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return 0;
}
m->match_type = TABLE_ACL;
if (strcmp(tokens[2], "priority") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "priority");
return 0;
}
if (parser_read_uint32(&m->match.acl.priority,
tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "priority");
return 0;
}
if (strcmp(tokens[4], "ipv4") == 0) {
struct in_addr saddr, daddr;
m->match.acl.ip_version = 1;
if (parse_ipv4_addr(tokens[5], &saddr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "sa");
return 0;
}
m->match.acl.ipv4.sa = rte_be_to_cpu_32(saddr.s_addr);
if (parse_ipv4_addr(tokens[7], &daddr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "da");
return 0;
}
m->match.acl.ipv4.da = rte_be_to_cpu_32(daddr.s_addr);
} else if (strcmp(tokens[4], "ipv6") == 0) {
struct rte_ipv6_addr saddr, daddr;
m->match.acl.ip_version = 0;
if (parse_ipv6_addr(tokens[5], &saddr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "sa");
return 0;
}
m->match.acl.ipv6.sa = saddr;
if (parse_ipv6_addr(tokens[7], &daddr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "da");
return 0;
}
m->match.acl.ipv6.da = daddr;
} else {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
"ipv4 or ipv6");
return 0;
}
if (parser_read_uint32(&m->match.acl.sa_depth,
tokens[6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "sa_depth");
return 0;
}
if (parser_read_uint32(&m->match.acl.da_depth,
tokens[8]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "da_depth");
return 0;
}
if (parser_read_uint16(&m->match.acl.sp0, tokens[9]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "sp0");
return 0;
}
if (parser_read_uint16(&m->match.acl.sp1, tokens[10]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "sp1");
return 0;
}
if (parser_read_uint16(&m->match.acl.dp0, tokens[11]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "dp0");
return 0;
}
if (parser_read_uint16(&m->match.acl.dp1, tokens[12]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "dp1");
return 0;
}
if (parser_read_uint8(&m->match.acl.proto, tokens[13]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "proto");
return 0;
}
m->match.acl.proto_mask = 0xff;
return 14;
} /* acl */
if (strcmp(tokens[1], "array") == 0) {
if (n_tokens < 3) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return 0;
}
m->match_type = TABLE_ARRAY;
if (parser_read_uint32(&m->match.array.pos, tokens[2]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "pos");
return 0;
}
return 3;
} /* array */
if (strcmp(tokens[1], "hash") == 0) {
if (n_tokens < 3) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return 0;
}
m->match_type = TABLE_HASH;
if (strcmp(tokens[2], "raw") == 0) {
uint32_t key_size = TABLE_RULE_MATCH_SIZE_MAX;
if (n_tokens < 4) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
tokens[0]);
return 0;
}
if (parse_hex_string(tokens[3],
m->match.hash.key, &key_size) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "key");
return 0;
}
return 4;
} /* hash raw */
if (strcmp(tokens[2], "ipv4_5tuple") == 0) {
struct pkt_key_ipv4_5tuple *ipv4 =
(struct pkt_key_ipv4_5tuple *) m->match.hash.key;
struct in_addr saddr, daddr;
uint16_t sp, dp;
uint8_t proto;
if (n_tokens < 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
tokens[0]);
return 0;
}
if (parse_ipv4_addr(tokens[3], &saddr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "sa");
return 0;
}
if (parse_ipv4_addr(tokens[4], &daddr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "da");
return 0;
}
if (parser_read_uint16(&sp, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "sp");
return 0;
}
if (parser_read_uint16(&dp, tokens[6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "dp");
return 0;
}
if (parser_read_uint8(&proto, tokens[7]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"proto");
return 0;
}
ipv4->sa = saddr.s_addr;
ipv4->da = daddr.s_addr;
ipv4->sp = rte_cpu_to_be_16(sp);
ipv4->dp = rte_cpu_to_be_16(dp);
ipv4->proto = proto;
return 8;
} /* hash ipv4_5tuple */
if (strcmp(tokens[2], "ipv6_5tuple") == 0) {
struct pkt_key_ipv6_5tuple *ipv6 =
(struct pkt_key_ipv6_5tuple *) m->match.hash.key;
struct rte_ipv6_addr saddr, daddr;
uint16_t sp, dp;
uint8_t proto;
if (n_tokens < 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
tokens[0]);
return 0;
}
if (parse_ipv6_addr(tokens[3], &saddr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "sa");
return 0;
}
if (parse_ipv6_addr(tokens[4], &daddr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "da");
return 0;
}
if (parser_read_uint16(&sp, tokens[5]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "sp");
return 0;
}
if (parser_read_uint16(&dp, tokens[6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "dp");
return 0;
}
if (parser_read_uint8(&proto, tokens[7]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"proto");
return 0;
}
ipv6->sa = saddr;
ipv6->da = daddr;
ipv6->sp = rte_cpu_to_be_16(sp);
ipv6->dp = rte_cpu_to_be_16(dp);
ipv6->proto = proto;
return 8;
} /* hash ipv6_5tuple */
if (strcmp(tokens[2], "ipv4_addr") == 0) {
struct pkt_key_ipv4_addr *ipv4_addr =
(struct pkt_key_ipv4_addr *) m->match.hash.key;
struct in_addr addr;
if (n_tokens < 4) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
tokens[0]);
return 0;
}
if (parse_ipv4_addr(tokens[3], &addr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"addr");
return 0;
}
ipv4_addr->addr = addr.s_addr;
return 4;
} /* hash ipv4_addr */
if (strcmp(tokens[2], "ipv6_addr") == 0) {
struct pkt_key_ipv6_addr *ipv6_addr =
(struct pkt_key_ipv6_addr *) m->match.hash.key;
struct rte_ipv6_addr addr;
if (n_tokens < 4) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
tokens[0]);
return 0;
}
if (parse_ipv6_addr(tokens[3], &addr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"addr");
return 0;
}
ipv6_addr->addr = addr;
return 4;
} /* hash ipv6_5tuple */
if (strcmp(tokens[2], "qinq") == 0) {
struct pkt_key_qinq *qinq =
(struct pkt_key_qinq *) m->match.hash.key;
uint16_t svlan, cvlan;
if (n_tokens < 5) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
tokens[0]);
return 0;
}
if ((parser_read_uint16(&svlan, tokens[3]) != 0) ||
(svlan > 0xFFF)) {
snprintf(out, out_size, MSG_ARG_INVALID,
"svlan");
return 0;
}
if ((parser_read_uint16(&cvlan, tokens[4]) != 0) ||
(cvlan > 0xFFF)) {
snprintf(out, out_size, MSG_ARG_INVALID,
"cvlan");
return 0;
}
qinq->svlan = rte_cpu_to_be_16(svlan);
qinq->cvlan = rte_cpu_to_be_16(cvlan);
return 5;
} /* hash qinq */
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return 0;
} /* hash */
if (strcmp(tokens[1], "lpm") == 0) {
if (n_tokens < 5) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return 0;
}
m->match_type = TABLE_LPM;
if (strcmp(tokens[2], "ipv4") == 0) {
struct in_addr addr;
m->match.lpm.ip_version = 1;
if (parse_ipv4_addr(tokens[3], &addr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"addr");
return 0;
}
m->match.lpm.ipv4 = rte_be_to_cpu_32(addr.s_addr);
} else if (strcmp(tokens[2], "ipv6") == 0) {
struct rte_ipv6_addr addr;
m->match.lpm.ip_version = 0;
if (parse_ipv6_addr(tokens[3], &addr) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"addr");
return 0;
}
m->match.lpm.ipv6 = addr;
} else {
snprintf(out, out_size, MSG_ARG_MISMATCH,
"ipv4 or ipv6");
return 0;
}
if (parser_read_uint8(&m->match.lpm.depth, tokens[4]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "depth");
return 0;
}
return 5;
} /* lpm */
snprintf(out, out_size, MSG_ARG_MISMATCH,
"acl or array or hash or lpm");
return 0;
}
static uint32_t
parse_table_action_fwd(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
if ((n_tokens == 0) || (strcmp(tokens[0], "fwd") != 0))
return 0;
tokens++;
n_tokens--;
if (n_tokens && (strcmp(tokens[0], "drop") == 0)) {
a->fwd.action = RTE_PIPELINE_ACTION_DROP;
a->action_mask |= 1 << RTE_TABLE_ACTION_FWD;
return 1 + 1;
}
if (n_tokens && (strcmp(tokens[0], "port") == 0)) {
uint32_t id;
if ((n_tokens < 2) ||
parser_read_uint32(&id, tokens[1]))
return 0;
a->fwd.action = RTE_PIPELINE_ACTION_PORT;
a->fwd.id = id;
a->action_mask |= 1 << RTE_TABLE_ACTION_FWD;
return 1 + 2;
}
if (n_tokens && (strcmp(tokens[0], "meta") == 0)) {
a->fwd.action = RTE_PIPELINE_ACTION_PORT_META;
a->action_mask |= 1 << RTE_TABLE_ACTION_FWD;
return 1 + 1;
}
if (n_tokens && (strcmp(tokens[0], "table") == 0)) {
uint32_t id;
if ((n_tokens < 2) ||
parser_read_uint32(&id, tokens[1]))
return 0;
a->fwd.action = RTE_PIPELINE_ACTION_TABLE;
a->fwd.id = id;
a->action_mask |= 1 << RTE_TABLE_ACTION_FWD;
return 1 + 2;
}
return 0;
}
static uint32_t
parse_table_action_balance(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
uint32_t i;
if ((n_tokens == 0) || (strcmp(tokens[0], "balance") != 0))
return 0;
tokens++;
n_tokens--;
if (n_tokens < RTE_TABLE_ACTION_LB_TABLE_SIZE)
return 0;
for (i = 0; i < RTE_TABLE_ACTION_LB_TABLE_SIZE; i++)
if (parser_read_uint32(&a->lb.out[i], tokens[i]) != 0)
return 0;
a->action_mask |= 1 << RTE_TABLE_ACTION_LB;
return 1 + RTE_TABLE_ACTION_LB_TABLE_SIZE;
}
static int
parse_policer_action(char *token, enum rte_table_action_policer *a)
{
if (strcmp(token, "g") == 0) {
*a = RTE_TABLE_ACTION_POLICER_COLOR_GREEN;
return 0;
}
if (strcmp(token, "y") == 0) {
*a = RTE_TABLE_ACTION_POLICER_COLOR_YELLOW;
return 0;
}
if (strcmp(token, "r") == 0) {
*a = RTE_TABLE_ACTION_POLICER_COLOR_RED;
return 0;
}
if (strcmp(token, "drop") == 0) {
*a = RTE_TABLE_ACTION_POLICER_DROP;
return 0;
}
return -1;
}
static uint32_t
parse_table_action_meter_tc(char **tokens,
uint32_t n_tokens,
struct rte_table_action_mtr_tc_params *mtr)
{
if ((n_tokens < 9) ||
strcmp(tokens[0], "meter") ||
parser_read_uint32(&mtr->meter_profile_id, tokens[1]) ||
strcmp(tokens[2], "policer") ||
strcmp(tokens[3], "g") ||
parse_policer_action(tokens[4], &mtr->policer[RTE_COLOR_GREEN]) ||
strcmp(tokens[5], "y") ||
parse_policer_action(tokens[6], &mtr->policer[RTE_COLOR_YELLOW]) ||
strcmp(tokens[7], "r") ||
parse_policer_action(tokens[8], &mtr->policer[RTE_COLOR_RED]))
return 0;
return 9;
}
static uint32_t
parse_table_action_meter(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
if ((n_tokens == 0) || strcmp(tokens[0], "meter"))
return 0;
tokens++;
n_tokens--;
if ((n_tokens < 10) ||
strcmp(tokens[0], "tc0") ||
(parse_table_action_meter_tc(tokens + 1,
n_tokens - 1,
&a->mtr.mtr[0]) == 0))
return 0;
tokens += 10;
n_tokens -= 10;
if ((n_tokens == 0) || strcmp(tokens[0], "tc1")) {
a->mtr.tc_mask = 1;
a->action_mask |= 1 << RTE_TABLE_ACTION_MTR;
return 1 + 10;
}
if ((n_tokens < 30) ||
(parse_table_action_meter_tc(tokens + 1,
n_tokens - 1, &a->mtr.mtr[1]) == 0) ||
strcmp(tokens[10], "tc2") ||
(parse_table_action_meter_tc(tokens + 11,
n_tokens - 11, &a->mtr.mtr[2]) == 0) ||
strcmp(tokens[20], "tc3") ||
(parse_table_action_meter_tc(tokens + 21,
n_tokens - 21, &a->mtr.mtr[3]) == 0))
return 0;
a->mtr.tc_mask = 0xF;
a->action_mask |= 1 << RTE_TABLE_ACTION_MTR;
return 1 + 10 + 3 * 10;
}
static uint32_t
parse_table_action_tm(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
uint32_t subport_id, pipe_id;
if ((n_tokens < 5) ||
strcmp(tokens[0], "tm") ||
strcmp(tokens[1], "subport") ||
parser_read_uint32(&subport_id, tokens[2]) ||
strcmp(tokens[3], "pipe") ||
parser_read_uint32(&pipe_id, tokens[4]))
return 0;
a->tm.subport_id = subport_id;
a->tm.pipe_id = pipe_id;
a->action_mask |= 1 << RTE_TABLE_ACTION_TM;
return 5;
}
static uint32_t
parse_table_action_encap(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
if ((n_tokens == 0) || strcmp(tokens[0], "encap"))
return 0;
tokens++;
n_tokens--;
/* ether */
if (n_tokens && (strcmp(tokens[0], "ether") == 0)) {
if ((n_tokens < 3) ||
parse_mac_addr(tokens[1], &a->encap.ether.ether.da) ||
parse_mac_addr(tokens[2], &a->encap.ether.ether.sa))
return 0;
a->encap.type = RTE_TABLE_ACTION_ENCAP_ETHER;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + 3;
}
/* vlan */
if (n_tokens && (strcmp(tokens[0], "vlan") == 0)) {
uint32_t pcp, dei, vid;
if ((n_tokens < 6) ||
parse_mac_addr(tokens[1], &a->encap.vlan.ether.da) ||
parse_mac_addr(tokens[2], &a->encap.vlan.ether.sa) ||
parser_read_uint32(&pcp, tokens[3]) ||
(pcp > 0x7) ||
parser_read_uint32(&dei, tokens[4]) ||
(dei > 0x1) ||
parser_read_uint32(&vid, tokens[5]) ||
(vid > 0xFFF))
return 0;
a->encap.vlan.vlan.pcp = pcp & 0x7;
a->encap.vlan.vlan.dei = dei & 0x1;
a->encap.vlan.vlan.vid = vid & 0xFFF;
a->encap.type = RTE_TABLE_ACTION_ENCAP_VLAN;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + 6;
}
/* qinq */
if (n_tokens && (strcmp(tokens[0], "qinq") == 0)) {
uint32_t svlan_pcp, svlan_dei, svlan_vid;
uint32_t cvlan_pcp, cvlan_dei, cvlan_vid;
if ((n_tokens < 9) ||
parse_mac_addr(tokens[1], &a->encap.qinq.ether.da) ||
parse_mac_addr(tokens[2], &a->encap.qinq.ether.sa) ||
parser_read_uint32(&svlan_pcp, tokens[3]) ||
(svlan_pcp > 0x7) ||
parser_read_uint32(&svlan_dei, tokens[4]) ||
(svlan_dei > 0x1) ||
parser_read_uint32(&svlan_vid, tokens[5]) ||
(svlan_vid > 0xFFF) ||
parser_read_uint32(&cvlan_pcp, tokens[6]) ||
(cvlan_pcp > 0x7) ||
parser_read_uint32(&cvlan_dei, tokens[7]) ||
(cvlan_dei > 0x1) ||
parser_read_uint32(&cvlan_vid, tokens[8]) ||
(cvlan_vid > 0xFFF))
return 0;
a->encap.qinq.svlan.pcp = svlan_pcp & 0x7;
a->encap.qinq.svlan.dei = svlan_dei & 0x1;
a->encap.qinq.svlan.vid = svlan_vid & 0xFFF;
a->encap.qinq.cvlan.pcp = cvlan_pcp & 0x7;
a->encap.qinq.cvlan.dei = cvlan_dei & 0x1;
a->encap.qinq.cvlan.vid = cvlan_vid & 0xFFF;
a->encap.type = RTE_TABLE_ACTION_ENCAP_QINQ;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + 9;
}
/* qinq_pppoe */
if (n_tokens && (strcmp(tokens[0], "qinq_pppoe") == 0)) {
uint32_t svlan_pcp, svlan_dei, svlan_vid;
uint32_t cvlan_pcp, cvlan_dei, cvlan_vid;
if ((n_tokens < 10) ||
parse_mac_addr(tokens[1],
&a->encap.qinq_pppoe.ether.da) ||
parse_mac_addr(tokens[2],
&a->encap.qinq_pppoe.ether.sa) ||
parser_read_uint32(&svlan_pcp, tokens[3]) ||
(svlan_pcp > 0x7) ||
parser_read_uint32(&svlan_dei, tokens[4]) ||
(svlan_dei > 0x1) ||
parser_read_uint32(&svlan_vid, tokens[5]) ||
(svlan_vid > 0xFFF) ||
parser_read_uint32(&cvlan_pcp, tokens[6]) ||
(cvlan_pcp > 0x7) ||
parser_read_uint32(&cvlan_dei, tokens[7]) ||
(cvlan_dei > 0x1) ||
parser_read_uint32(&cvlan_vid, tokens[8]) ||
(cvlan_vid > 0xFFF) ||
parser_read_uint16(&a->encap.qinq_pppoe.pppoe.session_id,
tokens[9]))
return 0;
a->encap.qinq_pppoe.svlan.pcp = svlan_pcp & 0x7;
a->encap.qinq_pppoe.svlan.dei = svlan_dei & 0x1;
a->encap.qinq_pppoe.svlan.vid = svlan_vid & 0xFFF;
a->encap.qinq_pppoe.cvlan.pcp = cvlan_pcp & 0x7;
a->encap.qinq_pppoe.cvlan.dei = cvlan_dei & 0x1;
a->encap.qinq_pppoe.cvlan.vid = cvlan_vid & 0xFFF;
a->encap.type = RTE_TABLE_ACTION_ENCAP_QINQ_PPPOE;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + 10;
}
/* mpls */
if (n_tokens && (strcmp(tokens[0], "mpls") == 0)) {
uint32_t label, tc, ttl;
if (n_tokens < 8)
return 0;
if (strcmp(tokens[1], "unicast") == 0)
a->encap.mpls.unicast = 1;
else if (strcmp(tokens[1], "multicast") == 0)
a->encap.mpls.unicast = 0;
else
return 0;
if (parse_mac_addr(tokens[2], &a->encap.mpls.ether.da) ||
parse_mac_addr(tokens[3], &a->encap.mpls.ether.sa) ||
strcmp(tokens[4], "label0") ||
parser_read_uint32(&label, tokens[5]) ||
(label > 0xFFFFF) ||
parser_read_uint32(&tc, tokens[6]) ||
(tc > 0x7) ||
parser_read_uint32(&ttl, tokens[7]) ||
(ttl > 0x3F))
return 0;
a->encap.mpls.mpls[0].label = label;
a->encap.mpls.mpls[0].tc = tc;
a->encap.mpls.mpls[0].ttl = ttl;
tokens += 8;
n_tokens -= 8;
if ((n_tokens == 0) || strcmp(tokens[0], "label1")) {
a->encap.mpls.mpls_count = 1;
a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + 8;
}
if ((n_tokens < 4) ||
parser_read_uint32(&label, tokens[1]) ||
(label > 0xFFFFF) ||
parser_read_uint32(&tc, tokens[2]) ||
(tc > 0x7) ||
parser_read_uint32(&ttl, tokens[3]) ||
(ttl > 0x3F))
return 0;
a->encap.mpls.mpls[1].label = label;
a->encap.mpls.mpls[1].tc = tc;
a->encap.mpls.mpls[1].ttl = ttl;
tokens += 4;
n_tokens -= 4;
if ((n_tokens == 0) || strcmp(tokens[0], "label2")) {
a->encap.mpls.mpls_count = 2;
a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + 8 + 4;
}
if ((n_tokens < 4) ||
parser_read_uint32(&label, tokens[1]) ||
(label > 0xFFFFF) ||
parser_read_uint32(&tc, tokens[2]) ||
(tc > 0x7) ||
parser_read_uint32(&ttl, tokens[3]) ||
(ttl > 0x3F))
return 0;
a->encap.mpls.mpls[2].label = label;
a->encap.mpls.mpls[2].tc = tc;
a->encap.mpls.mpls[2].ttl = ttl;
tokens += 4;
n_tokens -= 4;
if ((n_tokens == 0) || strcmp(tokens[0], "label3")) {
a->encap.mpls.mpls_count = 3;
a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + 8 + 4 + 4;
}
if ((n_tokens < 4) ||
parser_read_uint32(&label, tokens[1]) ||
(label > 0xFFFFF) ||
parser_read_uint32(&tc, tokens[2]) ||
(tc > 0x7) ||
parser_read_uint32(&ttl, tokens[3]) ||
(ttl > 0x3F))
return 0;
a->encap.mpls.mpls[3].label = label;
a->encap.mpls.mpls[3].tc = tc;
a->encap.mpls.mpls[3].ttl = ttl;
a->encap.mpls.mpls_count = 4;
a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + 8 + 4 + 4 + 4;
}
/* pppoe */
if (n_tokens && (strcmp(tokens[0], "pppoe") == 0)) {
if ((n_tokens < 4) ||
parse_mac_addr(tokens[1], &a->encap.pppoe.ether.da) ||
parse_mac_addr(tokens[2], &a->encap.pppoe.ether.sa) ||
parser_read_uint16(&a->encap.pppoe.pppoe.session_id,
tokens[3]))
return 0;
a->encap.type = RTE_TABLE_ACTION_ENCAP_PPPOE;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + 4;
}
/* vxlan */
if (n_tokens && (strcmp(tokens[0], "vxlan") == 0)) {
uint32_t n = 0;
n_tokens--;
tokens++;
n++;
/* ether <da> <sa> */
if ((n_tokens < 3) ||
strcmp(tokens[0], "ether") ||
parse_mac_addr(tokens[1], &a->encap.vxlan.ether.da) ||
parse_mac_addr(tokens[2], &a->encap.vxlan.ether.sa))
return 0;
n_tokens -= 3;
tokens += 3;
n += 3;
/* [vlan <pcp> <dei> <vid>] */
if (strcmp(tokens[0], "vlan") == 0) {
uint32_t pcp, dei, vid;
if ((n_tokens < 4) ||
parser_read_uint32(&pcp, tokens[1]) ||
(pcp > 7) ||
parser_read_uint32(&dei, tokens[2]) ||
(dei > 1) ||
parser_read_uint32(&vid, tokens[3]) ||
(vid > 0xFFF))
return 0;
a->encap.vxlan.vlan.pcp = pcp;
a->encap.vxlan.vlan.dei = dei;
a->encap.vxlan.vlan.vid = vid;
n_tokens -= 4;
tokens += 4;
n += 4;
}
/* ipv4 <sa> <da> <dscp> <ttl>
| ipv6 <sa> <da> <flow_label> <dscp> <hop_limit> */
if (strcmp(tokens[0], "ipv4") == 0) {
struct in_addr sa, da;
uint8_t dscp, ttl;
if ((n_tokens < 5) ||
parse_ipv4_addr(tokens[1], &sa) ||
parse_ipv4_addr(tokens[2], &da) ||
parser_read_uint8(&dscp, tokens[3]) ||
(dscp > 64) ||
parser_read_uint8(&ttl, tokens[4]))
return 0;
a->encap.vxlan.ipv4.sa = rte_be_to_cpu_32(sa.s_addr);
a->encap.vxlan.ipv4.da = rte_be_to_cpu_32(da.s_addr);
a->encap.vxlan.ipv4.dscp = dscp;
a->encap.vxlan.ipv4.ttl = ttl;
n_tokens -= 5;
tokens += 5;
n += 5;
} else if (strcmp(tokens[0], "ipv6") == 0) {
struct rte_ipv6_addr sa, da;
uint32_t flow_label;
uint8_t dscp, hop_limit;
if ((n_tokens < 6) ||
parse_ipv6_addr(tokens[1], &sa) ||
parse_ipv6_addr(tokens[2], &da) ||
parser_read_uint32(&flow_label, tokens[3]) ||
parser_read_uint8(&dscp, tokens[4]) ||
(dscp > 64) ||
parser_read_uint8(&hop_limit, tokens[5]))
return 0;
a->encap.vxlan.ipv6.sa = sa;
a->encap.vxlan.ipv6.da = da;
a->encap.vxlan.ipv6.flow_label = flow_label;
a->encap.vxlan.ipv6.dscp = dscp;
a->encap.vxlan.ipv6.hop_limit = hop_limit;
n_tokens -= 6;
tokens += 6;
n += 6;
} else
return 0;
/* udp <sp> <dp> */
if ((n_tokens < 3) ||
strcmp(tokens[0], "udp") ||
parser_read_uint16(&a->encap.vxlan.udp.sp, tokens[1]) ||
parser_read_uint16(&a->encap.vxlan.udp.dp, tokens[2]))
return 0;
n_tokens -= 3;
tokens += 3;
n += 3;
/* vxlan <vni> */
if ((n_tokens < 2) ||
strcmp(tokens[0], "vxlan") ||
parser_read_uint32(&a->encap.vxlan.vxlan.vni, tokens[1]) ||
(a->encap.vxlan.vxlan.vni > 0xFFFFFF))
return 0;
n_tokens -= 2;
tokens += 2;
n += 2;
a->encap.type = RTE_TABLE_ACTION_ENCAP_VXLAN;
a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
return 1 + n;
}
return 0;
}
static uint32_t
parse_table_action_nat(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
if ((n_tokens < 4) ||
strcmp(tokens[0], "nat"))
return 0;
if (strcmp(tokens[1], "ipv4") == 0) {
struct in_addr addr;
uint16_t port;
if (parse_ipv4_addr(tokens[2], &addr) ||
parser_read_uint16(&port, tokens[3]))
return 0;
a->nat.ip_version = 1;
a->nat.addr.ipv4 = rte_be_to_cpu_32(addr.s_addr);
a->nat.port = port;
a->action_mask |= 1 << RTE_TABLE_ACTION_NAT;
return 4;
}
if (strcmp(tokens[1], "ipv6") == 0) {
struct rte_ipv6_addr addr;
uint16_t port;
if (parse_ipv6_addr(tokens[2], &addr) ||
parser_read_uint16(&port, tokens[3]))
return 0;
a->nat.ip_version = 0;
a->nat.addr.ipv6 = addr;
a->nat.port = port;
a->action_mask |= 1 << RTE_TABLE_ACTION_NAT;
return 4;
}
return 0;
}
static uint32_t
parse_table_action_ttl(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
if ((n_tokens < 2) ||
strcmp(tokens[0], "ttl"))
return 0;
if (strcmp(tokens[1], "dec") == 0)
a->ttl.decrement = 1;
else if (strcmp(tokens[1], "keep") == 0)
a->ttl.decrement = 0;
else
return 0;
a->action_mask |= 1 << RTE_TABLE_ACTION_TTL;
return 2;
}
static uint32_t
parse_table_action_stats(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
if ((n_tokens < 1) ||
strcmp(tokens[0], "stats"))
return 0;
a->stats.n_packets = 0;
a->stats.n_bytes = 0;
a->action_mask |= 1 << RTE_TABLE_ACTION_STATS;
return 1;
}
static uint32_t
parse_table_action_time(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
if ((n_tokens < 1) ||
strcmp(tokens[0], "time"))
return 0;
a->time.time = rte_rdtsc();
a->action_mask |= 1 << RTE_TABLE_ACTION_TIME;
return 1;
}
static void
parse_free_sym_crypto_param_data(struct rte_table_action_sym_crypto_params *p)
{
struct rte_crypto_sym_xform *xform[2] = {NULL};
uint32_t i;
xform[0] = p->xform;
if (xform[0])
xform[1] = xform[0]->next;
for (i = 0; i < 2; i++) {
if (xform[i] == NULL)
continue;
switch (xform[i]->type) {
case RTE_CRYPTO_SYM_XFORM_CIPHER:
free(p->cipher_auth.cipher_iv.val);
free(p->cipher_auth.cipher_iv_update.val);
break;
case RTE_CRYPTO_SYM_XFORM_AUTH:
if (p->cipher_auth.auth_iv.val)
free(p->cipher_auth.cipher_iv.val);
if (p->cipher_auth.auth_iv_update.val)
free(p->cipher_auth.cipher_iv_update.val);
break;
case RTE_CRYPTO_SYM_XFORM_AEAD:
free(p->aead.iv.val);
free(p->aead.aad.val);
break;
default:
continue;
}
}
}
static struct rte_crypto_sym_xform *
parse_table_action_cipher(struct rte_table_action_sym_crypto_params *p,
uint8_t *key, uint32_t max_key_len, char **tokens,
uint32_t n_tokens, uint32_t encrypt, uint32_t *used_n_tokens)
{
struct rte_crypto_sym_xform *xform_cipher;
int status;
size_t len;
if (n_tokens < 7 || strcmp(tokens[1], "cipher_algo") ||
strcmp(tokens[3], "cipher_key") ||
strcmp(tokens[5], "cipher_iv"))
return NULL;
xform_cipher = calloc(1, sizeof(*xform_cipher));
if (xform_cipher == NULL)
return NULL;
xform_cipher->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
xform_cipher->cipher.op = encrypt ? RTE_CRYPTO_CIPHER_OP_ENCRYPT :
RTE_CRYPTO_CIPHER_OP_DECRYPT;
/* cipher_algo */
status = rte_cryptodev_get_cipher_algo_enum(
&xform_cipher->cipher.algo, tokens[2]);
if (status < 0)
goto error_exit;
/* cipher_key */
len = strlen(tokens[4]);
if (len / 2 > max_key_len) {
status = -ENOMEM;
goto error_exit;
}
status = parse_hex_string(tokens[4], key, (uint32_t *)&len);
if (status < 0)
goto error_exit;
xform_cipher->cipher.key.data = key;
xform_cipher->cipher.key.length = (uint16_t)len;
/* cipher_iv */
len = strlen(tokens[6]);
p->cipher_auth.cipher_iv.val = calloc(1, len / 2 + 1);
if (p->cipher_auth.cipher_iv.val == NULL)
goto error_exit;
status = parse_hex_string(tokens[6],
p->cipher_auth.cipher_iv.val,
(uint32_t *)&len);
if (status < 0)
goto error_exit;
xform_cipher->cipher.iv.length = (uint16_t)len;
xform_cipher->cipher.iv.offset = RTE_TABLE_ACTION_SYM_CRYPTO_IV_OFFSET;
p->cipher_auth.cipher_iv.length = (uint32_t)len;
*used_n_tokens = 7;
return xform_cipher;
error_exit:
if (p->cipher_auth.cipher_iv.val) {
free(p->cipher_auth.cipher_iv.val);
p->cipher_auth.cipher_iv.val = NULL;
}
free(xform_cipher);
return NULL;
}
static struct rte_crypto_sym_xform *
parse_table_action_cipher_auth(struct rte_table_action_sym_crypto_params *p,
uint8_t *key, uint32_t max_key_len, char **tokens,
uint32_t n_tokens, uint32_t encrypt, uint32_t *used_n_tokens)
{
struct rte_crypto_sym_xform *xform_cipher;
struct rte_crypto_sym_xform *xform_auth;
int status;
size_t len;
if (n_tokens < 13 ||
strcmp(tokens[7], "auth_algo") ||
strcmp(tokens[9], "auth_key") ||
strcmp(tokens[11], "digest_size"))
return NULL;
xform_auth = calloc(1, sizeof(*xform_auth));
if (xform_auth == NULL)
return NULL;
xform_auth->type = RTE_CRYPTO_SYM_XFORM_AUTH;
xform_auth->auth.op = encrypt ? RTE_CRYPTO_AUTH_OP_GENERATE :
RTE_CRYPTO_AUTH_OP_VERIFY;
/* auth_algo */
status = rte_cryptodev_get_auth_algo_enum(&xform_auth->auth.algo,
tokens[8]);
if (status < 0)
goto error_exit;
/* auth_key */
len = strlen(tokens[10]);
if (len / 2 > max_key_len) {
status = -ENOMEM;
goto error_exit;
}
status = parse_hex_string(tokens[10], key, (uint32_t *)&len);
if (status < 0)
goto error_exit;
xform_auth->auth.key.data = key;
xform_auth->auth.key.length = (uint16_t)len;
key += xform_auth->auth.key.length;
max_key_len -= xform_auth->auth.key.length;
if (strcmp(tokens[11], "digest_size"))
goto error_exit;
status = parser_read_uint16(&xform_auth->auth.digest_length,
tokens[12]);
if (status < 0)
goto error_exit;
xform_cipher = parse_table_action_cipher(p, key, max_key_len, tokens,
7, encrypt, used_n_tokens);
if (xform_cipher == NULL)
goto error_exit;
*used_n_tokens += 6;
if (encrypt) {
xform_cipher->next = xform_auth;
return xform_cipher;
} else {
xform_auth->next = xform_cipher;
return xform_auth;
}
error_exit:
if (p->cipher_auth.auth_iv.val) {
free(p->cipher_auth.auth_iv.val);
p->cipher_auth.auth_iv.val = 0;
}
free(xform_auth);
return NULL;
}
static struct rte_crypto_sym_xform *
parse_table_action_aead(struct rte_table_action_sym_crypto_params *p,
uint8_t *key, uint32_t max_key_len, char **tokens,
uint32_t n_tokens, uint32_t encrypt, uint32_t *used_n_tokens)
{
struct rte_crypto_sym_xform *xform_aead;
int status;
size_t len;
if (n_tokens < 11 || strcmp(tokens[1], "aead_algo") ||
strcmp(tokens[3], "aead_key") ||
strcmp(tokens[5], "aead_iv") ||
strcmp(tokens[7], "aead_aad") ||
strcmp(tokens[9], "digest_size"))
return NULL;
xform_aead = calloc(1, sizeof(*xform_aead));
if (xform_aead == NULL)
return NULL;
xform_aead->type = RTE_CRYPTO_SYM_XFORM_AEAD;
xform_aead->aead.op = encrypt ? RTE_CRYPTO_AEAD_OP_ENCRYPT :
RTE_CRYPTO_AEAD_OP_DECRYPT;
/* aead_algo */
status = rte_cryptodev_get_aead_algo_enum(&xform_aead->aead.algo,
tokens[2]);
if (status < 0)
goto error_exit;
/* aead_key */
len = strlen(tokens[4]);
if (len / 2 > max_key_len) {
status = -ENOMEM;
goto error_exit;
}
status = parse_hex_string(tokens[4], key, (uint32_t *)&len);
if (status < 0)
goto error_exit;
xform_aead->aead.key.data = key;
xform_aead->aead.key.length = (uint16_t)len;
/* aead_iv */
len = strlen(tokens[6]);
p->aead.iv.val = calloc(1, len / 2 + 1);
if (p->aead.iv.val == NULL)
goto error_exit;
status = parse_hex_string(tokens[6], p->aead.iv.val,
(uint32_t *)&len);
if (status < 0)
goto error_exit;
xform_aead->aead.iv.length = (uint16_t)len;
xform_aead->aead.iv.offset = RTE_TABLE_ACTION_SYM_CRYPTO_IV_OFFSET;
p->aead.iv.length = (uint32_t)len;
/* aead_aad */
len = strlen(tokens[8]);
p->aead.aad.val = calloc(1, len / 2 + 1);
if (p->aead.aad.val == NULL)
goto error_exit;
status = parse_hex_string(tokens[8], p->aead.aad.val, (uint32_t *)&len);
if (status < 0)
goto error_exit;
xform_aead->aead.aad_length = (uint16_t)len;
p->aead.aad.length = (uint32_t)len;
/* digest_size */
status = parser_read_uint16(&xform_aead->aead.digest_length,
tokens[10]);
if (status < 0)
goto error_exit;
*used_n_tokens = 11;
return xform_aead;
error_exit:
if (p->aead.iv.val) {
free(p->aead.iv.val);
p->aead.iv.val = NULL;
}
if (p->aead.aad.val) {
free(p->aead.aad.val);
p->aead.aad.val = NULL;
}
free(xform_aead);
return NULL;
}
static uint32_t
parse_table_action_sym_crypto(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
struct rte_table_action_sym_crypto_params *p = &a->sym_crypto;
struct rte_crypto_sym_xform *xform = NULL;
uint8_t *key = a->sym_crypto_key;
uint32_t max_key_len = SYM_CRYPTO_MAX_KEY_SIZE;
uint32_t used_n_tokens;
uint32_t encrypt;
int status;
if ((n_tokens < 12) ||
strcmp(tokens[0], "sym_crypto") ||
strcmp(tokens[2], "type"))
return 0;
memset(p, 0, sizeof(*p));
if (strcmp(tokens[1], "encrypt") == 0)
encrypt = 1;
else
encrypt = 0;
status = parser_read_uint32(&p->data_offset, tokens[n_tokens - 1]);
if (status < 0)
return 0;
if (strcmp(tokens[3], "cipher") == 0) {
tokens += 3;
n_tokens -= 3;
xform = parse_table_action_cipher(p, key, max_key_len, tokens,
n_tokens, encrypt, &used_n_tokens);
} else if (strcmp(tokens[3], "cipher_auth") == 0) {
tokens += 3;
n_tokens -= 3;
xform = parse_table_action_cipher_auth(p, key, max_key_len,
tokens, n_tokens, encrypt, &used_n_tokens);
} else if (strcmp(tokens[3], "aead") == 0) {
tokens += 3;
n_tokens -= 3;
xform = parse_table_action_aead(p, key, max_key_len, tokens,
n_tokens, encrypt, &used_n_tokens);
}
if (xform == NULL)
return 0;
p->xform = xform;
if (strcmp(tokens[used_n_tokens], "data_offset")) {
parse_free_sym_crypto_param_data(p);
return 0;
}
a->action_mask |= 1 << RTE_TABLE_ACTION_SYM_CRYPTO;
return used_n_tokens + 5;
}
static uint32_t
parse_table_action_tag(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
if ((n_tokens < 2) ||
strcmp(tokens[0], "tag"))
return 0;
if (parser_read_uint32(&a->tag.tag, tokens[1]))
return 0;
a->action_mask |= 1 << RTE_TABLE_ACTION_TAG;
return 2;
}
static uint32_t
parse_table_action_decap(char **tokens,
uint32_t n_tokens,
struct table_rule_action *a)
{
if ((n_tokens < 2) ||
strcmp(tokens[0], "decap"))
return 0;
if (parser_read_uint16(&a->decap.n, tokens[1]))
return 0;
a->action_mask |= 1 << RTE_TABLE_ACTION_DECAP;
return 2;
}
static uint32_t
parse_table_action(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size,
struct table_rule_action *a)
{
uint32_t n_tokens0 = n_tokens;
memset(a, 0, sizeof(*a));
if ((n_tokens < 2) ||
strcmp(tokens[0], "action"))
return 0;
tokens++;
n_tokens--;
if (n_tokens && (strcmp(tokens[0], "fwd") == 0)) {
uint32_t n;
n = parse_table_action_fwd(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action fwd");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "balance") == 0)) {
uint32_t n;
n = parse_table_action_balance(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action balance");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "meter") == 0)) {
uint32_t n;
n = parse_table_action_meter(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action meter");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "tm") == 0)) {
uint32_t n;
n = parse_table_action_tm(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action tm");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "encap") == 0)) {
uint32_t n;
n = parse_table_action_encap(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action encap");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "nat") == 0)) {
uint32_t n;
n = parse_table_action_nat(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action nat");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "ttl") == 0)) {
uint32_t n;
n = parse_table_action_ttl(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action ttl");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "stats") == 0)) {
uint32_t n;
n = parse_table_action_stats(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action stats");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "time") == 0)) {
uint32_t n;
n = parse_table_action_time(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action time");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "sym_crypto") == 0)) {
uint32_t n;
n = parse_table_action_sym_crypto(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action sym_crypto");
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "tag") == 0)) {
uint32_t n;
n = parse_table_action_tag(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action tag");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens && (strcmp(tokens[0], "decap") == 0)) {
uint32_t n;
n = parse_table_action_decap(tokens, n_tokens, a);
if (n == 0) {
snprintf(out, out_size, MSG_ARG_INVALID,
"action decap");
return 0;
}
tokens += n;
n_tokens -= n;
}
if (n_tokens0 - n_tokens == 1) {
snprintf(out, out_size, MSG_ARG_INVALID, "action");
return 0;
}
return n_tokens0 - n_tokens;
}
static const char cmd_pipeline_table_rule_add_help[] =
"pipeline <pipeline_name> table <table_id> rule add\n"
" match <match>\n"
" action <table_action>\n";
static void
cmd_pipeline_table_rule_add(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct table_rule_match m;
struct table_rule_action a;
char *pipeline_name;
uint32_t table_id, t0, n_tokens_parsed;
int status;
if (n_tokens < 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "add") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add");
return;
}
t0 = 6;
/* match */
n_tokens_parsed = parse_match(tokens + t0,
n_tokens - t0,
out,
out_size,
&m);
if (n_tokens_parsed == 0)
return;
t0 += n_tokens_parsed;
/* action */
n_tokens_parsed = parse_table_action(tokens + t0,
n_tokens - t0,
out,
out_size,
&a);
if (n_tokens_parsed == 0)
return;
t0 += n_tokens_parsed;
if (t0 != n_tokens) {
snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
return;
}
status = pipeline_table_rule_add(pipeline_name, table_id, &m, &a);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
if (a.action_mask & 1 << RTE_TABLE_ACTION_SYM_CRYPTO)
parse_free_sym_crypto_param_data(&a.sym_crypto);
}
static const char cmd_pipeline_table_rule_add_default_help[] =
"pipeline <pipeline_name> table <table_id> rule add\n"
" match\n"
" default\n"
" action\n"
" fwd\n"
" drop\n"
" | port <port_id>\n"
" | meta\n"
" | table <table_id>\n";
static void
cmd_pipeline_table_rule_add_default(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct table_rule_action action;
char *pipeline_name;
uint32_t table_id;
int status;
if ((n_tokens != 11) && (n_tokens != 12)) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "add") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add");
return;
}
if (strcmp(tokens[6], "match") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "match");
return;
}
if (strcmp(tokens[7], "default") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "default");
return;
}
if (strcmp(tokens[8], "action") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "action");
return;
}
if (strcmp(tokens[9], "fwd") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "fwd");
return;
}
action.action_mask = 1 << RTE_TABLE_ACTION_FWD;
if (strcmp(tokens[10], "drop") == 0) {
if (n_tokens != 11) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
action.fwd.action = RTE_PIPELINE_ACTION_DROP;
} else if (strcmp(tokens[10], "port") == 0) {
uint32_t id;
if (n_tokens != 12) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
if (parser_read_uint32(&id, tokens[11]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
return;
}
action.fwd.action = RTE_PIPELINE_ACTION_PORT;
action.fwd.id = id;
} else if (strcmp(tokens[10], "meta") == 0) {
if (n_tokens != 11) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
action.fwd.action = RTE_PIPELINE_ACTION_PORT_META;
} else if (strcmp(tokens[10], "table") == 0) {
uint32_t id;
if (n_tokens != 12) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
if (parser_read_uint32(&id, tokens[11]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
action.fwd.action = RTE_PIPELINE_ACTION_TABLE;
action.fwd.id = id;
} else {
snprintf(out, out_size, MSG_ARG_INVALID,
"drop or port or meta or table");
return;
}
status = pipeline_table_rule_add_default(pipeline_name,
table_id,
&action);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_table_rule_add_bulk_help[] =
"pipeline <pipeline_name> table <table_id> rule add bulk <file_name>\n"
"\n"
" File <file_name>:\n"
" - line format: match <match> action <action>\n";
static int
cli_rule_file_process(const char *file_name,
size_t line_len_max,
struct table_rule_list **rule_list,
uint32_t *n_rules,
uint32_t *line_number,
char *out,
size_t out_size);
static void
cmd_pipeline_table_rule_add_bulk(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct table_rule_list *list = NULL;
char *pipeline_name, *file_name;
uint32_t table_id, n_rules, n_rules_added, n_rules_not_added, line_number;
int status;
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "add") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add");
return;
}
if (strcmp(tokens[6], "bulk") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "bulk");
return;
}
file_name = tokens[7];
/* Load rules from file. */
status = cli_rule_file_process(file_name,
1024,
&list,
&n_rules,
&line_number,
out,
out_size);
if (status) {
snprintf(out, out_size, MSG_FILE_ERR, file_name, line_number);
return;
}
/* Rule bulk add */
status = pipeline_table_rule_add_bulk(pipeline_name,
table_id,
list,
&n_rules_added,
&n_rules_not_added);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
snprintf(out, out_size, "Added %u rules out of %u.\n",
n_rules_added,
n_rules);
}
static const char cmd_pipeline_table_rule_delete_help[] =
"pipeline <pipeline_name> table <table_id> rule delete\n"
" match <match>\n";
static void
cmd_pipeline_table_rule_delete(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct table_rule_match m;
char *pipeline_name;
uint32_t table_id, n_tokens_parsed, t0;
int status;
if (n_tokens < 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "delete") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "delete");
return;
}
t0 = 6;
/* match */
n_tokens_parsed = parse_match(tokens + t0,
n_tokens - t0,
out,
out_size,
&m);
if (n_tokens_parsed == 0)
return;
t0 += n_tokens_parsed;
if (n_tokens != t0) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
status = pipeline_table_rule_delete(pipeline_name,
table_id,
&m);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_table_rule_delete_default_help[] =
"pipeline <pipeline_name> table <table_id> rule delete\n"
" match\n"
" default\n";
static void
cmd_pipeline_table_rule_delete_default(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
char *pipeline_name;
uint32_t table_id;
int status;
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "delete") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "delete");
return;
}
if (strcmp(tokens[6], "match") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "match");
return;
}
if (strcmp(tokens[7], "default") != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "default");
return;
}
status = pipeline_table_rule_delete_default(pipeline_name,
table_id);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static void
ether_addr_show(FILE *f, struct rte_ether_addr *addr)
{
fprintf(f, RTE_ETHER_ADDR_PRT_FMT, RTE_ETHER_ADDR_BYTES(addr));
}
static void
ipv4_addr_show(FILE *f, uint32_t addr)
{
fprintf(f, "%u.%u.%u.%u",
addr >> 24,
(addr >> 16) & 0xFF,
(addr >> 8) & 0xFF,
addr & 0xFF);
}
static void
ipv6_addr_show(FILE *f, const struct rte_ipv6_addr *ip)
{
fprintf(f, RTE_IPV6_ADDR_FMT ":", RTE_IPV6_ADDR_SPLIT(ip));
}
static const char *
policer_action_string(enum rte_table_action_policer action) {
switch (action) {
case RTE_TABLE_ACTION_POLICER_COLOR_GREEN: return "G";
case RTE_TABLE_ACTION_POLICER_COLOR_YELLOW: return "Y";
case RTE_TABLE_ACTION_POLICER_COLOR_RED: return "R";
case RTE_TABLE_ACTION_POLICER_DROP: return "D";
default: return "?";
}
}
static int
table_rule_show(const char *pipeline_name,
uint32_t table_id,
const char *file_name)
{
struct pipeline *p;
struct table *table;
struct table_rule *rule;
FILE *f = NULL;
uint32_t i;
/* Check input params. */
if ((pipeline_name == NULL) ||
(file_name == NULL))
return -1;
p = pipeline_find(pipeline_name);
if ((p == NULL) ||
(table_id >= p->n_tables))
return -1;
table = &p->table[table_id];
/* Open file. */
f = fopen(file_name, "w");
if (f == NULL)
return -1;
/* Write table rules to file. */
TAILQ_FOREACH(rule, &table->rules, node) {
struct table_rule_match *m = &rule->match;
struct table_rule_action *a = &rule->action;
fprintf(f, "match ");
switch (m->match_type) {
case TABLE_ACL:
fprintf(f, "acl priority %u ",
m->match.acl.priority);
fprintf(f, m->match.acl.ip_version ? "ipv4 " : "ipv6 ");
if (m->match.acl.ip_version)
ipv4_addr_show(f, m->match.acl.ipv4.sa);
else
ipv6_addr_show(f, &m->match.acl.ipv6.sa);
fprintf(f, "%u", m->match.acl.sa_depth);
if (m->match.acl.ip_version)
ipv4_addr_show(f, m->match.acl.ipv4.da);
else
ipv6_addr_show(f, &m->match.acl.ipv6.da);
fprintf(f, "%u", m->match.acl.da_depth);
fprintf(f, "%u %u %u %u %u ",
(uint32_t)m->match.acl.sp0,
(uint32_t)m->match.acl.sp1,
(uint32_t)m->match.acl.dp0,
(uint32_t)m->match.acl.dp1,
(uint32_t)m->match.acl.proto);
break;
case TABLE_ARRAY:
fprintf(f, "array %u ",
m->match.array.pos);
break;
case TABLE_HASH:
fprintf(f, "hash raw ");
for (i = 0; i < table->params.match.hash.key_size; i++)
fprintf(f, "%02x", m->match.hash.key[i]);
fprintf(f, " ");
break;
case TABLE_LPM:
fprintf(f, "lpm ");
fprintf(f, m->match.lpm.ip_version ? "ipv4 " : "ipv6 ");
if (m->match.acl.ip_version)
ipv4_addr_show(f, m->match.lpm.ipv4);
else
ipv6_addr_show(f, &m->match.lpm.ipv6);
fprintf(f, "%u ",
(uint32_t)m->match.lpm.depth);
break;
default:
fprintf(f, "unknown ");
}
fprintf(f, "action ");
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_FWD)) {
fprintf(f, "fwd ");
switch (a->fwd.action) {
case RTE_PIPELINE_ACTION_DROP:
fprintf(f, "drop ");
break;
case RTE_PIPELINE_ACTION_PORT:
fprintf(f, "port %u ", a->fwd.id);
break;
case RTE_PIPELINE_ACTION_PORT_META:
fprintf(f, "meta ");
break;
case RTE_PIPELINE_ACTION_TABLE:
default:
fprintf(f, "table %u ", a->fwd.id);
}
}
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_LB)) {
fprintf(f, "balance ");
for (i = 0; i < RTE_DIM(a->lb.out); i++)
fprintf(f, "%u ", a->lb.out[i]);
}
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_MTR)) {
fprintf(f, "mtr ");
for (i = 0; i < RTE_TABLE_ACTION_TC_MAX; i++)
if (a->mtr.tc_mask & (1 << i)) {
struct rte_table_action_mtr_tc_params *p =
&a->mtr.mtr[i];
enum rte_table_action_policer ga =
p->policer[RTE_COLOR_GREEN];
enum rte_table_action_policer ya =
p->policer[RTE_COLOR_YELLOW];
enum rte_table_action_policer ra =
p->policer[RTE_COLOR_RED];
fprintf(f, "tc%u meter %u policer g %s y %s r %s ",
i,
a->mtr.mtr[i].meter_profile_id,
policer_action_string(ga),
policer_action_string(ya),
policer_action_string(ra));
}
}
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TM))
fprintf(f, "tm subport %u pipe %u ",
a->tm.subport_id,
a->tm.pipe_id);
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_ENCAP)) {
fprintf(f, "encap ");
switch (a->encap.type) {
case RTE_TABLE_ACTION_ENCAP_ETHER:
fprintf(f, "ether ");
ether_addr_show(f, &a->encap.ether.ether.da);
fprintf(f, " ");
ether_addr_show(f, &a->encap.ether.ether.sa);
fprintf(f, " ");
break;
case RTE_TABLE_ACTION_ENCAP_VLAN:
fprintf(f, "vlan ");
ether_addr_show(f, &a->encap.vlan.ether.da);
fprintf(f, " ");
ether_addr_show(f, &a->encap.vlan.ether.sa);
fprintf(f, " pcp %u dei %u vid %u ",
a->encap.vlan.vlan.pcp,
a->encap.vlan.vlan.dei,
a->encap.vlan.vlan.vid);
break;
case RTE_TABLE_ACTION_ENCAP_QINQ:
fprintf(f, "qinq ");
ether_addr_show(f, &a->encap.qinq.ether.da);
fprintf(f, " ");
ether_addr_show(f, &a->encap.qinq.ether.sa);
fprintf(f, " pcp %u dei %u vid %u pcp %u dei %u vid %u ",
a->encap.qinq.svlan.pcp,
a->encap.qinq.svlan.dei,
a->encap.qinq.svlan.vid,
a->encap.qinq.cvlan.pcp,
a->encap.qinq.cvlan.dei,
a->encap.qinq.cvlan.vid);
break;
case RTE_TABLE_ACTION_ENCAP_MPLS:
fprintf(f, "mpls %s ", (a->encap.mpls.unicast) ?
"unicast " : "multicast ");
ether_addr_show(f, &a->encap.mpls.ether.da);
fprintf(f, " ");
ether_addr_show(f, &a->encap.mpls.ether.sa);
fprintf(f, " ");
for (i = 0; i < a->encap.mpls.mpls_count; i++) {
struct rte_table_action_mpls_hdr *l =
&a->encap.mpls.mpls[i];
fprintf(f, "label%u %u %u %u ",
i,
l->label,
l->tc,
l->ttl);
}
break;
case RTE_TABLE_ACTION_ENCAP_PPPOE:
fprintf(f, "pppoe ");
ether_addr_show(f, &a->encap.pppoe.ether.da);
fprintf(f, " ");
ether_addr_show(f, &a->encap.pppoe.ether.sa);
fprintf(f, " %u ", a->encap.pppoe.pppoe.session_id);
break;
case RTE_TABLE_ACTION_ENCAP_VXLAN:
fprintf(f, "vxlan ether ");
ether_addr_show(f, &a->encap.vxlan.ether.da);
fprintf(f, " ");
ether_addr_show(f, &a->encap.vxlan.ether.sa);
if (table->ap->params.encap.vxlan.vlan)
fprintf(f, " vlan pcp %u dei %u vid %u ",
a->encap.vxlan.vlan.pcp,
a->encap.vxlan.vlan.dei,
a->encap.vxlan.vlan.vid);
if (table->ap->params.encap.vxlan.ip_version) {
fprintf(f, " ipv4 ");
ipv4_addr_show(f, a->encap.vxlan.ipv4.sa);
fprintf(f, " ");
ipv4_addr_show(f, a->encap.vxlan.ipv4.da);
fprintf(f, " %u %u ",
(uint32_t)a->encap.vxlan.ipv4.dscp,
(uint32_t)a->encap.vxlan.ipv4.ttl);
} else {
fprintf(f, " ipv6 ");
ipv6_addr_show(f, &a->encap.vxlan.ipv6.sa);
fprintf(f, " ");
ipv6_addr_show(f, &a->encap.vxlan.ipv6.da);
fprintf(f, " %u %u %u ",
a->encap.vxlan.ipv6.flow_label,
(uint32_t)a->encap.vxlan.ipv6.dscp,
(uint32_t)a->encap.vxlan.ipv6.hop_limit);
fprintf(f, " udp %u %u vxlan %u ",
a->encap.vxlan.udp.sp,
a->encap.vxlan.udp.dp,
a->encap.vxlan.vxlan.vni);
}
break;
default:
fprintf(f, "unknown ");
}
}
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_NAT)) {
fprintf(f, "nat %s ", (a->nat.ip_version) ? "ipv4 " : "ipv6 ");
if (a->nat.ip_version)
ipv4_addr_show(f, a->nat.addr.ipv4);
else
ipv6_addr_show(f, &a->nat.addr.ipv6);
fprintf(f, " %u ", (uint32_t)(a->nat.port));
}
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TTL))
fprintf(f, "ttl %s ", (a->ttl.decrement) ? "dec" : "keep");
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_STATS))
fprintf(f, "stats ");
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TIME))
fprintf(f, "time ");
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_SYM_CRYPTO))
fprintf(f, "sym_crypto ");
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TAG))
fprintf(f, "tag %u ", a->tag.tag);
if (a->action_mask & (1LLU << RTE_TABLE_ACTION_DECAP))
fprintf(f, "decap %u ", a->decap.n);
/* end */
fprintf(f, "\n");
}
/* Write table default rule to file. */
if (table->rule_default) {
struct table_rule_action *a = &table->rule_default->action;
fprintf(f, "# match default action fwd ");
switch (a->fwd.action) {
case RTE_PIPELINE_ACTION_DROP:
fprintf(f, "drop ");
break;
case RTE_PIPELINE_ACTION_PORT:
fprintf(f, "port %u ", a->fwd.id);
break;
case RTE_PIPELINE_ACTION_PORT_META:
fprintf(f, "meta ");
break;
case RTE_PIPELINE_ACTION_TABLE:
default:
fprintf(f, "table %u ", a->fwd.id);
}
} else
fprintf(f, "# match default action fwd drop ");
fprintf(f, "\n");
/* Close file. */
fclose(f);
return 0;
}
static const char cmd_pipeline_table_rule_show_help[] =
"pipeline <pipeline_name> table <table_id> rule show\n"
" file <file_name>\n";
static void
cmd_pipeline_table_rule_show(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
char *file_name = NULL, *pipeline_name;
uint32_t table_id;
int status;
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "show") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "show");
return;
}
if (strcmp(tokens[6], "file") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "file");
return;
}
file_name = tokens[7];
status = table_rule_show(pipeline_name, table_id, file_name);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_table_rule_stats_read_help[] =
"pipeline <pipeline_name> table <table_id> rule read stats [clear]\n"
" match <match>\n";
static void
cmd_pipeline_table_rule_stats_read(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct table_rule_match m;
struct rte_table_action_stats_counters stats;
char *pipeline_name;
uint32_t table_id, n_tokens_parsed;
int clear = 0, status;
if (n_tokens < 7) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "read") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
return;
}
if (strcmp(tokens[6], "stats") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
return;
}
n_tokens -= 7;
tokens += 7;
/* clear */
if (n_tokens && (strcmp(tokens[0], "clear") == 0)) {
clear = 1;
n_tokens--;
tokens++;
}
/* match */
if ((n_tokens == 0) || strcmp(tokens[0], "match")) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
return;
}
n_tokens_parsed = parse_match(tokens,
n_tokens,
out,
out_size,
&m);
if (n_tokens_parsed == 0)
return;
n_tokens -= n_tokens_parsed;
tokens += n_tokens_parsed;
/* end */
if (n_tokens) {
snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
return;
}
/* Read table rule stats. */
status = pipeline_table_rule_stats_read(pipeline_name,
table_id,
&m,
&stats,
clear);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
/* Print stats. */
if (stats.n_packets_valid && stats.n_bytes_valid)
snprintf(out, out_size, "Packets: %" PRIu64 "; Bytes: %" PRIu64 "\n",
stats.n_packets,
stats.n_bytes);
if (stats.n_packets_valid && !stats.n_bytes_valid)
snprintf(out, out_size, "Packets: %" PRIu64 "; Bytes: N/A\n",
stats.n_packets);
if (!stats.n_packets_valid && stats.n_bytes_valid)
snprintf(out, out_size, "Packets: N/A; Bytes: %" PRIu64 "\n",
stats.n_bytes);
if (!stats.n_packets_valid && !stats.n_bytes_valid)
snprintf(out, out_size, "Packets: N/A ; Bytes: N/A\n");
}
static const char cmd_pipeline_table_meter_profile_add_help[] =
"pipeline <pipeline_name> table <table_id> meter profile <meter_profile_id>\n"
" add srtcm cir <cir> cbs <cbs> ebs <ebs>\n"
" | trtcm cir <cir> pir <pir> cbs <cbs> pbs <pbs>\n";
static void
cmd_pipeline_table_meter_profile_add(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct rte_table_action_meter_profile p;
char *pipeline_name;
uint32_t table_id, meter_profile_id;
int status;
if (n_tokens < 9) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "meter") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "meter");
return;
}
if (strcmp(tokens[5], "profile") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
return;
}
if (parser_read_uint32(&meter_profile_id, tokens[6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "meter_profile_id");
return;
}
if (strcmp(tokens[7], "add") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add");
return;
}
if (strcmp(tokens[8], "srtcm") == 0) {
if (n_tokens != 15) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
tokens[0]);
return;
}
p.alg = RTE_TABLE_ACTION_METER_SRTCM;
if (strcmp(tokens[9], "cir") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cir");
return;
}
if (parser_read_uint64(&p.srtcm.cir, tokens[10]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "cir");
return;
}
if (strcmp(tokens[11], "cbs") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cbs");
return;
}
if (parser_read_uint64(&p.srtcm.cbs, tokens[12]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "cbs");
return;
}
if (strcmp(tokens[13], "ebs") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "ebs");
return;
}
if (parser_read_uint64(&p.srtcm.ebs, tokens[14]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "ebs");
return;
}
} else if (strcmp(tokens[8], "trtcm") == 0) {
if (n_tokens != 17) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
p.alg = RTE_TABLE_ACTION_METER_TRTCM;
if (strcmp(tokens[9], "cir") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cir");
return;
}
if (parser_read_uint64(&p.trtcm.cir, tokens[10]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "cir");
return;
}
if (strcmp(tokens[11], "pir") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pir");
return;
}
if (parser_read_uint64(&p.trtcm.pir, tokens[12]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "pir");
return;
}
if (strcmp(tokens[13], "cbs") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cbs");
return;
}
if (parser_read_uint64(&p.trtcm.cbs, tokens[14]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "cbs");
return;
}
if (strcmp(tokens[15], "pbs") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pbs");
return;
}
if (parser_read_uint64(&p.trtcm.pbs, tokens[16]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "pbs");
return;
}
} else {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
status = pipeline_table_mtr_profile_add(pipeline_name,
table_id,
meter_profile_id,
&p);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_table_meter_profile_delete_help[] =
"pipeline <pipeline_name> table <table_id>\n"
" meter profile <meter_profile_id> delete\n";
static void
cmd_pipeline_table_meter_profile_delete(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
char *pipeline_name;
uint32_t table_id, meter_profile_id;
int status;
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "meter") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "meter");
return;
}
if (strcmp(tokens[5], "profile") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
return;
}
if (parser_read_uint32(&meter_profile_id, tokens[6]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "meter_profile_id");
return;
}
if (strcmp(tokens[7], "delete") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "delete");
return;
}
status = pipeline_table_mtr_profile_delete(pipeline_name,
table_id,
meter_profile_id);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_table_rule_meter_read_help[] =
"pipeline <pipeline_name> table <table_id> rule read meter [clear]\n"
" match <match>\n";
static void
cmd_pipeline_table_rule_meter_read(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct table_rule_match m;
struct rte_table_action_mtr_counters stats;
char *pipeline_name;
uint32_t table_id, n_tokens_parsed;
int clear = 0, status;
if (n_tokens < 7) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "read") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
return;
}
if (strcmp(tokens[6], "meter") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "meter");
return;
}
n_tokens -= 7;
tokens += 7;
/* clear */
if (n_tokens && (strcmp(tokens[0], "clear") == 0)) {
clear = 1;
n_tokens--;
tokens++;
}
/* match */
if ((n_tokens == 0) || strcmp(tokens[0], "match")) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
return;
}
n_tokens_parsed = parse_match(tokens,
n_tokens,
out,
out_size,
&m);
if (n_tokens_parsed == 0)
return;
n_tokens -= n_tokens_parsed;
tokens += n_tokens_parsed;
/* end */
if (n_tokens) {
snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
return;
}
/* Read table rule meter stats. */
status = pipeline_table_rule_mtr_read(pipeline_name,
table_id,
&m,
&stats,
clear);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
/* Print stats. */
}
static const char cmd_pipeline_table_dscp_help[] =
"pipeline <pipeline_name> table <table_id> dscp <file_name>\n"
"\n"
" File <file_name>:\n"
" - exactly 64 lines\n"
" - line format: <tc_id> <tc_queue_id> <color>, with <color> as: g | y | r\n";
static int
load_dscp_table(struct rte_table_action_dscp_table *dscp_table,
const char *file_name,
uint32_t *line_number)
{
FILE *f = NULL;
uint32_t dscp, l;
/* Check input arguments */
if ((dscp_table == NULL) ||
(file_name == NULL) ||
(line_number == NULL)) {
if (line_number)
*line_number = 0;
return -EINVAL;
}
/* Open input file */
f = fopen(file_name, "r");
if (f == NULL) {
*line_number = 0;
return -EINVAL;
}
/* Read file */
for (dscp = 0, l = 1; ; l++) {
char line[64];
char *tokens[3];
enum rte_color color;
uint32_t tc_id, tc_queue_id, n_tokens = RTE_DIM(tokens);
if (fgets(line, sizeof(line), f) == NULL)
break;
if (is_comment(line))
continue;
if (parse_tokenize_string(line, tokens, &n_tokens)) {
*line_number = l;
fclose(f);
return -EINVAL;
}
if (n_tokens == 0)
continue;
if ((dscp >= RTE_DIM(dscp_table->entry)) ||
(n_tokens != RTE_DIM(tokens)) ||
parser_read_uint32(&tc_id, tokens[0]) ||
(tc_id >= RTE_TABLE_ACTION_TC_MAX) ||
parser_read_uint32(&tc_queue_id, tokens[1]) ||
(tc_queue_id >= RTE_TABLE_ACTION_TC_QUEUE_MAX) ||
(strlen(tokens[2]) != 1)) {
*line_number = l;
fclose(f);
return -EINVAL;
}
switch (tokens[2][0]) {
case 'g':
case 'G':
color = RTE_COLOR_GREEN;
break;
case 'y':
case 'Y':
color = RTE_COLOR_YELLOW;
break;
case 'r':
case 'R':
color = RTE_COLOR_RED;
break;
default:
*line_number = l;
fclose(f);
return -EINVAL;
}
dscp_table->entry[dscp].tc_id = tc_id;
dscp_table->entry[dscp].tc_queue_id = tc_queue_id;
dscp_table->entry[dscp].color = color;
dscp++;
}
/* Close file */
fclose(f);
return 0;
}
static void
cmd_pipeline_table_dscp(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct rte_table_action_dscp_table dscp_table;
char *pipeline_name, *file_name;
uint32_t table_id, line_number;
int status;
if (n_tokens != 6) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "dscp") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "dscp");
return;
}
file_name = tokens[5];
status = load_dscp_table(&dscp_table, file_name, &line_number);
if (status) {
snprintf(out, out_size, MSG_FILE_ERR, file_name, line_number);
return;
}
status = pipeline_table_dscp_table_update(pipeline_name,
table_id,
UINT64_MAX,
&dscp_table);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
}
static const char cmd_pipeline_table_rule_ttl_read_help[] =
"pipeline <pipeline_name> table <table_id> rule read ttl [clear]\n"
" match <match>\n";
static void
cmd_pipeline_table_rule_ttl_read(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct table_rule_match m;
struct rte_table_action_ttl_counters stats;
char *pipeline_name;
uint32_t table_id, n_tokens_parsed;
int clear = 0, status;
if (n_tokens < 7) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "read") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
return;
}
if (strcmp(tokens[6], "ttl") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "ttl");
return;
}
n_tokens -= 7;
tokens += 7;
/* clear */
if (n_tokens && (strcmp(tokens[0], "clear") == 0)) {
clear = 1;
n_tokens--;
tokens++;
}
/* match */
if ((n_tokens == 0) || strcmp(tokens[0], "match")) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
return;
}
n_tokens_parsed = parse_match(tokens,
n_tokens,
out,
out_size,
&m);
if (n_tokens_parsed == 0)
return;
n_tokens -= n_tokens_parsed;
tokens += n_tokens_parsed;
/* end */
if (n_tokens) {
snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
return;
}
/* Read table rule TTL stats. */
status = pipeline_table_rule_ttl_read(pipeline_name,
table_id,
&m,
&stats,
clear);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
/* Print stats. */
snprintf(out, out_size, "Packets: %" PRIu64 "\n",
stats.n_packets);
}
static const char cmd_pipeline_table_rule_time_read_help[] =
"pipeline <pipeline_name> table <table_id> rule read time\n"
" match <match>\n";
static void
cmd_pipeline_table_rule_time_read(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
struct table_rule_match m;
char *pipeline_name;
uint64_t timestamp;
uint32_t table_id, n_tokens_parsed;
int status;
if (n_tokens < 7) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
pipeline_name = tokens[1];
if (strcmp(tokens[2], "table") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
return;
}
if (parser_read_uint32(&table_id, tokens[3]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
return;
}
if (strcmp(tokens[4], "rule") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
return;
}
if (strcmp(tokens[5], "read") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
return;
}
if (strcmp(tokens[6], "time") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "time");
return;
}
n_tokens -= 7;
tokens += 7;
/* match */
if ((n_tokens == 0) || strcmp(tokens[0], "match")) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
return;
}
n_tokens_parsed = parse_match(tokens,
n_tokens,
out,
out_size,
&m);
if (n_tokens_parsed == 0)
return;
n_tokens -= n_tokens_parsed;
tokens += n_tokens_parsed;
/* end */
if (n_tokens) {
snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
return;
}
/* Read table rule timestamp. */
status = pipeline_table_rule_time_read(pipeline_name,
table_id,
&m,
&timestamp);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
}
/* Print stats. */
snprintf(out, out_size, "Packets: %" PRIu64 "\n", timestamp);
}
static const char cmd_thread_pipeline_enable_help[] =
"thread <thread_id> pipeline <pipeline_name> enable\n";
static void
cmd_thread_pipeline_enable(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
char *pipeline_name;
uint32_t thread_id;
int status;
if (n_tokens != 5) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
if (parser_read_uint32(&thread_id, tokens[1]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "thread_id");
return;
}
if (strcmp(tokens[2], "pipeline") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipeline");
return;
}
pipeline_name = tokens[3];
if (strcmp(tokens[4], "enable") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "enable");
return;
}
status = thread_pipeline_enable(thread_id, pipeline_name);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL, "thread pipeline enable");
return;
}
}
static const char cmd_thread_pipeline_disable_help[] =
"thread <thread_id> pipeline <pipeline_name> disable\n";
static void
cmd_thread_pipeline_disable(char **tokens,
uint32_t n_tokens,
char *out,
size_t out_size)
{
char *pipeline_name;
uint32_t thread_id;
int status;
if (n_tokens != 5) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
if (parser_read_uint32(&thread_id, tokens[1]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "thread_id");
return;
}
if (strcmp(tokens[2], "pipeline") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipeline");
return;
}
pipeline_name = tokens[3];
if (strcmp(tokens[4], "disable") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "disable");
return;
}
status = thread_pipeline_disable(thread_id, pipeline_name);
if (status) {
snprintf(out, out_size, MSG_CMD_FAIL,
"thread pipeline disable");
return;
}
}
static void
cmd_help(char **tokens, uint32_t n_tokens, char *out, size_t out_size)
{
tokens++;
n_tokens--;
if (n_tokens == 0) {
snprintf(out, out_size,
"Type 'help <command>' for details on each command.\n\n"
"List of commands:\n"
"\tmempool\n"
"\tlink\n"
"\tswq\n"
"\ttmgr subport profile\n"
"\ttmgr pipe profile\n"
"\ttmgr\n"
"\ttmgr subport\n"
"\ttmgr subport pipe\n"
"\ttap\n"
"\tport in action profile\n"
"\ttable action profile\n"
"\tpipeline\n"
"\tpipeline port in\n"
"\tpipeline port out\n"
"\tpipeline table\n"
"\tpipeline port in table\n"
"\tpipeline port in stats\n"
"\tpipeline port in enable\n"
"\tpipeline port in disable\n"
"\tpipeline port out stats\n"
"\tpipeline table stats\n"
"\tpipeline table rule add\n"
"\tpipeline table rule add default\n"
"\tpipeline table rule add bulk\n"
"\tpipeline table rule delete\n"
"\tpipeline table rule delete default\n"
"\tpipeline table rule show\n"
"\tpipeline table rule stats read\n"
"\tpipeline table meter profile add\n"
"\tpipeline table meter profile delete\n"
"\tpipeline table rule meter read\n"
"\tpipeline table dscp\n"
"\tpipeline table rule ttl read\n"
"\tpipeline table rule time read\n"
"\tthread pipeline enable\n"
"\tthread pipeline disable\n\n");
return;
}
if (strcmp(tokens[0], "mempool") == 0) {
snprintf(out, out_size, "\n%s\n", cmd_mempool_help);
return;
}
if (strcmp(tokens[0], "link") == 0) {
snprintf(out, out_size, "\n%s\n", cmd_link_help);
return;
}
if (strcmp(tokens[0], "swq") == 0) {
snprintf(out, out_size, "\n%s\n", cmd_swq_help);
return;
}
if (strcmp(tokens[0], "tmgr") == 0) {
if (n_tokens == 1) {
snprintf(out, out_size, "\n%s\n", cmd_tmgr_help);
return;
}
if ((n_tokens == 2) &&
(strcmp(tokens[1], "subport")) == 0) {
snprintf(out, out_size, "\n%s\n", cmd_tmgr_subport_help);
return;
}
if ((n_tokens == 3) &&
(strcmp(tokens[1], "subport") == 0) &&
(strcmp(tokens[2], "profile") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_tmgr_subport_profile_help);
return;
}
if ((n_tokens == 3) &&
(strcmp(tokens[1], "subport") == 0) &&
(strcmp(tokens[2], "pipe") == 0)) {
snprintf(out, out_size, "\n%s\n", cmd_tmgr_subport_pipe_help);
return;
}
if ((n_tokens == 3) &&
(strcmp(tokens[1], "pipe") == 0) &&
(strcmp(tokens[2], "profile") == 0)) {
snprintf(out, out_size, "\n%s\n", cmd_tmgr_pipe_profile_help);
return;
}
}
if (strcmp(tokens[0], "tap") == 0) {
snprintf(out, out_size, "\n%s\n", cmd_tap_help);
return;
}
if (strcmp(tokens[0], "cryptodev") == 0) {
snprintf(out, out_size, "\n%s\n", cmd_cryptodev_help);
return;
}
if ((n_tokens == 4) &&
(strcmp(tokens[0], "port") == 0) &&
(strcmp(tokens[1], "in") == 0) &&
(strcmp(tokens[2], "action") == 0) &&
(strcmp(tokens[3], "profile") == 0)) {
snprintf(out, out_size, "\n%s\n", cmd_port_in_action_profile_help);
return;
}
if ((n_tokens == 3) &&
(strcmp(tokens[0], "table") == 0) &&
(strcmp(tokens[1], "action") == 0) &&
(strcmp(tokens[2], "profile") == 0)) {
snprintf(out, out_size, "\n%s\n", cmd_table_action_profile_help);
return;
}
if ((strcmp(tokens[0], "pipeline") == 0) && (n_tokens == 1)) {
snprintf(out, out_size, "\n%s\n", cmd_pipeline_help);
return;
}
if ((strcmp(tokens[0], "pipeline") == 0) &&
(strcmp(tokens[1], "port") == 0)) {
if ((n_tokens == 3) && (strcmp(tokens[2], "in")) == 0) {
snprintf(out, out_size, "\n%s\n", cmd_pipeline_port_in_help);
return;
}
if ((n_tokens == 3) && (strcmp(tokens[2], "out")) == 0) {
snprintf(out, out_size, "\n%s\n", cmd_pipeline_port_out_help);
return;
}
if ((n_tokens == 4) &&
(strcmp(tokens[2], "in") == 0) &&
(strcmp(tokens[3], "table") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_port_in_table_help);
return;
}
if ((n_tokens == 4) &&
(strcmp(tokens[2], "in") == 0) &&
(strcmp(tokens[3], "stats") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_port_in_stats_help);
return;
}
if ((n_tokens == 4) &&
(strcmp(tokens[2], "in") == 0) &&
(strcmp(tokens[3], "enable") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_port_in_enable_help);
return;
}
if ((n_tokens == 4) &&
(strcmp(tokens[2], "in") == 0) &&
(strcmp(tokens[3], "disable") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_port_in_disable_help);
return;
}
if ((n_tokens == 4) &&
(strcmp(tokens[2], "out") == 0) &&
(strcmp(tokens[3], "stats") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_port_out_stats_help);
return;
}
}
if ((strcmp(tokens[0], "pipeline") == 0) &&
(strcmp(tokens[1], "table") == 0)) {
if (n_tokens == 2) {
snprintf(out, out_size, "\n%s\n", cmd_pipeline_table_help);
return;
}
if ((n_tokens == 3) && strcmp(tokens[2], "stats") == 0) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_stats_help);
return;
}
if ((n_tokens == 3) && strcmp(tokens[2], "dscp") == 0) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_dscp_help);
return;
}
if ((n_tokens == 4) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "add") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_add_help);
return;
}
if ((n_tokens == 5) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "add") == 0) &&
(strcmp(tokens[4], "default") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_add_default_help);
return;
}
if ((n_tokens == 5) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "add") == 0) &&
(strcmp(tokens[4], "bulk") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_add_bulk_help);
return;
}
if ((n_tokens == 4) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "delete") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_delete_help);
return;
}
if ((n_tokens == 5) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "delete") == 0) &&
(strcmp(tokens[4], "default") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_delete_default_help);
return;
}
if ((n_tokens == 4) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "show") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_show_help);
return;
}
if ((n_tokens == 5) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "stats") == 0) &&
(strcmp(tokens[4], "read") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_stats_read_help);
return;
}
if ((n_tokens == 5) &&
(strcmp(tokens[2], "meter") == 0) &&
(strcmp(tokens[3], "profile") == 0) &&
(strcmp(tokens[4], "add") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_meter_profile_add_help);
return;
}
if ((n_tokens == 5) &&
(strcmp(tokens[2], "meter") == 0) &&
(strcmp(tokens[3], "profile") == 0) &&
(strcmp(tokens[4], "delete") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_meter_profile_delete_help);
return;
}
if ((n_tokens == 5) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "meter") == 0) &&
(strcmp(tokens[4], "read") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_meter_read_help);
return;
}
if ((n_tokens == 5) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "ttl") == 0) &&
(strcmp(tokens[4], "read") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_ttl_read_help);
return;
}
if ((n_tokens == 5) &&
(strcmp(tokens[2], "rule") == 0) &&
(strcmp(tokens[3], "time") == 0) &&
(strcmp(tokens[4], "read") == 0)) {
snprintf(out, out_size, "\n%s\n",
cmd_pipeline_table_rule_time_read_help);
return;
}
}
if ((n_tokens == 3) &&
(strcmp(tokens[0], "thread") == 0) &&
(strcmp(tokens[1], "pipeline") == 0)) {
if (strcmp(tokens[2], "enable") == 0) {
snprintf(out, out_size, "\n%s\n",
cmd_thread_pipeline_enable_help);
return;
}
if (strcmp(tokens[2], "disable") == 0) {
snprintf(out, out_size, "\n%s\n",
cmd_thread_pipeline_disable_help);
return;
}
}
snprintf(out, out_size, "Invalid command\n");
}
void
cli_process(char *in, char *out, size_t out_size)
{
char *tokens[CMD_MAX_TOKENS];
uint32_t n_tokens = RTE_DIM(tokens);
int status;
if (is_comment(in))
return;
status = parse_tokenize_string(in, tokens, &n_tokens);
if (status) {
snprintf(out, out_size, MSG_ARG_TOO_MANY, "");
return;
}
if (n_tokens == 0)
return;
if (strcmp(tokens[0], "help") == 0) {
cmd_help(tokens, n_tokens, out, out_size);
return;
}
if (strcmp(tokens[0], "mempool") == 0) {
cmd_mempool(tokens, n_tokens, out, out_size);
return;
}
if (strcmp(tokens[0], "link") == 0) {
if (strcmp(tokens[1], "show") == 0) {
cmd_link_show(tokens, n_tokens, out, out_size);
return;
}
cmd_link(tokens, n_tokens, out, out_size);
return;
}
if (strcmp(tokens[0], "swq") == 0) {
cmd_swq(tokens, n_tokens, out, out_size);
return;
}
if (strcmp(tokens[0], "tmgr") == 0) {
if ((n_tokens >= 3) &&
(strcmp(tokens[1], "subport") == 0) &&
(strcmp(tokens[2], "profile") == 0)) {
cmd_tmgr_subport_profile(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 3) &&
(strcmp(tokens[1], "pipe") == 0) &&
(strcmp(tokens[2], "profile") == 0)) {
cmd_tmgr_pipe_profile(tokens, n_tokens, out, out_size);
return;
}
if ((n_tokens >= 5) &&
(strcmp(tokens[2], "subport") == 0) &&
(strcmp(tokens[4], "profile") == 0)) {
cmd_tmgr_subport(tokens, n_tokens, out, out_size);
return;
}
if ((n_tokens >= 5) &&
(strcmp(tokens[2], "subport") == 0) &&
(strcmp(tokens[4], "pipe") == 0)) {
cmd_tmgr_subport_pipe(tokens, n_tokens, out, out_size);
return;
}
cmd_tmgr(tokens, n_tokens, out, out_size);
return;
}
if (strcmp(tokens[0], "tap") == 0) {
cmd_tap(tokens, n_tokens, out, out_size);
return;
}
if (strcmp(tokens[0], "cryptodev") == 0) {
cmd_cryptodev(tokens, n_tokens, out, out_size);
return;
}
if (strcmp(tokens[0], "port") == 0) {
cmd_port_in_action_profile(tokens, n_tokens, out, out_size);
return;
}
if (strcmp(tokens[0], "table") == 0) {
cmd_table_action_profile(tokens, n_tokens, out, out_size);
return;
}
if (strcmp(tokens[0], "pipeline") == 0) {
if ((n_tokens >= 3) &&
(strcmp(tokens[2], "period") == 0)) {
cmd_pipeline(tokens, n_tokens, out, out_size);
return;
}
if ((n_tokens >= 5) &&
(strcmp(tokens[2], "port") == 0) &&
(strcmp(tokens[3], "in") == 0) &&
(strcmp(tokens[4], "bsz") == 0)) {
cmd_pipeline_port_in(tokens, n_tokens, out, out_size);
return;
}
if ((n_tokens >= 5) &&
(strcmp(tokens[2], "port") == 0) &&
(strcmp(tokens[3], "out") == 0) &&
(strcmp(tokens[4], "bsz") == 0)) {
cmd_pipeline_port_out(tokens, n_tokens, out, out_size);
return;
}
if ((n_tokens >= 4) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[3], "match") == 0)) {
cmd_pipeline_table(tokens, n_tokens, out, out_size);
return;
}
if ((n_tokens >= 6) &&
(strcmp(tokens[2], "port") == 0) &&
(strcmp(tokens[3], "in") == 0) &&
(strcmp(tokens[5], "table") == 0)) {
cmd_pipeline_port_in_table(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 6) &&
(strcmp(tokens[2], "port") == 0) &&
(strcmp(tokens[3], "in") == 0) &&
(strcmp(tokens[5], "stats") == 0)) {
cmd_pipeline_port_in_stats(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 6) &&
(strcmp(tokens[2], "port") == 0) &&
(strcmp(tokens[3], "in") == 0) &&
(strcmp(tokens[5], "enable") == 0)) {
cmd_pipeline_port_in_enable(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 6) &&
(strcmp(tokens[2], "port") == 0) &&
(strcmp(tokens[3], "in") == 0) &&
(strcmp(tokens[5], "disable") == 0)) {
cmd_pipeline_port_in_disable(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 6) &&
(strcmp(tokens[2], "port") == 0) &&
(strcmp(tokens[3], "out") == 0) &&
(strcmp(tokens[5], "stats") == 0)) {
cmd_pipeline_port_out_stats(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 5) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "stats") == 0)) {
cmd_pipeline_table_stats(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 7) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "rule") == 0) &&
(strcmp(tokens[5], "add") == 0) &&
(strcmp(tokens[6], "match") == 0)) {
if ((n_tokens >= 8) &&
(strcmp(tokens[7], "default") == 0)) {
cmd_pipeline_table_rule_add_default(tokens,
n_tokens, out, out_size);
return;
}
cmd_pipeline_table_rule_add(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 7) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "rule") == 0) &&
(strcmp(tokens[5], "add") == 0) &&
(strcmp(tokens[6], "bulk") == 0)) {
cmd_pipeline_table_rule_add_bulk(tokens,
n_tokens, out, out_size);
return;
}
if ((n_tokens >= 7) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "rule") == 0) &&
(strcmp(tokens[5], "delete") == 0) &&
(strcmp(tokens[6], "match") == 0)) {
if ((n_tokens >= 8) &&
(strcmp(tokens[7], "default") == 0)) {
cmd_pipeline_table_rule_delete_default(tokens,
n_tokens, out, out_size);
return;
}
cmd_pipeline_table_rule_delete(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 6) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "rule") == 0) &&
(strcmp(tokens[5], "show") == 0)) {
cmd_pipeline_table_rule_show(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 7) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "rule") == 0) &&
(strcmp(tokens[5], "read") == 0) &&
(strcmp(tokens[6], "stats") == 0)) {
cmd_pipeline_table_rule_stats_read(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 8) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "meter") == 0) &&
(strcmp(tokens[5], "profile") == 0) &&
(strcmp(tokens[7], "add") == 0)) {
cmd_pipeline_table_meter_profile_add(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 8) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "meter") == 0) &&
(strcmp(tokens[5], "profile") == 0) &&
(strcmp(tokens[7], "delete") == 0)) {
cmd_pipeline_table_meter_profile_delete(tokens,
n_tokens, out, out_size);
return;
}
if ((n_tokens >= 7) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "rule") == 0) &&
(strcmp(tokens[5], "read") == 0) &&
(strcmp(tokens[6], "meter") == 0)) {
cmd_pipeline_table_rule_meter_read(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 5) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "dscp") == 0)) {
cmd_pipeline_table_dscp(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 7) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "rule") == 0) &&
(strcmp(tokens[5], "read") == 0) &&
(strcmp(tokens[6], "ttl") == 0)) {
cmd_pipeline_table_rule_ttl_read(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 7) &&
(strcmp(tokens[2], "table") == 0) &&
(strcmp(tokens[4], "rule") == 0) &&
(strcmp(tokens[5], "read") == 0) &&
(strcmp(tokens[6], "time") == 0)) {
cmd_pipeline_table_rule_time_read(tokens, n_tokens,
out, out_size);
return;
}
}
if (strcmp(tokens[0], "thread") == 0) {
if ((n_tokens >= 5) &&
(strcmp(tokens[4], "enable") == 0)) {
cmd_thread_pipeline_enable(tokens, n_tokens,
out, out_size);
return;
}
if ((n_tokens >= 5) &&
(strcmp(tokens[4], "disable") == 0)) {
cmd_thread_pipeline_disable(tokens, n_tokens,
out, out_size);
return;
}
}
snprintf(out, out_size, MSG_CMD_UNKNOWN, tokens[0]);
}
int
cli_script_process(const char *file_name,
size_t msg_in_len_max,
size_t msg_out_len_max)
{
char *msg_in = NULL, *msg_out = NULL;
FILE *f = NULL;
/* Check input arguments */
if ((file_name == NULL) ||
(strlen(file_name) == 0) ||
(msg_in_len_max == 0) ||
(msg_out_len_max == 0))
return -EINVAL;
msg_in = malloc(msg_in_len_max + 1);
msg_out = malloc(msg_out_len_max + 1);
if ((msg_in == NULL) ||
(msg_out == NULL)) {
free(msg_out);
free(msg_in);
return -ENOMEM;
}
/* Open input file */
f = fopen(file_name, "r");
if (f == NULL) {
free(msg_out);
free(msg_in);
return -EIO;
}
/* Read file */
for ( ; ; ) {
if (fgets(msg_in, msg_in_len_max + 1, f) == NULL)
break;
printf("%s", msg_in);
msg_out[0] = 0;
cli_process(msg_in,
msg_out,
msg_out_len_max);
if (strlen(msg_out))
printf("%s", msg_out);
}
/* Close file */
fclose(f);
free(msg_out);
free(msg_in);
return 0;
}
static int
cli_rule_file_process(const char *file_name,
size_t line_len_max,
struct table_rule_list **rule_list,
uint32_t *n_rules,
uint32_t *line_number,
char *out,
size_t out_size)
{
struct table_rule_list *list = NULL;
char *line = NULL;
FILE *f = NULL;
uint32_t rule_id = 0, line_id = 0;
int status = 0;
/* Check input arguments */
if ((file_name == NULL) ||
(strlen(file_name) == 0) ||
(line_len_max == 0) ||
(rule_list == NULL) ||
(n_rules == NULL) ||
(line_number == NULL) ||
(out == NULL)) {
status = -EINVAL;
goto cli_rule_file_process_free;
}
/* Memory allocation */
list = malloc(sizeof(struct table_rule_list));
if (list == NULL) {
status = -ENOMEM;
goto cli_rule_file_process_free;
}
TAILQ_INIT(list);
line = malloc(line_len_max + 1);
if (line == NULL) {
status = -ENOMEM;
goto cli_rule_file_process_free;
}
/* Open file */
f = fopen(file_name, "r");
if (f == NULL) {
status = -EIO;
goto cli_rule_file_process_free;
}
/* Read file */
for (line_id = 1, rule_id = 0; ; line_id++) {
char *tokens[CMD_MAX_TOKENS];
struct table_rule *rule = NULL;
uint32_t n_tokens, n_tokens_parsed, t0;
/* Read next line from file. */
if (fgets(line, line_len_max + 1, f) == NULL)
break;
/* Comment. */
if (is_comment(line))
continue;
/* Parse line. */
n_tokens = RTE_DIM(tokens);
status = parse_tokenize_string(line, tokens, &n_tokens);
if (status) {
status = -EINVAL;
goto cli_rule_file_process_free;
}
/* Empty line. */
if (n_tokens == 0)
continue;
t0 = 0;
/* Rule alloc and insert. */
rule = calloc(1, sizeof(struct table_rule));
if (rule == NULL) {
status = -ENOMEM;
goto cli_rule_file_process_free;
}
TAILQ_INSERT_TAIL(list, rule, node);
/* Rule match. */
n_tokens_parsed = parse_match(tokens + t0,
n_tokens - t0,
out,
out_size,
&rule->match);
if (n_tokens_parsed == 0) {
status = -EINVAL;
goto cli_rule_file_process_free;
}
t0 += n_tokens_parsed;
/* Rule action. */
n_tokens_parsed = parse_table_action(tokens + t0,
n_tokens - t0,
out,
out_size,
&rule->action);
if (n_tokens_parsed == 0) {
status = -EINVAL;
goto cli_rule_file_process_free;
}
t0 += n_tokens_parsed;
/* Line completed. */
if (t0 < n_tokens) {
status = -EINVAL;
goto cli_rule_file_process_free;
}
/* Increment rule count */
rule_id++;
}
/* Close file */
fclose(f);
/* Memory free */
free(line);
*rule_list = list;
*n_rules = rule_id;
*line_number = line_id;
return 0;
cli_rule_file_process_free:
if (rule_list != NULL)
*rule_list = NULL;
if (n_rules != NULL)
*n_rules = rule_id;
if (line_number != NULL)
*line_number = line_id;
if (list != NULL)
for ( ; ; ) {
struct table_rule *rule;
rule = TAILQ_FIRST(list);
if (rule == NULL)
break;
TAILQ_REMOVE(list, rule, node);
free(rule);
}
if (f)
fclose(f);
free(line);
free(list);
return status;
}
rte_be_to_cpu_32
static uint32_t rte_be_to_cpu_32(rte_be32_t x)
rte_cpu_to_be_16
static rte_be16_t rte_cpu_to_be_16(uint16_t x)
rte_common.h
__rte_packed
#define __rte_packed
Definition: rte_common.h:108
RTE_DIM
#define RTE_DIM(a)
Definition: rte_common.h:793
RTE_CRYPTO_CIPHER_OP_DECRYPT
@ RTE_CRYPTO_CIPHER_OP_DECRYPT
Definition: rte_crypto_sym.h:189
RTE_CRYPTO_CIPHER_OP_ENCRYPT
@ RTE_CRYPTO_CIPHER_OP_ENCRYPT
Definition: rte_crypto_sym.h:187
RTE_CRYPTO_SYM_XFORM_AUTH
@ RTE_CRYPTO_SYM_XFORM_AUTH
Definition: rte_crypto_sym.h:564
RTE_CRYPTO_SYM_XFORM_AEAD
@ RTE_CRYPTO_SYM_XFORM_AEAD
Definition: rte_crypto_sym.h:566
RTE_CRYPTO_SYM_XFORM_CIPHER
@ RTE_CRYPTO_SYM_XFORM_CIPHER
Definition: rte_crypto_sym.h:565
RTE_CRYPTO_AUTH_OP_VERIFY
@ RTE_CRYPTO_AUTH_OP_VERIFY
Definition: rte_crypto_sym.h:391
RTE_CRYPTO_AUTH_OP_GENERATE
@ RTE_CRYPTO_AUTH_OP_GENERATE
Definition: rte_crypto_sym.h:392
RTE_CRYPTO_AEAD_OP_DECRYPT
@ RTE_CRYPTO_AEAD_OP_DECRYPT
Definition: rte_crypto_sym.h:493
RTE_CRYPTO_AEAD_OP_ENCRYPT
@ RTE_CRYPTO_AEAD_OP_ENCRYPT
Definition: rte_crypto_sym.h:491
rte_cryptodev_get_auth_algo_enum
int rte_cryptodev_get_auth_algo_enum(enum rte_crypto_auth_algorithm *algo_enum, const char *algo_string)
rte_cryptodev_get_cipher_algo_enum
int rte_cryptodev_get_cipher_algo_enum(enum rte_crypto_cipher_algorithm *algo_enum, const char *algo_string)
rte_cryptodev_get_aead_algo_enum
int rte_cryptodev_get_aead_algo_enum(enum rte_crypto_aead_algorithm *algo_enum, const char *algo_string)
rte_cycles.h
rte_strerror
const char * rte_strerror(int errnum)
rte_ethdev.h
rte_eth_dev_get_mtu
int rte_eth_dev_get_mtu(uint16_t port_id, uint16_t *mtu)
rte_eth_macaddr_get
int rte_eth_macaddr_get(uint16_t port_id, struct rte_ether_addr *mac_addr)
rte_eth_link_get
int rte_eth_link_get(uint16_t port_id, struct rte_eth_link *link) __rte_warn_unused_result
rte_eth_link_speed_to_str
__rte_experimental const char * rte_eth_link_speed_to_str(uint32_t link_speed)
rte_eth_stats_get
int rte_eth_stats_get(uint16_t port_id, struct rte_eth_stats *stats)
RTE_ETHER_ADDR_PRT_FMT
#define RTE_ETHER_ADDR_PRT_FMT
Definition: rte_ether.h:248
RTE_ETHER_ADDR_BYTES
#define RTE_ETHER_ADDR_BYTES(mac_addrs)
Definition: rte_ether.h:252
RTE_IPV6_ADDR_SPLIT
#define RTE_IPV6_ADDR_SPLIT(ip)
Definition: rte_ip6.h:210
RTE_IPV6_ADDR_FMT
#define RTE_IPV6_ADDR_FMT
Definition: rte_ip6.h:195
rte_color
rte_color
Definition: rte_meter.h:32
RTE_COLOR_GREEN
@ RTE_COLOR_GREEN
Definition: rte_meter.h:33
RTE_COLOR_YELLOW
@ RTE_COLOR_YELLOW
Definition: rte_meter.h:34
RTE_COLOR_RED
@ RTE_COLOR_RED
Definition: rte_meter.h:35
RTE_PIPELINE_ACTION_PORT_META
@ RTE_PIPELINE_ACTION_PORT_META
Definition: rte_pipeline.h:186
RTE_PIPELINE_ACTION_TABLE
@ RTE_PIPELINE_ACTION_TABLE
Definition: rte_pipeline.h:189
RTE_PIPELINE_ACTION_PORT
@ RTE_PIPELINE_ACTION_PORT
Definition: rte_pipeline.h:183
RTE_PIPELINE_ACTION_DROP
@ RTE_PIPELINE_ACTION_DROP
Definition: rte_pipeline.h:180
RTE_PORT_IN_ACTION_FLTR_KEY_SIZE
#define RTE_PORT_IN_ACTION_FLTR_KEY_SIZE
Definition: rte_port_in_action.h:73
RTE_PORT_IN_ACTION_LB
@ RTE_PORT_IN_ACTION_LB
Definition: rte_port_in_action.h:66
RTE_PORT_IN_ACTION_FLTR
@ RTE_PORT_IN_ACTION_FLTR
Definition: rte_port_in_action.h:63
RTE_PORT_IN_ACTION_LB_KEY_SIZE_MAX
#define RTE_PORT_IN_ACTION_LB_KEY_SIZE_MAX
Definition: rte_port_in_action.h:116
RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE
#define RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE
Definition: rte_sched.h:85
RTE_SCHED_BE_QUEUES_PER_PIPE
#define RTE_SCHED_BE_QUEUES_PER_PIPE
Definition: rte_sched.h:79
RTE_TABLE_ACTION_TC_QUEUE_MAX
#define RTE_TABLE_ACTION_TC_QUEUE_MAX
Definition: rte_table_action.h:188
rte_table_action_policer
rte_table_action_policer
Definition: rte_table_action.h:239
RTE_TABLE_ACTION_POLICER_COLOR_RED
@ RTE_TABLE_ACTION_POLICER_COLOR_RED
Definition: rte_table_action.h:247
RTE_TABLE_ACTION_POLICER_COLOR_GREEN
@ RTE_TABLE_ACTION_POLICER_COLOR_GREEN
Definition: rte_table_action.h:241
RTE_TABLE_ACTION_POLICER_COLOR_YELLOW
@ RTE_TABLE_ACTION_POLICER_COLOR_YELLOW
Definition: rte_table_action.h:244
RTE_TABLE_ACTION_POLICER_DROP
@ RTE_TABLE_ACTION_POLICER_DROP
Definition: rte_table_action.h:250
RTE_TABLE_ACTION_ENCAP_VLAN
@ RTE_TABLE_ACTION_ENCAP_VLAN
Definition: rte_table_action.h:368
RTE_TABLE_ACTION_ENCAP_QINQ_PPPOE
@ RTE_TABLE_ACTION_ENCAP_QINQ_PPPOE
Definition: rte_table_action.h:385
RTE_TABLE_ACTION_ENCAP_MPLS
@ RTE_TABLE_ACTION_ENCAP_MPLS
Definition: rte_table_action.h:374
RTE_TABLE_ACTION_ENCAP_VXLAN
@ RTE_TABLE_ACTION_ENCAP_VXLAN
Definition: rte_table_action.h:382
RTE_TABLE_ACTION_ENCAP_QINQ
@ RTE_TABLE_ACTION_ENCAP_QINQ
Definition: rte_table_action.h:371
RTE_TABLE_ACTION_ENCAP_PPPOE
@ RTE_TABLE_ACTION_ENCAP_PPPOE
Definition: rte_table_action.h:377
RTE_TABLE_ACTION_ENCAP_ETHER
@ RTE_TABLE_ACTION_ENCAP_ETHER
Definition: rte_table_action.h:365
RTE_TABLE_ACTION_TAG
@ RTE_TABLE_ACTION_TAG
Definition: rte_table_action.h:102
RTE_TABLE_ACTION_STATS
@ RTE_TABLE_ACTION_STATS
Definition: rte_table_action.h:93
RTE_TABLE_ACTION_TIME
@ RTE_TABLE_ACTION_TIME
Definition: rte_table_action.h:96
RTE_TABLE_ACTION_NAT
@ RTE_TABLE_ACTION_NAT
Definition: rte_table_action.h:87
RTE_TABLE_ACTION_TTL
@ RTE_TABLE_ACTION_TTL
Definition: rte_table_action.h:90
RTE_TABLE_ACTION_DECAP
@ RTE_TABLE_ACTION_DECAP
Definition: rte_table_action.h:105
RTE_TABLE_ACTION_MTR
@ RTE_TABLE_ACTION_MTR
Definition: rte_table_action.h:78
RTE_TABLE_ACTION_SYM_CRYPTO
@ RTE_TABLE_ACTION_SYM_CRYPTO
Definition: rte_table_action.h:99
RTE_TABLE_ACTION_TM
@ RTE_TABLE_ACTION_TM
Definition: rte_table_action.h:81
RTE_TABLE_ACTION_FWD
@ RTE_TABLE_ACTION_FWD
Definition: rte_table_action.h:72
RTE_TABLE_ACTION_ENCAP
@ RTE_TABLE_ACTION_ENCAP
Definition: rte_table_action.h:84
RTE_TABLE_ACTION_LB
@ RTE_TABLE_ACTION_LB
Definition: rte_table_action.h:75
RTE_TABLE_ACTION_TC_MAX
#define RTE_TABLE_ACTION_TC_MAX
Definition: rte_table_action.h:185
RTE_TABLE_ACTION_METER_TRTCM
@ RTE_TABLE_ACTION_METER_TRTCM
Definition: rte_table_action.h:221
RTE_TABLE_ACTION_METER_SRTCM
@ RTE_TABLE_ACTION_METER_SRTCM
Definition: rte_table_action.h:218
RTE_TABLE_ACTION_LB_TABLE_SIZE
#define RTE_TABLE_ACTION_LB_TABLE_SIZE
Definition: rte_table_action.h:143
rte_crypto_auth_xform::algo
enum rte_crypto_auth_algorithm algo
Definition: rte_crypto_sym.h:409
rte_crypto_auth_xform::length
uint16_t length
Definition: rte_crypto_sym.h:414
rte_crypto_auth_xform::key
struct rte_crypto_auth_xform::@103 key
rte_crypto_auth_xform::data
const uint8_t * data
Definition: rte_crypto_sym.h:413
rte_crypto_auth_xform::digest_length
uint16_t digest_length
Definition: rte_crypto_sym.h:460
rte_crypto_auth_xform::op
enum rte_crypto_auth_operation op
Definition: rte_crypto_sym.h:407
rte_crypto_cipher_xform::length
uint16_t length
Definition: rte_crypto_sym.h:214
rte_crypto_cipher_xform::algo
enum rte_crypto_cipher_algorithm algo
Definition: rte_crypto_sym.h:209
rte_crypto_cipher_xform::data
const uint8_t * data
Definition: rte_crypto_sym.h:213
rte_crypto_cipher_xform::iv
struct rte_crypto_cipher_xform::@102 iv
rte_crypto_cipher_xform::key
struct rte_crypto_cipher_xform::@101 key
rte_crypto_cipher_xform::op
enum rte_crypto_cipher_operation op
Definition: rte_crypto_sym.h:204
rte_crypto_cipher_xform::offset
uint16_t offset
Definition: rte_crypto_sym.h:248
rte_crypto_sym_xform
Definition: rte_crypto_sym.h:579
rte_crypto_sym_xform::auth
struct rte_crypto_auth_xform auth
Definition: rte_crypto_sym.h:585
rte_crypto_sym_xform::type
enum rte_crypto_sym_xform_type type
Definition: rte_crypto_sym.h:582
rte_crypto_sym_xform::next
struct rte_crypto_sym_xform * next
Definition: rte_crypto_sym.h:580
rte_crypto_sym_xform::cipher
struct rte_crypto_cipher_xform cipher
Definition: rte_crypto_sym.h:587
rte_crypto_sym_xform::aead
struct rte_crypto_aead_xform aead
Definition: rte_crypto_sym.h:589
rte_eth_link
Definition: rte_ethdev.h:335
rte_eth_stats
Definition: rte_ethdev.h:262
rte_ipv6_addr
Definition: rte_ip6.h:53
rte_pipeline_port_in_stats
Definition: rte_pipeline.h:86
rte_pipeline_port_in_stats::stats
struct rte_port_in_stats stats
Definition: rte_pipeline.h:88
rte_pipeline_port_out_stats
Definition: rte_pipeline.h:96
rte_pipeline_port_out_stats::stats
struct rte_port_out_stats stats
Definition: rte_pipeline.h:98
rte_pipeline_table_stats
Definition: rte_pipeline.h:105
rte_pipeline_table_stats::stats
struct rte_table_stats stats
Definition: rte_pipeline.h:107
rte_table_action_dscp_table_entry::tc_queue_id
uint32_t tc_queue_id
Definition: rte_table_action.h:201
rte_table_action_dscp_table_entry::tc_id
uint32_t tc_id
Definition: rte_table_action.h:196
rte_table_action_dscp_table_entry::color
enum rte_color color
Definition: rte_table_action.h:206
rte_table_action_dscp_table
Definition: rte_table_action.h:210
rte_table_action_dscp_table::entry
struct rte_table_action_dscp_table_entry entry[64]
Definition: rte_table_action.h:212
rte_table_action_meter_profile
Definition: rte_table_action.h:225
rte_table_action_mpls_hdr
Definition: rte_table_action.h:402
rte_table_action_mpls_hdr::ttl
uint8_t ttl
Definition: rte_table_action.h:405
rte_table_action_mpls_hdr::tc
uint8_t tc
Definition: rte_table_action.h:404
rte_table_action_mpls_hdr::label
uint32_t label
Definition: rte_table_action.h:403
rte_table_action_mtr_counters
Definition: rte_table_action.h:327
rte_table_action_mtr_counters::stats
struct rte_table_action_mtr_counters_tc stats[RTE_TABLE_ACTION_TC_MAX]
Definition: rte_table_action.h:329
rte_table_action_mtr_tc_params
Definition: rte_table_action.h:257
rte_table_action_mtr_tc_params::meter_profile_id
uint32_t meter_profile_id
Definition: rte_table_action.h:259
rte_table_action_mtr_tc_params::policer
enum rte_table_action_policer policer[RTE_COLORS]
Definition: rte_table_action.h:262
rte_table_action_stats_counters
Definition: rte_table_action.h:682
rte_table_action_sym_crypto_params
Definition: rte_table_action.h:747
rte_table_action_sym_crypto_params::data_offset
uint32_t data_offset
Definition: rte_table_action.h:757
rte_table_action_sym_crypto_params::aad
struct rte_table_action_vlo aad
Definition: rte_table_action.h:777
rte_table_action_sym_crypto_params::cipher_iv_update
struct rte_table_action_vlo cipher_iv_update
Definition: rte_table_action.h:765
rte_table_action_sym_crypto_params::cipher_iv
struct rte_table_action_vlo cipher_iv
Definition: rte_table_action.h:762
rte_table_action_sym_crypto_params::iv
struct rte_table_action_vlo iv
Definition: rte_table_action.h:780
rte_table_action_sym_crypto_params::auth_iv_update
struct rte_table_action_vlo auth_iv_update
Definition: rte_table_action.h:771
rte_table_action_sym_crypto_params::xform
struct rte_crypto_sym_xform * xform
Definition: rte_table_action.h:750
rte_table_action_sym_crypto_params::auth_iv
struct rte_table_action_vlo auth_iv
Definition: rte_table_action.h:768
rte_table_action_ttl_counters
Definition: rte_table_action.h:639
Generated by doxygen 1.9.4