From patchwork Fri May 6 15:57:29 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michal Jastrzebski X-Patchwork-Id: 12532 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id B7A013798; Fri, 6 May 2016 18:01:07 +0200 (CEST) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by dpdk.org (Postfix) with ESMTP id 9F0CC2C72 for ; Fri, 6 May 2016 18:01:05 +0200 (CEST) Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga101.jf.intel.com with ESMTP; 06 May 2016 09:01:04 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.24,587,1455004800"; d="scan'208";a="970234445" Received: from unknown (HELO Sent) ([10.217.248.166]) by orsmga002.jf.intel.com with SMTP; 06 May 2016 09:01:01 -0700 Received: by Sent (sSMTP sendmail emulation); Fri, 06 May 2016 18:00:39 +0200 From: Michal Jastrzebski To: dev@dpdk.org Cc: Tomasz Kulasek , Marcin Kerlin , Slawomir Mrozowicz , Michal Kobylinski Date: Fri, 6 May 2016 17:57:29 +0200 Message-Id: <1462550250-1256-6-git-send-email-michalx.k.jastrzebski@intel.com> X-Mailer: git-send-email 2.7.0 In-Reply-To: <1462550250-1256-1-git-send-email-michalx.k.jastrzebski@intel.com> References: <1462550250-1256-1-git-send-email-michalx.k.jastrzebski@intel.com> Subject: [dpdk-dev] [PATCH 5/6] examples/ip_pipeline: modifies flow classifications pipeline CLI X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" This patch modifies flow classifications pipeline command line interface. All commands are merged into one cmd_fc_parsed. Additionally a classification for ipv6, ipv4 and qinq can be added from configuration file. 1. flow add qinq bulk File line format: qinq port id File line example: qinq 1 2 port 3 id 0 2. flow add ipv4 bulk File line format: ipv4 port id File line example: ipv4 1.2.3.4 10.20.30.40 63 127 6 port 2 id 999 3. flow add ipv6 bulk File line format: ipv6 port id Signed-off-by: Tomasz Kulasek Signed-off-by: Marcin Kerlin Signed-off-by: Slawomir Mrozowicz Signed-off-by: Michal Kobylinski --- .../pipeline/pipeline_flow_classification.c | 2066 ++++++++------------ 1 file changed, 849 insertions(+), 1217 deletions(-) diff --git a/examples/ip_pipeline/pipeline/pipeline_flow_classification.c b/examples/ip_pipeline/pipeline/pipeline_flow_classification.c index 1921574..1a74baa 100644 --- a/examples/ip_pipeline/pipeline/pipeline_flow_classification.c +++ b/examples/ip_pipeline/pipeline/pipeline_flow_classification.c @@ -1,7 +1,7 @@ /*- * BSD LICENSE * - * Copyright(c) 2010-2015 Intel Corporation. All rights reserved. + * Copyright(c) 2010-2016 Intel Corporation. All rights reserved. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -35,6 +35,7 @@ #include #include #include +#include #include #include @@ -50,6 +51,13 @@ #include "pipeline_common_fe.h" #include "pipeline_flow_classification.h" #include "hash_func.h" +#include "parser.h" + +#define BUF_SIZE 1024 +#define TOKEN_SIZE 32 +#define IPV4_NUM_OF_TOKENS 10 +#define IPV6_NUM_OF_TOKENS 10 +#define QINQ_NUM_OF_TOKENS 7 /* * Key conversion @@ -82,6 +90,13 @@ struct pkt_key_ipv6_5tuple { uint16_t port_dst; } __attribute__((__packed__)); +struct app_pipeline_add_bulk_params { + struct pipeline_fc_key *keys; + uint32_t n_keys; + uint32_t *port_ids; + uint32_t *flow_ids; +}; + static int app_pipeline_fc_key_convert(struct pipeline_fc_key *key_in, uint8_t *key_out, @@ -277,6 +292,446 @@ app_pipeline_fc_key_check(struct pipeline_fc_key *key) } } +static int +app_pipeline_fc_add_qinq_bulk_parse_file(FILE *file, + struct app_pipeline_add_bulk_params *params) +{ + FILE *f = file; + uint16_t num_value16; + uint32_t i, num_value, ret_tokens, line = 0; + char file_buf[BUF_SIZE]; + char *tokens[QINQ_NUM_OF_TOKENS]; + + ret_tokens = QINQ_NUM_OF_TOKENS; + + i = 0; + while (fgets(file_buf, BUF_SIZE, f) != NULL) { + int status; + uint8_t pos = 0; + + status = parse_tokenize_string(file_buf, tokens, &ret_tokens); + + if (ret_tokens == 0 || tokens[0][0] == '#') { + line++; + ret_tokens = QINQ_NUM_OF_TOKENS; + continue; + } + + if (status != 0 || ret_tokens != QINQ_NUM_OF_TOKENS) { + if (status == -E2BIG) + printf("too many parameters at %d line\n", line + 1); + else if (ret_tokens < QINQ_NUM_OF_TOKENS) + printf("not enough parameters at %d line, " + "missing %d parameters\n", + line + 1, QINQ_NUM_OF_TOKENS - ret_tokens); + else + printf("there was a problem with tokenize at %d line\n", line + 1); + + return -1; + } + + status = strcmp(tokens[pos++], "qinq"); + if (status != 0) { + printf("not found keyword \'qinq\' at line %d.\n", line + 1); + return -1; + } + + status = parser_read_uint16(&num_value16, tokens[pos]); + if (status != 0) { + printf("conversion error svlan: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.qinq.svlan = num_value16; + pos++; + + status = parser_read_uint16(&num_value16, tokens[pos]); + if (status != 0) { + printf("conversion error cvlan: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.qinq.cvlan = num_value16; + pos++; + + status = strcmp(tokens[pos++], "port"); + if (status != 0) { + printf("not found keyword \'port\' at line %d\n", line + 1); + return -1; + } + + status = parser_read_uint32(&num_value, tokens[pos]); + if (status != 0) { + printf("conversion error port id: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->port_ids[i] = num_value; + pos++; + + status = strcmp(tokens[pos++], "id"); + if (status != 0) { + printf("not found keyword \'id\' at line %d\n", line + 1); + return -1; + } + + status = parser_read_uint32(&num_value, tokens[pos]); + if (status != 0) { + printf("conversion error flow id: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->flow_ids[i] = num_value; + + params->keys[i].type = FLOW_KEY_QINQ; + + line++; + i++; + } + + return 0; +} + +static int +app_pipeline_fc_add_ipv4_bulk_parse_file(FILE *file, + struct app_pipeline_add_bulk_params *params) +{ + FILE *f = file; + uint16_t num_value16; + uint32_t i, num_value, ret_tokens, line = 0; + char file_buf[BUF_SIZE]; + char *tokens[IPV4_NUM_OF_TOKENS]; + struct in_addr ipv4; + + ret_tokens = IPV4_NUM_OF_TOKENS; + + i = 0; + while (fgets(file_buf, BUF_SIZE, f) != NULL) { + int status; + uint8_t pos = 0; + + status = parse_tokenize_string(file_buf, tokens, &ret_tokens); + + if (ret_tokens == 0 || tokens[0][0] == '#') { + line++; + ret_tokens = IPV4_NUM_OF_TOKENS; + continue; + } + + if (status != 0 || ret_tokens != IPV4_NUM_OF_TOKENS) { + if (status == -E2BIG) + printf("too many parameters at %d line\n", line + 1); + else if (ret_tokens < QINQ_NUM_OF_TOKENS) + printf("not enough parameters at %d line, " + "missing %d parameters\n", + line + 1, QINQ_NUM_OF_TOKENS - ret_tokens); + else + printf("there was a problem with tokenize at %d line\n", line + 1); + + return -1; + } + + status = strcmp(tokens[pos++], "ipv4"); + if (status != 0) { + printf("not found keyword \'ipv4\' at line %d.\n", line + 1); + return -1; + } + + status = parse_ipv4_addr(tokens[pos], &ipv4); + if (status != 0) { + printf("conversion error src ip: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.ipv4_5tuple.ip_src = + rte_bswap32((uint32_t) ipv4.s_addr); + pos++; + + status = parse_ipv4_addr(tokens[pos], &ipv4); + if (status != 0) { + printf("conversion error dst ip: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.ipv4_5tuple.ip_dst = + rte_bswap32((uint32_t) ipv4.s_addr); + pos++; + + status = parser_read_uint16(&num_value16, tokens[pos]); + if (status != 0) { + printf("conversion error src port: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.ipv4_5tuple.port_src = num_value16; + pos++; + + status = parser_read_uint16(&num_value16, tokens[pos]); + if (status != 0) { + printf("conversion error dst port: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.ipv4_5tuple.port_dst = num_value16; + pos++; + + status = parser_read_uint32(&num_value, tokens[pos]); + if (status != 0) { + printf("conversion error proto: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.ipv4_5tuple.proto = num_value; + pos++; + + status = strcmp(tokens[pos++], "port"); + if (status != 0) { + printf("not found keyword \'port\' at line %d\n", line + 1); + return -1; + } + + status = parser_read_uint32(&num_value, tokens[pos]); + if (status != 0) { + printf("conversion error port id: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->port_ids[i] = num_value; + pos++; + + status = strcmp(tokens[pos++], "id"); + if (status != 0) { + printf("not found keyword \'id\' at line %d\n", line + 1); + return -1; + } + + status = parser_read_uint32(&num_value, tokens[pos]); + if (status != 0) { + printf("conversion error flow id: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->flow_ids[i] = num_value; + + params->keys[i].type = FLOW_KEY_IPV4_5TUPLE; + + line++; + i++; + } + + return 0; +} + +static int +app_pipeline_fc_add_ipv6_bulk_parse_file(FILE *file, + struct app_pipeline_add_bulk_params *params) +{ + FILE *f = file; + uint16_t num_value16; + uint32_t i, num_value, ret_tokens, line = 0; + char file_buf[BUF_SIZE]; + char *tokens[IPV6_NUM_OF_TOKENS]; + struct in6_addr ipv6; + + ret_tokens = IPV6_NUM_OF_TOKENS; + + i = 0; + while (fgets(file_buf, BUF_SIZE, f) != NULL) { + int status; + uint8_t pos = 0; + + status = parse_tokenize_string(file_buf, tokens, &ret_tokens); + + if (ret_tokens == 0 || tokens[0][0] == '#') { + line++; + ret_tokens = IPV6_NUM_OF_TOKENS; + continue; + } + + if (status != 0 || ret_tokens != IPV6_NUM_OF_TOKENS) { + if (status == -E2BIG) + printf("too many parameters at %d line\n", line + 1); + else if (ret_tokens < QINQ_NUM_OF_TOKENS) + printf("not enough parameters at %d line, " + "missing %d parameters\n", + line + 1, QINQ_NUM_OF_TOKENS - ret_tokens); + else + printf("there was a problem with tokenize at %d line\n", line + 1); + + return -1; + } + + status = strcmp(tokens[pos++], "ipv6"); + if (status != 0) { + printf("not found keyword \'ipv6\' at line %d.\n", line + 1); + return -1; + } + + status = parse_ipv6_addr(tokens[pos], &ipv6); + if (status != 0) { + printf("conversion error src ip: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + memcpy(params->keys[i].key.ipv6_5tuple.ip_src, ipv6.s6_addr, + sizeof(ipv6.s6_addr)); + pos++; + + status = parse_ipv6_addr(tokens[pos], &ipv6); + if (status != 0) { + printf("conversion error dst ip: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + memcpy(params->keys[i].key.ipv6_5tuple.ip_dst, ipv6.s6_addr, + sizeof(ipv6.s6_addr)); + pos++; + + status = parser_read_uint16(&num_value16, tokens[pos]); + if (status != 0) { + printf("conversion error src port: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.ipv6_5tuple.port_src = num_value16; + pos++; + + status = parser_read_uint16(&num_value16, tokens[pos]); + if (status != 0) { + printf("conversion error dst port: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.ipv6_5tuple.port_dst = num_value16; + pos++; + + status = parser_read_uint32(&num_value, tokens[pos]); + if (status != 0) { + printf("conversion error proto: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->keys[i].key.ipv6_5tuple.proto = num_value; + pos++; + + status = strcmp(tokens[pos++], "port"); + if (status != 0) { + printf("not found keyword \'port\' at line %d\n", line + 1); + return -1; + } + + status = parser_read_uint32(&num_value, tokens[pos]); + if (status != 0) { + printf("conversion error port id: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->port_ids[i] = num_value; + pos++; + + status = strcmp(tokens[pos++], "id"); + if (status != 0) { + printf("not found keyword \'id\' at line %d\n", line + 1); + return -1; + } + + status = parser_read_uint32(&num_value, tokens[pos]); + if (status != 0) { + printf("conversion error flow id: \'%s\' at line %d\n", + tokens[pos], line + 1); + return -1; + } + params->flow_ids[i] = num_value; + + params->keys[i].type = FLOW_KEY_IPV6_5TUPLE; + + line++; + i++; + } + + return 0; +} + +static int +app_pipeline_fc_add_bulk_parse_file(char *filename, + struct app_pipeline_add_bulk_params *params, enum flow_key_type type) +{ + FILE *file; + int status; + char file_buf[BUF_SIZE]; + + file = fopen(filename, "r"); + if (file == NULL) { + if (getcwd(file_buf, sizeof(file_buf)) != NULL) + printf("not found file %s in the current working dir %s\n", + filename, file_buf); + return -1; + } + + params->n_keys = 0; + while (fgets(file_buf, BUF_SIZE, file) != NULL) + if (file_buf[0] != '\0' && file_buf[0] != '\n' && file_buf[0] != '#') + params->n_keys++; + rewind(file); + + if (params->n_keys == 0) { + printf("not found any keys in the file %s\n", filename); + status = -1; + goto end; + } + + params->keys = rte_malloc(NULL, + params->n_keys * sizeof(struct pipeline_fc_key), + RTE_CACHE_LINE_SIZE); + if (params->keys == NULL) { + printf("out of memory\n"); + status = -1; + goto end; + } + + params->port_ids = rte_malloc(NULL, + params->n_keys * sizeof(uint32_t), + RTE_CACHE_LINE_SIZE); + if (params->port_ids == NULL) { + printf("out of memory\n"); + status = -1; + goto end; + } + + params->flow_ids = rte_malloc(NULL, + params->n_keys * sizeof(uint32_t), + RTE_CACHE_LINE_SIZE); + if (params->flow_ids == NULL) { + printf("out of memory\n"); + status = -1; + goto end; + } + + switch (type) { + case FLOW_KEY_QINQ: + status = app_pipeline_fc_add_qinq_bulk_parse_file(file, params); + break; + case FLOW_KEY_IPV4_5TUPLE: + status = app_pipeline_fc_add_ipv4_bulk_parse_file(file, params); + break; + case FLOW_KEY_IPV6_5TUPLE: + status = app_pipeline_fc_add_ipv6_bulk_parse_file(file, params); + break; + default: + status = -1; + goto end; + } + + if (status != 0) { + status = -1; + goto end; + } + +end: + fclose(file); + return status; +} + int app_pipeline_fc_add(struct app_params *app, uint32_t pipeline_id, @@ -897,1308 +1352,485 @@ app_pipeline_fc_ls(struct app_params *app, return 0; } -/* - * flow add qinq - */ - -struct cmd_fc_add_qinq_result { +struct cmd_fc_parsed_result { cmdline_fixed_string_t p_string; uint32_t pipeline_id; cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t add_string; - cmdline_fixed_string_t qinq_string; - uint16_t svlan; - uint16_t cvlan; - cmdline_fixed_string_t port_string; - uint32_t port; - cmdline_fixed_string_t flowid_string; - uint32_t flow_id; + cmdline_fixed_string_t command_string; }; static void -cmd_fc_add_qinq_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) +cmd_fc_parsed(void *parsed_result, __attribute__((unused)) struct cmdline *cl, + void *data __rte_unused) { - struct cmd_fc_add_qinq_result *params = parsed_result; - struct app_params *app = data; - struct pipeline_fc_key key; int status; - memset(&key, 0, sizeof(key)); - key.type = FLOW_KEY_QINQ; - key.key.qinq.svlan = params->svlan; - key.key.qinq.cvlan = params->cvlan; - - status = app_pipeline_fc_add(app, - params->pipeline_id, - &key, - params->port, - params->flow_id); - if (status != 0) - printf("Command failed\n"); -} - -cmdline_parse_token_string_t cmd_fc_add_qinq_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_result, p_string, "p"); - -cmdline_parse_token_num_t cmd_fc_add_qinq_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_qinq_result, pipeline_id, - UINT32); - -cmdline_parse_token_string_t cmd_fc_add_qinq_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_result, flow_string, - "flow"); - -cmdline_parse_token_string_t cmd_fc_add_qinq_add_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_result, add_string, - "add"); - -cmdline_parse_token_string_t cmd_fc_add_qinq_qinq_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_result, qinq_string, - "qinq"); - -cmdline_parse_token_num_t cmd_fc_add_qinq_svlan = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_qinq_result, svlan, UINT16); - -cmdline_parse_token_num_t cmd_fc_add_qinq_cvlan = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_qinq_result, cvlan, UINT16); - -cmdline_parse_token_string_t cmd_fc_add_qinq_port_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_result, port_string, - "port"); - -cmdline_parse_token_num_t cmd_fc_add_qinq_port = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_qinq_result, port, UINT32); - -cmdline_parse_token_string_t cmd_fc_add_qinq_flowid_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_result, flowid_string, - "flowid"); - -cmdline_parse_token_num_t cmd_fc_add_qinq_flow_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_qinq_result, flow_id, UINT32); - -cmdline_parse_inst_t cmd_fc_add_qinq = { - .f = cmd_fc_add_qinq_parsed, - .data = NULL, - .help_str = "Flow add (Q-in-Q)", - .tokens = { - (void *) &cmd_fc_add_qinq_p_string, - (void *) &cmd_fc_add_qinq_pipeline_id, - (void *) &cmd_fc_add_qinq_flow_string, - (void *) &cmd_fc_add_qinq_add_string, - (void *) &cmd_fc_add_qinq_qinq_string, - (void *) &cmd_fc_add_qinq_svlan, - (void *) &cmd_fc_add_qinq_cvlan, - (void *) &cmd_fc_add_qinq_port_string, - (void *) &cmd_fc_add_qinq_port, - (void *) &cmd_fc_add_qinq_flowid_string, - (void *) &cmd_fc_add_qinq_flow_id, - NULL, - }, -}; - -/* - * flow add qinq all - */ - -struct cmd_fc_add_qinq_all_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t add_string; - cmdline_fixed_string_t qinq_string; - cmdline_fixed_string_t all_string; - uint32_t n_flows; - uint32_t n_ports; -}; - -#ifndef N_FLOWS_BULK -#define N_FLOWS_BULK 4096 -#endif - -static void -cmd_fc_add_qinq_all_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_add_qinq_all_result *params = parsed_result; + uint32_t n_tokens; + char *tokens[256]; + struct pipeline_fc_key key; struct app_params *app = data; - struct pipeline_fc_key *key; - uint32_t *port_id; - uint32_t *flow_id; - uint32_t id; - - /* Check input arguments */ - if (params->n_flows == 0) { - printf("Invalid number of flows\n"); - return; - } + struct cmd_fc_parsed_result *results = + (struct cmd_fc_parsed_result *)parsed_result; - if (params->n_ports == 0) { - printf("Invalid number of output ports\n"); - return; - } + enum flow_key_type type; + uint32_t sport; + uint32_t dport; + uint32_t proto; + uint32_t svlan; + uint32_t cvlan; + uint32_t port_id; + uint32_t flow_id; + struct in_addr sipaddr_ipv4; + struct in_addr dipaddr_ipv4; + struct in6_addr sipaddr_ipv6; + struct in6_addr dipaddr_ipv6; + char *file_name; - /* Memory allocation */ - key = rte_zmalloc(NULL, - N_FLOWS_BULK * sizeof(*key), - RTE_CACHE_LINE_SIZE); - if (key == NULL) { - printf("Memory allocation failed\n"); - return; - } + n_tokens = RTE_DIM(tokens); + status = parse_tokenize_string(results->command_string, tokens, &n_tokens); - port_id = rte_malloc(NULL, - N_FLOWS_BULK * sizeof(*port_id), - RTE_CACHE_LINE_SIZE); - if (port_id == NULL) { - rte_free(key); - printf("Memory allocation failed\n"); + if (status) { + printf("Command \"flow\": Too many tokens\n"); return; } - flow_id = rte_malloc(NULL, - N_FLOWS_BULK * sizeof(*flow_id), - RTE_CACHE_LINE_SIZE); - if (flow_id == NULL) { - rte_free(port_id); - rte_free(key); - printf("Memory allocation failed\n"); + if (n_tokens < 1) { + printf("Not enough parameters for \"flow add|del|ls\"\n"); return; } - /* Flow add */ - for (id = 0; id < params->n_flows; id++) { - uint32_t pos = id & (N_FLOWS_BULK - 1); - - key[pos].type = FLOW_KEY_QINQ; - key[pos].key.qinq.svlan = id >> 12; - key[pos].key.qinq.cvlan = id & 0xFFF; - - port_id[pos] = id % params->n_ports; - flow_id[pos] = id; - - if ((pos == N_FLOWS_BULK - 1) || - (id == params->n_flows - 1)) { - int status; - - status = app_pipeline_fc_add_bulk(app, - params->pipeline_id, - key, - port_id, - flow_id, - pos + 1); + if (strcmp(tokens[0], "add") == 0) { - if (status != 0) { - printf("Command failed\n"); - - break; - } + if (n_tokens < 2) { + printf("Not enough parameters for \"flow add\"\n"); + return; } - } - - /* Memory free */ - rte_free(flow_id); - rte_free(port_id); - rte_free(key); -} - -cmdline_parse_token_string_t cmd_fc_add_qinq_all_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_all_result, p_string, - "p"); - -cmdline_parse_token_num_t cmd_fc_add_qinq_all_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_qinq_all_result, pipeline_id, - UINT32); - -cmdline_parse_token_string_t cmd_fc_add_qinq_all_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_all_result, flow_string, - "flow"); - -cmdline_parse_token_string_t cmd_fc_add_qinq_all_add_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_all_result, add_string, - "add"); -cmdline_parse_token_string_t cmd_fc_add_qinq_all_qinq_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_all_result, qinq_string, - "qinq"); + if (strcmp(tokens[1], "default") == 0) { + /* p flow add default */ -cmdline_parse_token_string_t cmd_fc_add_qinq_all_all_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_qinq_all_result, all_string, - "all"); - -cmdline_parse_token_num_t cmd_fc_add_qinq_all_n_flows = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_qinq_all_result, n_flows, - UINT32); - -cmdline_parse_token_num_t cmd_fc_add_qinq_all_n_ports = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_qinq_all_result, n_ports, - UINT32); - -cmdline_parse_inst_t cmd_fc_add_qinq_all = { - .f = cmd_fc_add_qinq_all_parsed, - .data = NULL, - .help_str = "Flow add all (Q-in-Q)", - .tokens = { - (void *) &cmd_fc_add_qinq_all_p_string, - (void *) &cmd_fc_add_qinq_all_pipeline_id, - (void *) &cmd_fc_add_qinq_all_flow_string, - (void *) &cmd_fc_add_qinq_all_add_string, - (void *) &cmd_fc_add_qinq_all_qinq_string, - (void *) &cmd_fc_add_qinq_all_all_string, - (void *) &cmd_fc_add_qinq_all_n_flows, - (void *) &cmd_fc_add_qinq_all_n_ports, - NULL, - }, -}; - -/* - * flow add ipv4_5tuple - */ - -struct cmd_fc_add_ipv4_5tuple_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t add_string; - cmdline_fixed_string_t ipv4_5tuple_string; - cmdline_ipaddr_t ip_src; - cmdline_ipaddr_t ip_dst; - uint16_t port_src; - uint16_t port_dst; - uint32_t proto; - cmdline_fixed_string_t port_string; - uint32_t port; - cmdline_fixed_string_t flowid_string; - uint32_t flow_id; -}; - -static void -cmd_fc_add_ipv4_5tuple_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_add_ipv4_5tuple_result *params = parsed_result; - struct app_params *app = data; - struct pipeline_fc_key key; - int status; - - memset(&key, 0, sizeof(key)); - key.type = FLOW_KEY_IPV4_5TUPLE; - key.key.ipv4_5tuple.ip_src = rte_bswap32( - params->ip_src.addr.ipv4.s_addr); - key.key.ipv4_5tuple.ip_dst = rte_bswap32( - params->ip_dst.addr.ipv4.s_addr); - key.key.ipv4_5tuple.port_src = params->port_src; - key.key.ipv4_5tuple.port_dst = params->port_dst; - key.key.ipv4_5tuple.proto = params->proto; - - status = app_pipeline_fc_add(app, - params->pipeline_id, - &key, - params->port, - params->flow_id); - if (status != 0) - printf("Command failed\n"); -} - -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, p_string, - "p"); - -cmdline_parse_token_num_t cmd_fc_add_ipv4_5tuple_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, pipeline_id, - UINT32); - -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, - flow_string, "flow"); - -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_add_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, - add_string, "add"); - -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_ipv4_5tuple_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, - ipv4_5tuple_string, "ipv4_5tuple"); - -cmdline_parse_token_ipaddr_t cmd_fc_add_ipv4_5tuple_ip_src = - TOKEN_IPV4_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, ip_src); - -cmdline_parse_token_ipaddr_t cmd_fc_add_ipv4_5tuple_ip_dst = - TOKEN_IPV4_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, ip_dst); + if (n_tokens < 3) { + printf("Not enough parameters for \"flow add default \"\n"); + return; + } -cmdline_parse_token_num_t cmd_fc_add_ipv4_5tuple_port_src = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, port_src, - UINT16); + if (parser_read_uint32(&port_id, tokens[2]) != 0) { + printf("Incorrect format for port id\n"); + return; + } -cmdline_parse_token_num_t cmd_fc_add_ipv4_5tuple_port_dst = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, port_dst, - UINT16); + status = app_pipeline_fc_add_default(app, results->pipeline_id, + port_id); -cmdline_parse_token_num_t cmd_fc_add_ipv4_5tuple_proto = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, proto, - UINT32); + if (status != 0) + printf("Command failed\n"); -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_port_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, port_string, - "port"); + return; -cmdline_parse_token_num_t cmd_fc_add_ipv4_5tuple_port = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, port, - UINT32); + } else { -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_flowid_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, - flowid_string, "flowid"); + if (n_tokens < 3) { + printf("Not enough parameters for \"flow add [ipv4|ipv6|qinq]\"\n"); + return; + } -cmdline_parse_token_num_t cmd_fc_add_ipv4_5tuple_flow_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_result, flow_id, - UINT32); + /* parse key type to add */ + if (strcmp(tokens[1], "qinq") == 0) + type = FLOW_KEY_QINQ; + else if (strcmp(tokens[1], "ipv4") == 0) + type = FLOW_KEY_IPV4_5TUPLE; + else if (strcmp(tokens[1], "ipv6") == 0) + type = FLOW_KEY_IPV6_5TUPLE; + else { + printf("Incorrect key type. Should be qinq, ipv4, ipv6 or default.\n"); + return; + } -cmdline_parse_inst_t cmd_fc_add_ipv4_5tuple = { - .f = cmd_fc_add_ipv4_5tuple_parsed, - .data = NULL, - .help_str = "Flow add (IPv4 5-tuple)", - .tokens = { - (void *) &cmd_fc_add_ipv4_5tuple_p_string, - (void *) &cmd_fc_add_ipv4_5tuple_pipeline_id, - (void *) &cmd_fc_add_ipv4_5tuple_flow_string, - (void *) &cmd_fc_add_ipv4_5tuple_add_string, - (void *) &cmd_fc_add_ipv4_5tuple_ipv4_5tuple_string, - (void *) &cmd_fc_add_ipv4_5tuple_ip_src, - (void *) &cmd_fc_add_ipv4_5tuple_ip_dst, - (void *) &cmd_fc_add_ipv4_5tuple_port_src, - (void *) &cmd_fc_add_ipv4_5tuple_port_dst, - (void *) &cmd_fc_add_ipv4_5tuple_proto, - (void *) &cmd_fc_add_ipv4_5tuple_port_string, - (void *) &cmd_fc_add_ipv4_5tuple_port, - (void *) &cmd_fc_add_ipv4_5tuple_flowid_string, - (void *) &cmd_fc_add_ipv4_5tuple_flow_id, - NULL, - }, -}; + /* check if this is a bulk command */ + if (strcmp(tokens[2], "bulk") == 0) { + /* flow add bulk */ + struct app_pipeline_add_bulk_params params = { 0 }; -/* - * flow add ipv4_5tuple all - */ + file_name = tokens[3]; -struct cmd_fc_add_ipv4_5tuple_all_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t add_string; - cmdline_fixed_string_t ipv4_5tuple_string; - cmdline_fixed_string_t all_string; - uint32_t n_flows; - uint32_t n_ports; -}; + status = app_pipeline_fc_add_bulk_parse_file(file_name, ¶ms, + type); -static void -cmd_fc_add_ipv4_5tuple_all_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_add_ipv4_5tuple_all_result *params = parsed_result; - struct app_params *app = data; - struct pipeline_fc_key *key; - uint32_t *port_id; - uint32_t *flow_id; - uint32_t id; - - /* Check input parameters */ - if (params->n_flows == 0) { - printf("Invalid number of flows\n"); - return; - } + if (status != 0) { + printf("Bulk file parse error\n"); + return; + } - if (params->n_ports == 0) { - printf("Invalid number of ports\n"); - return; - } + /* Flow add */ + status = app_pipeline_fc_add_bulk(app, results->pipeline_id, + params.keys, params.port_ids, params.flow_ids, + params.n_keys); - /* Memory allocation */ - key = rte_zmalloc(NULL, - N_FLOWS_BULK * sizeof(*key), - RTE_CACHE_LINE_SIZE); - if (key == NULL) { - printf("Memory allocation failed\n"); - return; - } + if (status != 0) + printf("Command failed\n"); - port_id = rte_malloc(NULL, - N_FLOWS_BULK * sizeof(*port_id), - RTE_CACHE_LINE_SIZE); - if (port_id == NULL) { - rte_free(key); - printf("Memory allocation failed\n"); - return; - } + /* Memory free */ + rte_free(params.flow_ids); + rte_free(params.port_ids); + rte_free(params.keys); - flow_id = rte_malloc(NULL, - N_FLOWS_BULK * sizeof(*flow_id), - RTE_CACHE_LINE_SIZE); - if (flow_id == NULL) { - rte_free(port_id); - rte_free(key); - printf("Memory allocation failed\n"); - return; - } + return; + } - /* Flow add */ - for (id = 0; id < params->n_flows; id++) { - uint32_t pos = id & (N_FLOWS_BULK - 1); + if (type == FLOW_KEY_QINQ) { + + /* (flow add qinq) port id */ + if (n_tokens < 8) { + printf("Not enough parameters for \"flow add qinq port id \"\n"); + return; + } + + if (parser_read_uint32(&svlan, tokens[2]) != 0) { + printf("Incorrect format for \"svlan\"\n"); + return; + } + + if (parser_read_uint32(&cvlan, tokens[3]) != 0) { + printf("Incorrect format for \"cvlan\"\n"); + return; + } + + if (strcmp(tokens[4], "port") != 0) { + printf("Missed \"port\"\n"); + return; + } + + if (parser_read_uint32(&port_id, tokens[5]) != 0) { + printf("Incorrect format for \"port_id\"\n"); + return; + } + + if (strcmp(tokens[6], "id") != 0) { + printf("Missed \"id\"\n"); + return; + } + + if (parser_read_uint32(&flow_id, tokens[7]) != 0) { + printf("Incorrect parameter format for \"id \"\n"); + return; + } + + } else { + /* ipv4 / ipv6 */ + + if (n_tokens < 11) { + printf("Not enough parameters for \"flow add %s\"\n", + tokens[1]); + return; + } + + /* parse source and destination IP addr dependly on key type */ + if (type == FLOW_KEY_IPV4_5TUPLE) { + if (parse_ipv4_addr(tokens[2], &sipaddr_ipv4) != 0) { + printf("Incorrect format of IPv4 source address\n"); + return; + } + if (parse_ipv4_addr(tokens[3], &dipaddr_ipv4) != 0) { + printf("Incorrect format of IPv4 destination address\n"); + return; + } + + } else if (type == FLOW_KEY_IPV6_5TUPLE) { + if (parse_ipv6_addr(tokens[2], &sipaddr_ipv6) != 0) { + printf("Incorrect format of IPv6 source address\n"); + return; + } + if (parse_ipv6_addr(tokens[3], &dipaddr_ipv6) != 0) { + printf("Incorrect format of IPv6 destination address\n"); + return; + } + } + + if (parser_read_uint32(&sport, tokens[4]) != 0) { + printf("Incorrect format of source port\n"); + return; + } + + if (parser_read_uint32(&dport, tokens[5]) != 0) { + printf("Incorrect format of destination port\n"); + return; + } + + if (parser_read_uint32(&proto, tokens[6]) != 0) { + printf("Incorrect format of proto value\n"); + return; + } + + if (strcmp(tokens[7], "port") != 0) { + printf("Missed port identifier\n"); + return; + } + + if (parser_read_uint32(&port_id, tokens[8]) != 0) { + printf("Incorrect format of port ID\n"); + return; + } + + if (strcmp(tokens[9], "id") != 0) { + printf("Missed id identifier before flow ID\n"); + return; + } + + if (parser_read_uint32(&flow_id, tokens[10]) != 0) { + printf("Incorrect format of flow ID\n"); + return; + } + } - key[pos].type = FLOW_KEY_IPV4_5TUPLE; - key[pos].key.ipv4_5tuple.ip_src = 0; - key[pos].key.ipv4_5tuple.ip_dst = id; - key[pos].key.ipv4_5tuple.port_src = 0; - key[pos].key.ipv4_5tuple.port_dst = 0; - key[pos].key.ipv4_5tuple.proto = 6; + /** + * Fill key structure with parsed values + */ + memset(&key, 0, sizeof(key)); - port_id[pos] = id % params->n_ports; - flow_id[pos] = id; + switch (type) { + case FLOW_KEY_QINQ: /* qinq */ + key.type = FLOW_KEY_QINQ; + key.key.qinq.svlan = svlan; + key.key.qinq.cvlan = cvlan; + break; - if ((pos == N_FLOWS_BULK - 1) || - (id == params->n_flows - 1)) { - int status; + case FLOW_KEY_IPV4_5TUPLE: /* ipv4 */ + key.type = FLOW_KEY_IPV4_5TUPLE; + key.key.ipv4_5tuple.ip_src = rte_bswap32( + sipaddr_ipv4.s_addr); + key.key.ipv4_5tuple.ip_dst = rte_bswap32( + dipaddr_ipv4.s_addr); + key.key.ipv4_5tuple.port_src = sport; + key.key.ipv4_5tuple.port_dst = dport; + key.key.ipv4_5tuple.proto = proto; + break; - status = app_pipeline_fc_add_bulk(app, - params->pipeline_id, - key, - port_id, - flow_id, - pos + 1); + case FLOW_KEY_IPV6_5TUPLE: /* ipv6 */ + key.type = FLOW_KEY_IPV6_5TUPLE; + memcpy(key.key.ipv6_5tuple.ip_src, (void *)&sipaddr_ipv6, 16); + memcpy(key.key.ipv6_5tuple.ip_dst, (void *)&dipaddr_ipv6, 16); + key.key.ipv6_5tuple.port_src = sport; + key.key.ipv6_5tuple.port_dst = dport; + key.key.ipv6_5tuple.proto = proto; + break; + } - if (status != 0) { + status = app_pipeline_fc_add(app, results->pipeline_id, + &key, port_id, flow_id); + if (status != 0) printf("Command failed\n"); - break; - } + return; } } - /* Memory free */ - rte_free(flow_id); - rte_free(port_id); - rte_free(key); -} - -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_all_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_all_result, - p_string, "p"); - -cmdline_parse_token_num_t cmd_fc_add_ipv4_5tuple_all_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_all_result, - pipeline_id, UINT32); - -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_all_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_all_result, - flow_string, "flow"); - -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_all_add_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_all_result, - add_string, "add"); - -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_all_ipv4_5tuple_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_all_result, - ipv4_5tuple_string, "ipv4_5tuple"); - -cmdline_parse_token_string_t cmd_fc_add_ipv4_5tuple_all_all_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_all_result, - all_string, "all"); - -cmdline_parse_token_num_t cmd_fc_add_ipv4_5tuple_all_n_flows = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_all_result, - n_flows, UINT32); - -cmdline_parse_token_num_t cmd_fc_add_ipv4_5tuple_all_n_ports = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv4_5tuple_all_result, - n_ports, UINT32); - -cmdline_parse_inst_t cmd_fc_add_ipv4_5tuple_all = { - .f = cmd_fc_add_ipv4_5tuple_all_parsed, - .data = NULL, - .help_str = "Flow add all (IPv4 5-tuple)", - .tokens = { - (void *) &cmd_fc_add_ipv4_5tuple_all_p_string, - (void *) &cmd_fc_add_ipv4_5tuple_all_pipeline_id, - (void *) &cmd_fc_add_ipv4_5tuple_all_flow_string, - (void *) &cmd_fc_add_ipv4_5tuple_all_add_string, - (void *) &cmd_fc_add_ipv4_5tuple_all_ipv4_5tuple_string, - (void *) &cmd_fc_add_ipv4_5tuple_all_all_string, - (void *) &cmd_fc_add_ipv4_5tuple_all_n_flows, - (void *) &cmd_fc_add_ipv4_5tuple_all_n_ports, - NULL, - }, -}; + if (strcmp(tokens[0], "del") == 0) { + /* ( p flow del ) qinq */ + /* ( p flow del ) ipv4 */ + /* ( p flow del ) ipv6 */ + /* ( p flow del ) default */ -/* - * flow add ipv6_5tuple - */ - -struct cmd_fc_add_ipv6_5tuple_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t add_string; - cmdline_fixed_string_t ipv6_5tuple_string; - cmdline_ipaddr_t ip_src; - cmdline_ipaddr_t ip_dst; - uint16_t port_src; - uint16_t port_dst; - uint32_t proto; - cmdline_fixed_string_t port_string; - uint32_t port; - cmdline_fixed_string_t flowid_string; - uint32_t flow_id; -}; - -static void -cmd_fc_add_ipv6_5tuple_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_add_ipv6_5tuple_result *params = parsed_result; - struct app_params *app = data; - struct pipeline_fc_key key; - int status; - - memset(&key, 0, sizeof(key)); - key.type = FLOW_KEY_IPV6_5TUPLE; - memcpy(key.key.ipv6_5tuple.ip_src, - params->ip_src.addr.ipv6.s6_addr, - 16); - memcpy(key.key.ipv6_5tuple.ip_dst, - params->ip_dst.addr.ipv6.s6_addr, - 16); - key.key.ipv6_5tuple.port_src = params->port_src; - key.key.ipv6_5tuple.port_dst = params->port_dst; - key.key.ipv6_5tuple.proto = params->proto; - - status = app_pipeline_fc_add(app, - params->pipeline_id, - &key, - params->port, - params->flow_id); - if (status != 0) - printf("Command failed\n"); -} - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, - p_string, "p"); - -cmdline_parse_token_num_t cmd_fc_add_ipv6_5tuple_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, pipeline_id, - UINT32); - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, - flow_string, "flow"); - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_add_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, - add_string, "add"); - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_ipv6_5tuple_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, - ipv6_5tuple_string, "ipv6_5tuple"); - -cmdline_parse_token_ipaddr_t cmd_fc_add_ipv6_5tuple_ip_src = - TOKEN_IPV6_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, ip_src); - -cmdline_parse_token_ipaddr_t cmd_fc_add_ipv6_5tuple_ip_dst = - TOKEN_IPV6_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, ip_dst); - -cmdline_parse_token_num_t cmd_fc_add_ipv6_5tuple_port_src = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, port_src, - UINT16); - -cmdline_parse_token_num_t cmd_fc_add_ipv6_5tuple_port_dst = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, port_dst, - UINT16); - -cmdline_parse_token_num_t cmd_fc_add_ipv6_5tuple_proto = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, proto, - UINT32); - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_port_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, - port_string, "port"); - -cmdline_parse_token_num_t cmd_fc_add_ipv6_5tuple_port = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, port, - UINT32); - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_flowid_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, - flowid_string, "flowid"); - -cmdline_parse_token_num_t cmd_fc_add_ipv6_5tuple_flow_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_result, flow_id, - UINT32); - -cmdline_parse_inst_t cmd_fc_add_ipv6_5tuple = { - .f = cmd_fc_add_ipv6_5tuple_parsed, - .data = NULL, - .help_str = "Flow add (IPv6 5-tuple)", - .tokens = { - (void *) &cmd_fc_add_ipv6_5tuple_p_string, - (void *) &cmd_fc_add_ipv6_5tuple_pipeline_id, - (void *) &cmd_fc_add_ipv6_5tuple_flow_string, - (void *) &cmd_fc_add_ipv6_5tuple_add_string, - (void *) &cmd_fc_add_ipv6_5tuple_ipv6_5tuple_string, - (void *) &cmd_fc_add_ipv6_5tuple_ip_src, - (void *) &cmd_fc_add_ipv6_5tuple_ip_dst, - (void *) &cmd_fc_add_ipv6_5tuple_port_src, - (void *) &cmd_fc_add_ipv6_5tuple_port_dst, - (void *) &cmd_fc_add_ipv6_5tuple_proto, - (void *) &cmd_fc_add_ipv6_5tuple_port_string, - (void *) &cmd_fc_add_ipv6_5tuple_port, - (void *) &cmd_fc_add_ipv6_5tuple_flowid_string, - (void *) &cmd_fc_add_ipv6_5tuple_flow_id, - NULL, - }, -}; - -/* - * flow add ipv6_5tuple all - */ + if (n_tokens < 2) { + printf("Not enough parameters for \"flow del\"\n"); + return; + } -struct cmd_fc_add_ipv6_5tuple_all_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t add_string; - cmdline_fixed_string_t ipv6_5tuple_string; - cmdline_fixed_string_t all_string; - uint32_t n_flows; - uint32_t n_ports; -}; + if (strcmp(tokens[1], "default") == 0) { -static void -cmd_fc_add_ipv6_5tuple_all_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_add_ipv6_5tuple_all_result *params = parsed_result; - struct app_params *app = data; - struct pipeline_fc_key *key; - uint32_t *port_id; - uint32_t *flow_id; - uint32_t id; - - /* Check input parameters */ - if (params->n_flows == 0) { - printf("Invalid number of flows\n"); - return; - } - - if (params->n_ports == 0) { - printf("Invalid number of ports\n"); - return; - } + if (n_tokens != 2) { + printf("Incorrect number of parameters for \"flow del default\"\n"); + return; + } - /* Memory allocation */ - key = rte_zmalloc(NULL, - N_FLOWS_BULK * sizeof(*key), - RTE_CACHE_LINE_SIZE); - if (key == NULL) { - printf("Memory allocation failed\n"); - return; - } + status = app_pipeline_fc_del_default(app, results->pipeline_id); + if (status != 0) + printf("Command failed\n"); - port_id = rte_malloc(NULL, - N_FLOWS_BULK * sizeof(*port_id), - RTE_CACHE_LINE_SIZE); - if (port_id == NULL) { - rte_free(key); - printf("Memory allocation failed\n"); - return; - } + return; - flow_id = rte_malloc(NULL, - N_FLOWS_BULK * sizeof(*flow_id), - RTE_CACHE_LINE_SIZE); - if (flow_id == NULL) { - rte_free(port_id); - rte_free(key); - printf("Memory allocation failed\n"); - return; - } + } else { - /* Flow add */ - for (id = 0; id < params->n_flows; id++) { - uint32_t pos = id & (N_FLOWS_BULK - 1); - uint32_t *x; + /* parse key type to delete */ + if (strcmp(tokens[1], "qinq") == 0) + type = FLOW_KEY_QINQ; + else if (strcmp(tokens[1], "ipv4") == 0) + type = FLOW_KEY_IPV4_5TUPLE; + else if (strcmp(tokens[1], "ipv6") == 0) + type = FLOW_KEY_IPV6_5TUPLE; + else { + printf("Unknown key type. Should be qinq, ipv4, ipv6 or default.\n"); + return; + } - key[pos].type = FLOW_KEY_IPV6_5TUPLE; - x = (uint32_t *) key[pos].key.ipv6_5tuple.ip_dst; - *x = rte_bswap32(id); - key[pos].key.ipv6_5tuple.proto = 6; + if (type == FLOW_KEY_QINQ) { + /* Parse arguments for q-in-q deletion */ + + /* flow del qinq */ + + if (n_tokens != 4) { + printf("Incorrect number of parameters for \"flow del qinq \"\n"); + return; + } + + if (parser_read_uint32(&svlan, tokens[2]) != 0) { + printf("Incorrect format of \"svlan\"\n"); + return; + } + + if (parser_read_uint32(&cvlan, tokens[3]) != 0) { + printf("Incorrect format of \"cvlan\"\n"); + return; + } + + } else { + /* Parse arguments for IPv4/IPv6 deletion */ + /* flow del [ipv4|ipv6] */ + + if (n_tokens != 7) { + printf("Incorrect number of parameters for \"flow del\"\n"); + return; + } + + if (type == FLOW_KEY_IPV4_5TUPLE) { + if (parse_ipv4_addr(tokens[2], &sipaddr_ipv4) != 0) { + printf("Incorrect format of IPv4 source address\n"); + return; + } + if (parse_ipv4_addr(tokens[3], &dipaddr_ipv4) != 0) { + printf("Incorrect format of IPv4 destination address\n"); + return; + } + + } else { + if (parse_ipv6_addr(tokens[2], &sipaddr_ipv6) != 0) { + printf("Incorrect format of IPv6 source address\n"); + return; + } + + if (parse_ipv6_addr(tokens[3], &dipaddr_ipv6) != 0) { + printf("Incorrect format of IPv6 source address\n"); + return; + } + } + + if (parser_read_uint32(&sport, tokens[4]) != 0) { + printf("Incorrect format of source port\n"); + return; + } + + if (parser_read_uint32(&dport, tokens[5]) != 0) { + printf("Incorrect format of destination port\n"); + return; + } + + if (parser_read_uint32(&proto, tokens[6]) != 0) { + printf("Incorrect format of proto value\n"); + return; + } + } - port_id[pos] = id % params->n_ports; - flow_id[pos] = id; + /** + * Set a key structure for key type FLOW_KEY_QINQ, + * FLOW_KEY_IPV4_5TUPLE, FLOW_KEY_IPV6_5TUPLE + */ + memset(&key, 0, sizeof(key)); + + switch (type) { + case FLOW_KEY_QINQ: + key.type = FLOW_KEY_QINQ; + key.key.qinq.svlan = svlan; + key.key.qinq.cvlan = cvlan; + break; - if ((pos == N_FLOWS_BULK - 1) || - (id == params->n_flows - 1)) { - int status; + case FLOW_KEY_IPV4_5TUPLE: + key.type = FLOW_KEY_IPV4_5TUPLE; + key.key.ipv4_5tuple.ip_src = rte_bswap32(sipaddr_ipv4.s_addr); + key.key.ipv4_5tuple.ip_dst = rte_bswap32(dipaddr_ipv4.s_addr); + key.key.ipv4_5tuple.port_src = sport; + key.key.ipv4_5tuple.port_dst = dport; + key.key.ipv4_5tuple.proto = proto; + break; - status = app_pipeline_fc_add_bulk(app, - params->pipeline_id, - key, - port_id, - flow_id, - pos + 1); + case FLOW_KEY_IPV6_5TUPLE: + key.type = FLOW_KEY_IPV6_5TUPLE; + memcpy(key.key.ipv6_5tuple.ip_src, &sipaddr_ipv6, 16); + memcpy(key.key.ipv6_5tuple.ip_dst, &dipaddr_ipv6, 16); + key.key.ipv6_5tuple.port_src = sport; + key.key.ipv6_5tuple.port_dst = dport; + key.key.ipv6_5tuple.proto = proto; + } - if (status != 0) { + status = app_pipeline_fc_del(app, results->pipeline_id, &key); + if (status != 0) printf("Command failed\n"); - break; - } + return; } } - /* Memory free */ - rte_free(flow_id); - rte_free(port_id); - rte_free(key); -} - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_all_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_all_result, - p_string, "p"); - -cmdline_parse_token_num_t cmd_fc_add_ipv6_5tuple_all_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_all_result, - pipeline_id, UINT32); - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_all_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_all_result, - flow_string, "flow"); - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_all_add_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_all_result, - add_string, "add"); - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_all_ipv6_5tuple_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_all_result, - ipv6_5tuple_string, "ipv6_5tuple"); - -cmdline_parse_token_string_t cmd_fc_add_ipv6_5tuple_all_all_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_all_result, - all_string, "all"); - -cmdline_parse_token_num_t cmd_fc_add_ipv6_5tuple_all_n_flows = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_all_result, - n_flows, UINT32); - -cmdline_parse_token_num_t cmd_fc_add_ipv6_5tuple_all_n_ports = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_ipv6_5tuple_all_result, - n_ports, UINT32); - -cmdline_parse_inst_t cmd_fc_add_ipv6_5tuple_all = { - .f = cmd_fc_add_ipv6_5tuple_all_parsed, - .data = NULL, - .help_str = "Flow add all (ipv6 5-tuple)", - .tokens = { - (void *) &cmd_fc_add_ipv6_5tuple_all_p_string, - (void *) &cmd_fc_add_ipv6_5tuple_all_pipeline_id, - (void *) &cmd_fc_add_ipv6_5tuple_all_flow_string, - (void *) &cmd_fc_add_ipv6_5tuple_all_add_string, - (void *) &cmd_fc_add_ipv6_5tuple_all_ipv6_5tuple_string, - (void *) &cmd_fc_add_ipv6_5tuple_all_all_string, - (void *) &cmd_fc_add_ipv6_5tuple_all_n_flows, - (void *) &cmd_fc_add_ipv6_5tuple_all_n_ports, - NULL, - }, -}; - -/* - * flow del qinq - */ -struct cmd_fc_del_qinq_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t del_string; - cmdline_fixed_string_t qinq_string; - uint16_t svlan; - uint16_t cvlan; -}; - -static void -cmd_fc_del_qinq_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_del_qinq_result *params = parsed_result; - struct app_params *app = data; - struct pipeline_fc_key key; - int status; - - memset(&key, 0, sizeof(key)); - key.type = FLOW_KEY_QINQ; - key.key.qinq.svlan = params->svlan; - key.key.qinq.cvlan = params->cvlan; - status = app_pipeline_fc_del(app, params->pipeline_id, &key); - - if (status != 0) - printf("Command failed\n"); -} - -cmdline_parse_token_string_t cmd_fc_del_qinq_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_qinq_result, p_string, "p"); - -cmdline_parse_token_num_t cmd_fc_del_qinq_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_qinq_result, pipeline_id, - UINT32); - -cmdline_parse_token_string_t cmd_fc_del_qinq_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_qinq_result, flow_string, - "flow"); - -cmdline_parse_token_string_t cmd_fc_del_qinq_del_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_qinq_result, del_string, - "del"); - -cmdline_parse_token_string_t cmd_fc_del_qinq_qinq_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_qinq_result, qinq_string, - "qinq"); - -cmdline_parse_token_num_t cmd_fc_del_qinq_svlan = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_qinq_result, svlan, UINT16); - -cmdline_parse_token_num_t cmd_fc_del_qinq_cvlan = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_qinq_result, cvlan, UINT16); - -cmdline_parse_inst_t cmd_fc_del_qinq = { - .f = cmd_fc_del_qinq_parsed, - .data = NULL, - .help_str = "Flow delete (Q-in-Q)", - .tokens = { - (void *) &cmd_fc_del_qinq_p_string, - (void *) &cmd_fc_del_qinq_pipeline_id, - (void *) &cmd_fc_del_qinq_flow_string, - (void *) &cmd_fc_del_qinq_del_string, - (void *) &cmd_fc_del_qinq_qinq_string, - (void *) &cmd_fc_del_qinq_svlan, - (void *) &cmd_fc_del_qinq_cvlan, - NULL, - }, -}; - -/* - * flow del ipv4_5tuple - */ - -struct cmd_fc_del_ipv4_5tuple_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t del_string; - cmdline_fixed_string_t ipv4_5tuple_string; - cmdline_ipaddr_t ip_src; - cmdline_ipaddr_t ip_dst; - uint16_t port_src; - uint16_t port_dst; - uint32_t proto; -}; - -static void -cmd_fc_del_ipv4_5tuple_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_del_ipv4_5tuple_result *params = parsed_result; - struct app_params *app = data; - struct pipeline_fc_key key; - int status; - - memset(&key, 0, sizeof(key)); - key.type = FLOW_KEY_IPV4_5TUPLE; - key.key.ipv4_5tuple.ip_src = rte_bswap32( - params->ip_src.addr.ipv4.s_addr); - key.key.ipv4_5tuple.ip_dst = rte_bswap32( - params->ip_dst.addr.ipv4.s_addr); - key.key.ipv4_5tuple.port_src = params->port_src; - key.key.ipv4_5tuple.port_dst = params->port_dst; - key.key.ipv4_5tuple.proto = params->proto; - - status = app_pipeline_fc_del(app, params->pipeline_id, &key); - if (status != 0) - printf("Command failed\n"); -} - -cmdline_parse_token_string_t cmd_fc_del_ipv4_5tuple_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, - p_string, "p"); - -cmdline_parse_token_num_t cmd_fc_del_ipv4_5tuple_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, - pipeline_id, UINT32); - -cmdline_parse_token_string_t cmd_fc_del_ipv4_5tuple_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, - flow_string, "flow"); - -cmdline_parse_token_string_t cmd_fc_del_ipv4_5tuple_del_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, - del_string, "del"); - -cmdline_parse_token_string_t cmd_fc_del_ipv4_5tuple_ipv4_5tuple_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, - ipv4_5tuple_string, "ipv4_5tuple"); - -cmdline_parse_token_ipaddr_t cmd_fc_del_ipv4_5tuple_ip_src = - TOKEN_IPV4_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, - ip_src); - -cmdline_parse_token_ipaddr_t cmd_fc_del_ipv4_5tuple_ip_dst = - TOKEN_IPV4_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, ip_dst); - -cmdline_parse_token_num_t cmd_fc_del_ipv4_5tuple_port_src = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, - port_src, UINT16); - -cmdline_parse_token_num_t cmd_fc_del_ipv4_5tuple_port_dst = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, - port_dst, UINT16); - -cmdline_parse_token_num_t cmd_fc_del_ipv4_5tuple_proto = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_ipv4_5tuple_result, - proto, UINT32); - -cmdline_parse_inst_t cmd_fc_del_ipv4_5tuple = { - .f = cmd_fc_del_ipv4_5tuple_parsed, - .data = NULL, - .help_str = "Flow delete (IPv4 5-tuple)", - .tokens = { - (void *) &cmd_fc_del_ipv4_5tuple_p_string, - (void *) &cmd_fc_del_ipv4_5tuple_pipeline_id, - (void *) &cmd_fc_del_ipv4_5tuple_flow_string, - (void *) &cmd_fc_del_ipv4_5tuple_del_string, - (void *) &cmd_fc_del_ipv4_5tuple_ipv4_5tuple_string, - (void *) &cmd_fc_del_ipv4_5tuple_ip_src, - (void *) &cmd_fc_del_ipv4_5tuple_ip_dst, - (void *) &cmd_fc_del_ipv4_5tuple_port_src, - (void *) &cmd_fc_del_ipv4_5tuple_port_dst, - (void *) &cmd_fc_del_ipv4_5tuple_proto, - NULL, - }, -}; - -/* - * flow del ipv6_5tuple - */ - -struct cmd_fc_del_ipv6_5tuple_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t del_string; - cmdline_fixed_string_t ipv6_5tuple_string; - cmdline_ipaddr_t ip_src; - cmdline_ipaddr_t ip_dst; - uint16_t port_src; - uint16_t port_dst; - uint32_t proto; -}; - -static void -cmd_fc_del_ipv6_5tuple_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_del_ipv6_5tuple_result *params = parsed_result; - struct app_params *app = data; - struct pipeline_fc_key key; - int status; - - memset(&key, 0, sizeof(key)); - key.type = FLOW_KEY_IPV6_5TUPLE; - memcpy(key.key.ipv6_5tuple.ip_src, - params->ip_src.addr.ipv6.s6_addr, - 16); - memcpy(key.key.ipv6_5tuple.ip_dst, - params->ip_dst.addr.ipv6.s6_addr, - 16); - key.key.ipv6_5tuple.port_src = params->port_src; - key.key.ipv6_5tuple.port_dst = params->port_dst; - key.key.ipv6_5tuple.proto = params->proto; - - status = app_pipeline_fc_del(app, params->pipeline_id, &key); - if (status != 0) - printf("Command failed\n"); -} - -cmdline_parse_token_string_t cmd_fc_del_ipv6_5tuple_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, - p_string, "p"); - -cmdline_parse_token_num_t cmd_fc_del_ipv6_5tuple_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, - pipeline_id, UINT32); - -cmdline_parse_token_string_t cmd_fc_del_ipv6_5tuple_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, - flow_string, "flow"); - -cmdline_parse_token_string_t cmd_fc_del_ipv6_5tuple_del_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, - del_string, "del"); - -cmdline_parse_token_string_t cmd_fc_del_ipv6_5tuple_ipv6_5tuple_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, - ipv6_5tuple_string, "ipv6_5tuple"); - -cmdline_parse_token_ipaddr_t cmd_fc_del_ipv6_5tuple_ip_src = - TOKEN_IPV6_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, ip_src); - -cmdline_parse_token_ipaddr_t cmd_fc_del_ipv6_5tuple_ip_dst = - TOKEN_IPV6_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, ip_dst); - -cmdline_parse_token_num_t cmd_fc_del_ipv6_5tuple_port_src = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, port_src, - UINT16); - -cmdline_parse_token_num_t cmd_fc_del_ipv6_5tuple_port_dst = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, port_dst, - UINT16); - -cmdline_parse_token_num_t cmd_fc_del_ipv6_5tuple_proto = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_ipv6_5tuple_result, proto, - UINT32); - -cmdline_parse_inst_t cmd_fc_del_ipv6_5tuple = { - .f = cmd_fc_del_ipv6_5tuple_parsed, - .data = NULL, - .help_str = "Flow delete (IPv6 5-tuple)", - .tokens = { - (void *) &cmd_fc_del_ipv6_5tuple_p_string, - (void *) &cmd_fc_del_ipv6_5tuple_pipeline_id, - (void *) &cmd_fc_del_ipv6_5tuple_flow_string, - (void *) &cmd_fc_del_ipv6_5tuple_del_string, - (void *) &cmd_fc_del_ipv6_5tuple_ipv6_5tuple_string, - (void *) &cmd_fc_del_ipv6_5tuple_ip_src, - (void *) &cmd_fc_del_ipv6_5tuple_ip_dst, - (void *) &cmd_fc_del_ipv6_5tuple_port_src, - (void *) &cmd_fc_del_ipv6_5tuple_port_dst, - (void *) &cmd_fc_del_ipv6_5tuple_proto, - NULL, - }, -}; - -/* - * flow add default - */ - -struct cmd_fc_add_default_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t add_string; - cmdline_fixed_string_t default_string; - uint32_t port; -}; - -static void -cmd_fc_add_default_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_add_default_result *params = parsed_result; - struct app_params *app = data; - int status; - - status = app_pipeline_fc_add_default(app, params->pipeline_id, - params->port); + if (strcmp(tokens[0], "ls") == 0) { + /* p flow ls */ - if (status != 0) - printf("Command failed\n"); -} - -cmdline_parse_token_string_t cmd_fc_add_default_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_default_result, p_string, - "p"); - -cmdline_parse_token_num_t cmd_fc_add_default_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_default_result, pipeline_id, - UINT32); - -cmdline_parse_token_string_t cmd_fc_add_default_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_default_result, flow_string, - "flow"); - -cmdline_parse_token_string_t cmd_fc_add_default_add_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_default_result, add_string, - "add"); - -cmdline_parse_token_string_t cmd_fc_add_default_default_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_add_default_result, - default_string, "default"); - -cmdline_parse_token_num_t cmd_fc_add_default_port = - TOKEN_NUM_INITIALIZER(struct cmd_fc_add_default_result, port, UINT32); + if (n_tokens != 1) { + printf("Incorrect number of parameters for \"flow ls\"\n"); + return; + } -cmdline_parse_inst_t cmd_fc_add_default = { - .f = cmd_fc_add_default_parsed, - .data = NULL, - .help_str = "Flow add default", - .tokens = { - (void *) &cmd_fc_add_default_p_string, - (void *) &cmd_fc_add_default_pipeline_id, - (void *) &cmd_fc_add_default_flow_string, - (void *) &cmd_fc_add_default_add_string, - (void *) &cmd_fc_add_default_default_string, - (void *) &cmd_fc_add_default_port, - NULL, - }, -}; + status = app_pipeline_fc_ls(app, results->pipeline_id); + if (status != 0) + printf("Command failed\n"); -/* - * flow del default - */ + return; -struct cmd_fc_del_default_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t del_string; - cmdline_fixed_string_t default_string; -}; + } -static void -cmd_fc_del_default_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - void *data) -{ - struct cmd_fc_del_default_result *params = parsed_result; - struct app_params *app = data; - int status; + printf("Incorrect command. Should be \"flow (add|del|ls) ...\"\n"); + return; - status = app_pipeline_fc_del_default(app, params->pipeline_id); - if (status != 0) - printf("Command failed\n"); } -cmdline_parse_token_string_t cmd_fc_del_default_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_default_result, p_string, - "p"); - -cmdline_parse_token_num_t cmd_fc_del_default_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_del_default_result, pipeline_id, - UINT32); - -cmdline_parse_token_string_t cmd_fc_del_default_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_default_result, flow_string, - "flow"); - -cmdline_parse_token_string_t cmd_fc_del_default_del_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_default_result, del_string, - "del"); - -cmdline_parse_token_string_t cmd_fc_del_default_default_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_del_default_result, - default_string, "default"); - -cmdline_parse_inst_t cmd_fc_del_default = { - .f = cmd_fc_del_default_parsed, - .data = NULL, - .help_str = "Flow delete default", - .tokens = { - (void *) &cmd_fc_del_default_p_string, - (void *) &cmd_fc_del_default_pipeline_id, - (void *) &cmd_fc_del_default_flow_string, - (void *) &cmd_fc_del_default_del_string, - (void *) &cmd_fc_del_default_default_string, - NULL, - }, -}; - -/* - * flow ls - */ - -struct cmd_fc_ls_result { - cmdline_fixed_string_t p_string; - uint32_t pipeline_id; - cmdline_fixed_string_t flow_string; - cmdline_fixed_string_t ls_string; -}; - -static void -cmd_fc_ls_parsed( - void *parsed_result, - __attribute__((unused)) struct cmdline *cl, - void *data) -{ - struct cmd_fc_ls_result *params = parsed_result; - struct app_params *app = data; - int status; - - status = app_pipeline_fc_ls(app, params->pipeline_id); - if (status != 0) - printf("Command failed\n"); -} -cmdline_parse_token_string_t cmd_fc_ls_p_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_ls_result, p_string, "p"); +cmdline_parse_token_string_t cmd_fc_parsed_p_string = + TOKEN_STRING_INITIALIZER(struct cmd_fc_parsed_result, p_string, "p"); -cmdline_parse_token_num_t cmd_fc_ls_pipeline_id = - TOKEN_NUM_INITIALIZER(struct cmd_fc_ls_result, pipeline_id, UINT32); +cmdline_parse_token_num_t cmd_fc_parsed_pipeline_id = + TOKEN_NUM_INITIALIZER(struct cmd_fc_parsed_result, pipeline_id, UINT32); -cmdline_parse_token_string_t cmd_fc_ls_flow_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_ls_result, - flow_string, "flow"); +cmdline_parse_token_string_t cmd_fc_parsed_flow_string = + TOKEN_STRING_INITIALIZER(struct cmd_fc_parsed_result, flow_string, "flow"); -cmdline_parse_token_string_t cmd_fc_ls_ls_string = - TOKEN_STRING_INITIALIZER(struct cmd_fc_ls_result, ls_string, - "ls"); +cmdline_parse_token_string_t cmd_fc_parsed_command_string = + TOKEN_STRING_INITIALIZER(struct cmd_fc_parsed_result, command_string, + TOKEN_STRING_MULTI); -cmdline_parse_inst_t cmd_fc_ls = { - .f = cmd_fc_ls_parsed, +/* One command to rule them all */ +cmdline_parse_inst_t cmd_fc_parsed_all = { + .f = cmd_fc_parsed, .data = NULL, - .help_str = "Flow list", + .help_str = + "\n add qinq port id : Flow add (Q-in-Q)" + "\n add qinq bulk : Flow add bulk (Q-in-Q)" + "\n add ipv4 port id : Flow add (IPv4 5-tuple)" + "\n add ipv4 bulk : Flow add bulk (IPv4 5-tuple)" + "\n add ipv6 port id : Flow add (IPv6 5-tuple)" + "\n add ipv6 bulk : Flow add bulk (IPv6 5-tuple)" + "\n add default : Flow add default" + "\n del qinq : Flow delete (Q-in-Q)" + "\n del ipv4 : Flow delete (IPv4 5-tuple)" + "\n del ipv6 : Flow delete (IPv6 5-tuple)" + "\n del default : Flow delete default" + "\n ls : Flow list", .tokens = { - (void *) &cmd_fc_ls_p_string, - (void *) &cmd_fc_ls_pipeline_id, - (void *) &cmd_fc_ls_flow_string, - (void *) &cmd_fc_ls_ls_string, + (void *) &cmd_fc_parsed_p_string, + (void *) &cmd_fc_parsed_pipeline_id, + (void *) &cmd_fc_parsed_flow_string, + (void *) &cmd_fc_parsed_command_string, NULL, }, }; static cmdline_parse_ctx_t pipeline_cmds[] = { - (cmdline_parse_inst_t *) &cmd_fc_add_qinq, - (cmdline_parse_inst_t *) &cmd_fc_add_ipv4_5tuple, - (cmdline_parse_inst_t *) &cmd_fc_add_ipv6_5tuple, - - (cmdline_parse_inst_t *) &cmd_fc_del_qinq, - (cmdline_parse_inst_t *) &cmd_fc_del_ipv4_5tuple, - (cmdline_parse_inst_t *) &cmd_fc_del_ipv6_5tuple, - - (cmdline_parse_inst_t *) &cmd_fc_add_default, - (cmdline_parse_inst_t *) &cmd_fc_del_default, - - (cmdline_parse_inst_t *) &cmd_fc_add_qinq_all, - (cmdline_parse_inst_t *) &cmd_fc_add_ipv4_5tuple_all, - (cmdline_parse_inst_t *) &cmd_fc_add_ipv6_5tuple_all, - - (cmdline_parse_inst_t *) &cmd_fc_ls, + (cmdline_parse_inst_t *) &cmd_fc_parsed_all, NULL, };