X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline.c;h=0f81462e34b263ebd674c84d5ef32a6ea945148b;hb=1a572499beb69fbf4467dcf5cc0a870f580c0081;hp=a15cbf2d7cd9aabc6e3ef76b961bac531944aded;hpb=ff708facfcbf42f3dcb3c62d82ecd93e7b8c2506;p=dpdk.git diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index a15cbf2d7c..0f81462e34 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -1,7 +1,7 @@ /*- * BSD LICENSE * - * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. + * Copyright(c) 2010-2015 Intel Corporation. All rights reserved. * Copyright(c) 2014 6WIND S.A. * All rights reserved. * @@ -84,7 +84,6 @@ #include #include #include -#include #ifdef RTE_LIBRTE_PMD_BOND #include #endif @@ -191,7 +190,9 @@ static void cmd_help_long_parsed(void *parsed_result, " by masks on port X. size is used to indicate the" " hardware supported reta size\n\n" - "show port rss-hash [key]\n" + "show port rss-hash ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|" + "ipv4-sctp|ipv4-other|ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|" + "ipv6-other|l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex [key]\n" " Display the RSS hash functions and RSS hash key" " of port X\n\n" @@ -304,9 +305,9 @@ static void cmd_help_long_parsed(void *parsed_result, "rx_vxlan_port rm (udp_port) (port_id)\n" " Remove an UDP port for VXLAN packet filter on a port\n\n" - "tx_vlan set vlan_id (port_id)\n" - " Set hardware insertion of VLAN ID in packets sent" - " on a port.\n\n" + "tx_vlan set (port_id) vlan_id[, vlan_id_outer]\n" + " Set hardware insertion of VLAN IDs (single or double VLAN " + "depends on the number of VLAN IDs) in packets sent on a port.\n\n" "tx_vlan set pvid port_id vlan_id (on|off)\n" " Set port based TX VLAN insertion.\n\n" @@ -317,7 +318,7 @@ static void cmd_help_long_parsed(void *parsed_result, "csum set (ip|udp|tcp|sctp|outer-ip) (hw|sw) (port_id)\n" " Select hardware or software calculation of the" - " checksum with when transmitting a packet using the" + " checksum when transmitting a packet using the" " csum forward engine.\n" " ip|udp|tcp|sctp always concern the inner layer.\n" " outer-ip concerns the outer IP layer in" @@ -412,7 +413,7 @@ static void cmd_help_long_parsed(void *parsed_result, " Set rate limit for queues in VF of a port\n\n" "set port (port_id) mirror-rule (rule_id)" - "(pool-mirror|vlan-mirror)\n" + " (pool-mirror-up|pool-mirror-down|vlan-mirror)" " (poolmask|vlanid[,vlanid]*) dst-pool (pool_id) (on|off)\n" " Set pool or vlan type mirror rule on a port.\n" " e.g., 'set port 0 mirror-rule 0 vlan-mirror 0,1" @@ -652,6 +653,12 @@ static void cmd_help_long_parsed(void *parsed_result, " queue (queue_id) fd_id (fd_id_value)\n" " Add/Del a SCTP type flow director filter.\n\n" + "flow_director_filter (port_id) (add|del|update)" + " flow l2_payload ether (ethertype)" + " flexbytes (flexbytes_value) (drop|fwd)" + " queue (queue_id) fd_id (fd_id_value)\n" + " Add/Del a l2 payload type flow director filter.\n\n" + "flush_flow_director (port_id)\n" " Flush all flow director entries of a device.\n\n" @@ -661,9 +668,8 @@ static void cmd_help_long_parsed(void *parsed_result, " Set flow director mask.\n\n" "flow_director_flex_mask (port_id)" - " flow (raw|ip4|ip4-frag|tcp4|udp4|sctp4|ip6|ip6-frag|tcp6|udp6|sctp6|all)" - " flow (raw|ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|" - "ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|all)" + " flow (none|ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|" + "ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|l2_payload|all)" " (mask)\n" " Configure mask of flex payload.\n\n" @@ -1494,6 +1500,7 @@ struct cmd_config_rss_hash_key { cmdline_fixed_string_t config; uint8_t port_id; cmdline_fixed_string_t rss_hash_key; + cmdline_fixed_string_t rss_type; cmdline_fixed_string_t key; }; @@ -1551,7 +1558,8 @@ cmd_config_rss_hash_key_parsed(void *parsed_result, return; hash_key[i] = (uint8_t) ((xdgt0 * 16) + xdgt1); } - port_rss_hash_key_update(res->port_id, hash_key); + port_rss_hash_key_update(res->port_id, res->rss_type, hash_key, + RSS_HASH_KEY_LENGTH); } cmdline_parse_token_string_t cmd_config_rss_hash_key_port = @@ -1564,18 +1572,29 @@ cmdline_parse_token_num_t cmd_config_rss_hash_key_port_id = cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_hash_key = TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, rss_hash_key, "rss-hash-key"); +cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_type = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, rss_type, + "ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#" + "ipv4-other#ipv6#ipv6-frag#ipv6-tcp#ipv6-udp#" + "ipv6-sctp#ipv6-other#l2-payload#ipv6-ex#" + "ipv6-tcp-ex#ipv6-udp-ex"); cmdline_parse_token_string_t cmd_config_rss_hash_key_value = TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL); cmdline_parse_inst_t cmd_config_rss_hash_key = { .f = cmd_config_rss_hash_key_parsed, .data = NULL, - .help_str = "port config X rss-hash-key 80 hexa digits", + .help_str = + "port config X rss-hash-key ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|" + "ipv4-sctp|ipv4-other|ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|" + "ipv6-sctp|ipv6-other|l2-payload|" + "ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex 80 hexa digits\n", .tokens = { (void *)&cmd_config_rss_hash_key_port, (void *)&cmd_config_rss_hash_key_config, (void *)&cmd_config_rss_hash_key_port_id, (void *)&cmd_config_rss_hash_key_rss_hash_key, + (void *)&cmd_config_rss_hash_key_rss_type, (void *)&cmd_config_rss_hash_key_value, NULL, }, @@ -1925,6 +1944,7 @@ struct cmd_showport_rss_hash { cmdline_fixed_string_t port; uint8_t port_id; cmdline_fixed_string_t rss_hash; + cmdline_fixed_string_t rss_type; cmdline_fixed_string_t key; /* optional argument */ }; @@ -1934,7 +1954,8 @@ static void cmd_showport_rss_hash_parsed(void *parsed_result, { struct cmd_showport_rss_hash *res = parsed_result; - port_rss_hash_conf_show(res->port_id, show_rss_key != NULL); + port_rss_hash_conf_show(res->port_id, res->rss_type, + show_rss_key != NULL); } cmdline_parse_token_string_t cmd_showport_rss_hash_show = @@ -1946,18 +1967,29 @@ cmdline_parse_token_num_t cmd_showport_rss_hash_port_id = cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash = TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_hash, "rss-hash"); +cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash_info = + TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_type, + "ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#" + "ipv4-other#ipv6#ipv6-frag#ipv6-tcp#ipv6-udp#" + "ipv6-sctp#ipv6-other#l2-payload#ipv6-ex#" + "ipv6-tcp-ex#ipv6-udp-ex"); cmdline_parse_token_string_t cmd_showport_rss_hash_rss_key = TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, key, "key"); cmdline_parse_inst_t cmd_showport_rss_hash = { .f = cmd_showport_rss_hash_parsed, .data = NULL, - .help_str = "show port X rss-hash (X = port number)\n", + .help_str = + "show port X rss-hash ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|" + "ipv4-sctp|ipv4-other|ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|" + "ipv6-sctp|ipv6-other|l2-payload|" + "ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex (X = port number)\n", .tokens = { (void *)&cmd_showport_rss_hash_show, (void *)&cmd_showport_rss_hash_port, (void *)&cmd_showport_rss_hash_port_id, (void *)&cmd_showport_rss_hash_rss_hash, + (void *)&cmd_showport_rss_hash_rss_hash_info, NULL, }, }; @@ -1965,12 +1997,17 @@ cmdline_parse_inst_t cmd_showport_rss_hash = { cmdline_parse_inst_t cmd_showport_rss_hash_key = { .f = cmd_showport_rss_hash_parsed, .data = (void *)1, - .help_str = "show port X rss-hash key (X = port number)\n", + .help_str = + "show port X rss-hash ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|" + "ipv4-sctp|ipv4-other|ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|" + "ipv6-sctp|ipv6-other|l2-payload|" + "ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex key (X = port number)\n", .tokens = { (void *)&cmd_showport_rss_hash_show, (void *)&cmd_showport_rss_hash_port, (void *)&cmd_showport_rss_hash_port_id, (void *)&cmd_showport_rss_hash_rss_hash, + (void *)&cmd_showport_rss_hash_rss_hash_info, (void *)&cmd_showport_rss_hash_rss_key, NULL, }, @@ -1995,37 +2032,46 @@ cmd_config_dcb_parsed(void *parsed_result, __attribute__((unused)) void *data) { struct cmd_config_dcb *res = parsed_result; - struct dcb_config dcb_conf; portid_t port_id = res->port_id; struct rte_port *port; + uint8_t pfc_en; + int ret; port = &ports[port_id]; /** Check if the port is not started **/ if (port->port_status != RTE_PORT_STOPPED) { - printf("Please stop port %d first\n",port_id); + printf("Please stop port %d first\n", port_id); return; } - dcb_conf.num_tcs = (enum rte_eth_nb_tcs) res->num_tcs; - if ((dcb_conf.num_tcs != ETH_4_TCS) && (dcb_conf.num_tcs != ETH_8_TCS)){ - printf("The invalid number of traffic class,only 4 or 8 allowed\n"); + if ((res->num_tcs != ETH_4_TCS) && (res->num_tcs != ETH_8_TCS)) { + printf("The invalid number of traffic class," + " only 4 or 8 allowed.\n"); return; } - /* DCB in VT mode */ - if (!strncmp(res->vt_en, "on",2)) - dcb_conf.dcb_mode = DCB_VT_ENABLED; + if (nb_fwd_lcores < res->num_tcs) { + printf("nb_cores shouldn't be less than number of TCs.\n"); + return; + } + if (!strncmp(res->pfc_en, "on", 2)) + pfc_en = 1; else - dcb_conf.dcb_mode = DCB_ENABLED; + pfc_en = 0; - if (!strncmp(res->pfc_en, "on",2)) { - dcb_conf.pfc_en = 1; - } + /* DCB in VT mode */ + if (!strncmp(res->vt_en, "on", 2)) + ret = init_port_dcb_config(port_id, DCB_VT_ENABLED, + (enum rte_eth_nb_tcs)res->num_tcs, + pfc_en); else - dcb_conf.pfc_en = 0; + ret = init_port_dcb_config(port_id, DCB_ENABLED, + (enum rte_eth_nb_tcs)res->num_tcs, + pfc_en); - if (init_port_dcb_config(port_id,&dcb_conf) != 0) { - printf("Cannot initialize network ports\n"); + + if (ret != 0) { + printf("Cannot initialize network ports.\n"); return; } @@ -2800,8 +2846,8 @@ cmdline_parse_inst_t cmd_rx_vlan_filter = { struct cmd_tx_vlan_set_result { cmdline_fixed_string_t tx_vlan; cmdline_fixed_string_t set; - uint16_t vlan_id; uint8_t port_id; + uint16_t vlan_id; }; static void @@ -2810,6 +2856,13 @@ cmd_tx_vlan_set_parsed(void *parsed_result, __attribute__((unused)) void *data) { struct cmd_tx_vlan_set_result *res = parsed_result; + int vlan_offload = rte_eth_dev_get_vlan_offload(res->port_id); + + if (vlan_offload & ETH_VLAN_EXTEND_OFFLOAD) { + printf("Error, as QinQ has been enabled.\n"); + return; + } + tx_vlan_set(res->port_id, res->vlan_id); } @@ -2829,13 +2882,69 @@ cmdline_parse_token_num_t cmd_tx_vlan_set_portid = cmdline_parse_inst_t cmd_tx_vlan_set = { .f = cmd_tx_vlan_set_parsed, .data = NULL, - .help_str = "enable hardware insertion of a VLAN header with a given " - "TAG Identifier in packets sent on a port", + .help_str = "enable hardware insertion of a single VLAN header " + "with a given TAG Identifier in packets sent on a port", .tokens = { (void *)&cmd_tx_vlan_set_tx_vlan, (void *)&cmd_tx_vlan_set_set, - (void *)&cmd_tx_vlan_set_vlanid, (void *)&cmd_tx_vlan_set_portid, + (void *)&cmd_tx_vlan_set_vlanid, + NULL, + }, +}; + +/* *** ENABLE HARDWARE INSERTION OF Double VLAN HEADER IN TX PACKETS *** */ +struct cmd_tx_vlan_set_qinq_result { + cmdline_fixed_string_t tx_vlan; + cmdline_fixed_string_t set; + uint8_t port_id; + uint16_t vlan_id; + uint16_t vlan_id_outer; +}; + +static void +cmd_tx_vlan_set_qinq_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_tx_vlan_set_qinq_result *res = parsed_result; + int vlan_offload = rte_eth_dev_get_vlan_offload(res->port_id); + + if (!(vlan_offload & ETH_VLAN_EXTEND_OFFLOAD)) { + printf("Error, as QinQ hasn't been enabled.\n"); + return; + } + + tx_qinq_set(res->port_id, res->vlan_id, res->vlan_id_outer); +} + +cmdline_parse_token_string_t cmd_tx_vlan_set_qinq_tx_vlan = + TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_qinq_result, + tx_vlan, "tx_vlan"); +cmdline_parse_token_string_t cmd_tx_vlan_set_qinq_set = + TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_qinq_result, + set, "set"); +cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_portid = + TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result, + port_id, UINT8); +cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_vlanid = + TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result, + vlan_id, UINT16); +cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_vlanid_outer = + TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result, + vlan_id_outer, UINT16); + +cmdline_parse_inst_t cmd_tx_vlan_set_qinq = { + .f = cmd_tx_vlan_set_qinq_parsed, + .data = NULL, + .help_str = "enable hardware insertion of double VLAN header " + "with given TAG Identifiers in packets sent on a port", + .tokens = { + (void *)&cmd_tx_vlan_set_qinq_tx_vlan, + (void *)&cmd_tx_vlan_set_qinq_set, + (void *)&cmd_tx_vlan_set_qinq_portid, + (void *)&cmd_tx_vlan_set_qinq_vlanid, + (void *)&cmd_tx_vlan_set_qinq_vlanid_outer, NULL, }, }; @@ -3951,6 +4060,7 @@ static void cmd_add_bonding_slave_parsed(void *parsed_result, return; } init_port_config(); + set_port_slave_flag(slave_port_id); } cmdline_parse_token_string_t cmd_addbonding_slave_add = @@ -4007,6 +4117,7 @@ static void cmd_remove_bonding_slave_parsed(void *parsed_result, return; } init_port_config(); + clear_port_slave_flag(slave_port_id); } cmdline_parse_token_string_t cmd_removebonding_slave_remove = @@ -4744,7 +4855,8 @@ cmd_link_flow_ctrl_set_parsed(void *parsed_result, struct cmd_link_flow_ctrl_set_result *res = parsed_result; cmdline_parse_inst_t *cmd = data; struct rte_eth_fc_conf fc_conf; - int rx_fc_en, tx_fc_en = 0; + int rx_fc_en = 0; + int tx_fc_en = 0; int ret; /* @@ -6584,7 +6696,8 @@ cmdline_parse_token_num_t cmd_mirror_mask_ruleid = rule_id, UINT8); cmdline_parse_token_string_t cmd_mirror_mask_what = TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - what, "pool-mirror#vlan-mirror"); + what, "pool-mirror-up#pool-mirror-down" + "#vlan-mirror"); cmdline_parse_token_string_t cmd_mirror_mask_value = TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, value, NULL); @@ -6605,25 +6718,28 @@ cmd_set_mirror_mask_parsed(void *parsed_result, { int ret,nb_item,i; struct cmd_set_mirror_mask_result *res = parsed_result; - struct rte_eth_vmdq_mirror_conf mr_conf; + struct rte_eth_mirror_conf mr_conf; - memset(&mr_conf,0,sizeof(struct rte_eth_vmdq_mirror_conf)); + memset(&mr_conf, 0, sizeof(struct rte_eth_mirror_conf)); - unsigned int vlan_list[ETH_VMDQ_MAX_VLAN_FILTERS]; + unsigned int vlan_list[ETH_MIRROR_MAX_VLANS]; mr_conf.dst_pool = res->dstpool_id; - if (!strcmp(res->what, "pool-mirror")) { - mr_conf.pool_mask = strtoull(res->value,NULL,16); - mr_conf.rule_type_mask = ETH_VMDQ_POOL_MIRROR; - } else if(!strcmp(res->what, "vlan-mirror")) { - mr_conf.rule_type_mask = ETH_VMDQ_VLAN_MIRROR; - nb_item = parse_item_list(res->value, "core", - ETH_VMDQ_MAX_VLAN_FILTERS,vlan_list,1); + if (!strcmp(res->what, "pool-mirror-up")) { + mr_conf.pool_mask = strtoull(res->value, NULL, 16); + mr_conf.rule_type = ETH_MIRROR_VIRTUAL_POOL_UP; + } else if (!strcmp(res->what, "pool-mirror-down")) { + mr_conf.pool_mask = strtoull(res->value, NULL, 16); + mr_conf.rule_type = ETH_MIRROR_VIRTUAL_POOL_DOWN; + } else if (!strcmp(res->what, "vlan-mirror")) { + mr_conf.rule_type = ETH_MIRROR_VLAN; + nb_item = parse_item_list(res->value, "vlan", + ETH_MIRROR_MAX_VLANS, vlan_list, 1); if (nb_item <= 0) return; - for(i=0; i < nb_item; i++) { + for (i = 0; i < nb_item; i++) { if (vlan_list[i] > ETHER_MAX_VLAN_ID) { printf("Invalid vlan_id: must be < 4096\n"); return; @@ -6634,21 +6750,21 @@ cmd_set_mirror_mask_parsed(void *parsed_result, } } - if(!strcmp(res->on, "on")) - ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf, + if (!strcmp(res->on, "on")) + ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, res->rule_id, 1); else - ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf, + ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, res->rule_id, 0); - if(ret < 0) + if (ret < 0) printf("mirror rule add error: (%s)\n", strerror(-ret)); } cmdline_parse_inst_t cmd_set_mirror_mask = { .f = cmd_set_mirror_mask_parsed, .data = NULL, - .help_str = "set port X mirror-rule Y pool-mirror|vlan-mirror " - "pool_mask|vlan_id[,vlan_id]* dst-pool Z on|off", + .help_str = "set port X mirror-rule Y pool-mirror-up|pool-mirror-down|vlan-mirror" + " pool_mask|vlan_id[,vlan_id]* dst-pool Z on|off", .tokens = { (void *)&cmd_mirror_mask_set, (void *)&cmd_mirror_mask_port, @@ -6712,25 +6828,25 @@ cmd_set_mirror_link_parsed(void *parsed_result, { int ret; struct cmd_set_mirror_link_result *res = parsed_result; - struct rte_eth_vmdq_mirror_conf mr_conf; + struct rte_eth_mirror_conf mr_conf; - memset(&mr_conf,0,sizeof(struct rte_eth_vmdq_mirror_conf)); - if(!strcmp(res->what, "uplink-mirror")) { - mr_conf.rule_type_mask = ETH_VMDQ_UPLINK_MIRROR; - }else if(!strcmp(res->what, "downlink-mirror")) - mr_conf.rule_type_mask = ETH_VMDQ_DOWNLIN_MIRROR; + memset(&mr_conf, 0, sizeof(struct rte_eth_mirror_conf)); + if (!strcmp(res->what, "uplink-mirror")) + mr_conf.rule_type = ETH_MIRROR_UPLINK_PORT; + else + mr_conf.rule_type = ETH_MIRROR_DOWNLINK_PORT; mr_conf.dst_pool = res->dstpool_id; - if(!strcmp(res->on, "on")) - ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf, + if (!strcmp(res->on, "on")) + ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, res->rule_id, 1); else - ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf, + ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, res->rule_id, 0); /* check the return value and print it if is < 0 */ - if(ret < 0) + if (ret < 0) printf("mirror rule add error: (%s)\n", strerror(-ret)); } @@ -7651,9 +7767,13 @@ cmdline_parse_inst_t cmd_ethertype_filter = { struct cmd_flow_director_result { cmdline_fixed_string_t flow_director_filter; uint8_t port_id; + cmdline_fixed_string_t mode; + cmdline_fixed_string_t mode_value; cmdline_fixed_string_t ops; cmdline_fixed_string_t flow; cmdline_fixed_string_t flow_type; + cmdline_fixed_string_t ether; + uint16_t ether_type; cmdline_fixed_string_t src; cmdline_ipaddr_t ip_src; uint16_t port_src; @@ -7671,6 +7791,12 @@ struct cmd_flow_director_result { uint16_t queue_id; cmdline_fixed_string_t fd_id; uint32_t fd_id_value; + cmdline_fixed_string_t mac; + struct ether_addr mac_addr; + cmdline_fixed_string_t tunnel; + cmdline_fixed_string_t tunnel_type; + cmdline_fixed_string_t tunnel_id; + uint32_t tunnel_id_value; }; static inline int @@ -7742,6 +7868,26 @@ str2flowtype(char *string) return RTE_ETH_FLOW_UNKNOWN; } +static uint8_t +str2fdir_tunneltype(char *string) +{ + uint8_t i = 0; + + static const struct { + char str[32]; + uint8_t type; + } tunneltype_str[] = { + {"NVGRE", RTE_FDIR_TUNNEL_TYPE_NVGRE}, + {"VxLAN", RTE_FDIR_TUNNEL_TYPE_VXLAN}, + }; + + for (i = 0; i < RTE_DIM(tunneltype_str); i++) { + if (!strcmp(tunneltype_str[i].str, string)) + return tunneltype_str[i].type; + } + return RTE_FDIR_TUNNEL_TYPE_UNKNOWN; +} + #define IPV4_ADDR_TO_UINT(ip_addr, ip) \ do { \ if ((ip_addr).family == AF_INET) \ @@ -7782,6 +7928,25 @@ cmd_flow_director_filter_parsed(void *parsed_result, } memset(flexbytes, 0, sizeof(flexbytes)); memset(&entry, 0, sizeof(struct rte_eth_fdir_filter)); + + if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) { + if (strcmp(res->mode_value, "MAC-VLAN")) { + printf("Please set mode to MAC-VLAN.\n"); + return; + } + } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) { + if (strcmp(res->mode_value, "Tunnel")) { + printf("Please set mode to Tunnel.\n"); + return; + } + } else { + if (strcmp(res->mode_value, "IP")) { + printf("Please set mode to IP.\n"); + return; + } + entry.input.flow_type = str2flowtype(res->flow_type); + } + ret = parse_flexbytes(res->flexbytes_value, flexbytes, RTE_ETH_FDIR_MAX_FLEXLEN); @@ -7790,7 +7955,6 @@ cmd_flow_director_filter_parsed(void *parsed_result, return; } - entry.input.flow_type = str2flowtype(res->flow_type); switch (entry.input.flow_type) { case RTE_ETH_FLOW_FRAG_IPV4: case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: @@ -7812,6 +7976,10 @@ cmd_flow_director_filter_parsed(void *parsed_result, IPV4_ADDR_TO_UINT(res->ip_src, entry.input.flow.sctp4_flow.ip.src_ip); /* need convert to big endian. */ + entry.input.flow.sctp4_flow.dst_port = + rte_cpu_to_be_16(res->port_dst); + entry.input.flow.sctp4_flow.src_port = + rte_cpu_to_be_16(res->port_src); entry.input.flow.sctp4_flow.verify_tag = rte_cpu_to_be_32(res->verify_tag_value); break; @@ -7835,13 +8003,36 @@ cmd_flow_director_filter_parsed(void *parsed_result, IPV6_ADDR_TO_ARRAY(res->ip_src, entry.input.flow.sctp6_flow.ip.src_ip); /* need convert to big endian. */ + entry.input.flow.sctp6_flow.dst_port = + rte_cpu_to_be_16(res->port_dst); + entry.input.flow.sctp6_flow.src_port = + rte_cpu_to_be_16(res->port_src); entry.input.flow.sctp6_flow.verify_tag = rte_cpu_to_be_32(res->verify_tag_value); break; + case RTE_ETH_FLOW_L2_PAYLOAD: + entry.input.flow.l2_flow.ether_type = + rte_cpu_to_be_16(res->ether_type); + break; default: - printf("invalid parameter.\n"); - return; + break; } + + if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) + (void)rte_memcpy(&entry.input.flow.mac_vlan_flow.mac_addr, + &res->mac_addr, + sizeof(struct ether_addr)); + + if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) { + (void)rte_memcpy(&entry.input.flow.tunnel_flow.mac_addr, + &res->mac_addr, + sizeof(struct ether_addr)); + entry.input.flow.tunnel_flow.tunnel_type = + str2fdir_tunneltype(res->tunnel_type); + entry.input.flow.tunnel_flow.tunnel_id = + rte_cpu_to_be_32(res->tunnel_id_value); + } + (void)rte_memcpy(entry.input.flow_ext.flexbytes, flexbytes, RTE_ETH_FDIR_MAX_FLEXLEN); @@ -7886,7 +8077,13 @@ cmdline_parse_token_string_t cmd_flow_director_flow = cmdline_parse_token_string_t cmd_flow_director_flow_type = TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, flow_type, "ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#" - "ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp"); + "ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#l2_payload"); +cmdline_parse_token_string_t cmd_flow_director_ether = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + ether, "ether"); +cmdline_parse_token_num_t cmd_flow_director_ether_type = + TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result, + ether_type, UINT16); cmdline_parse_token_string_t cmd_flow_director_src = TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, src, "src"); @@ -7939,6 +8136,37 @@ cmdline_parse_token_num_t cmd_flow_director_fd_id_value = TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result, fd_id_value, UINT32); +cmdline_parse_token_string_t cmd_flow_director_mode = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + mode, "mode"); +cmdline_parse_token_string_t cmd_flow_director_mode_ip = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + mode_value, "IP"); +cmdline_parse_token_string_t cmd_flow_director_mode_mac_vlan = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + mode_value, "MAC-VLAN"); +cmdline_parse_token_string_t cmd_flow_director_mode_tunnel = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + mode_value, "Tunnel"); +cmdline_parse_token_string_t cmd_flow_director_mac = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + mac, "mac"); +cmdline_parse_token_etheraddr_t cmd_flow_director_mac_addr = + TOKEN_ETHERADDR_INITIALIZER(struct cmd_flow_director_result, + mac_addr); +cmdline_parse_token_string_t cmd_flow_director_tunnel = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + tunnel, "tunnel"); +cmdline_parse_token_string_t cmd_flow_director_tunnel_type = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + tunnel_type, "NVGRE#VxLAN"); +cmdline_parse_token_string_t cmd_flow_director_tunnel_id = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + tunnel_id, "tunnel-id"); +cmdline_parse_token_num_t cmd_flow_director_tunnel_id_value = + TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result, + tunnel_id_value, UINT32); + cmdline_parse_inst_t cmd_add_del_ip_flow_director = { .f = cmd_flow_director_filter_parsed, .data = NULL, @@ -7946,6 +8174,8 @@ cmdline_parse_inst_t cmd_add_del_ip_flow_director = { .tokens = { (void *)&cmd_flow_director_filter, (void *)&cmd_flow_director_port_id, + (void *)&cmd_flow_director_mode, + (void *)&cmd_flow_director_mode_ip, (void *)&cmd_flow_director_ops, (void *)&cmd_flow_director_flow, (void *)&cmd_flow_director_flow_type, @@ -7973,6 +8203,8 @@ cmdline_parse_inst_t cmd_add_del_udp_flow_director = { .tokens = { (void *)&cmd_flow_director_filter, (void *)&cmd_flow_director_port_id, + (void *)&cmd_flow_director_mode, + (void *)&cmd_flow_director_mode_ip, (void *)&cmd_flow_director_ops, (void *)&cmd_flow_director_flow, (void *)&cmd_flow_director_flow_type, @@ -8002,6 +8234,8 @@ cmdline_parse_inst_t cmd_add_del_sctp_flow_director = { .tokens = { (void *)&cmd_flow_director_filter, (void *)&cmd_flow_director_port_id, + (void *)&cmd_flow_director_mode, + (void *)&cmd_flow_director_mode_ip, (void *)&cmd_flow_director_ops, (void *)&cmd_flow_director_flow, (void *)&cmd_flow_director_flow_type, @@ -8026,6 +8260,85 @@ cmdline_parse_inst_t cmd_add_del_sctp_flow_director = { }, }; +cmdline_parse_inst_t cmd_add_del_l2_flow_director = { + .f = cmd_flow_director_filter_parsed, + .data = NULL, + .help_str = "add or delete a L2 flow director entry on NIC", + .tokens = { + (void *)&cmd_flow_director_filter, + (void *)&cmd_flow_director_port_id, + (void *)&cmd_flow_director_mode, + (void *)&cmd_flow_director_mode_ip, + (void *)&cmd_flow_director_ops, + (void *)&cmd_flow_director_flow, + (void *)&cmd_flow_director_flow_type, + (void *)&cmd_flow_director_ether, + (void *)&cmd_flow_director_ether_type, + (void *)&cmd_flow_director_flexbytes, + (void *)&cmd_flow_director_flexbytes_value, + (void *)&cmd_flow_director_drop, + (void *)&cmd_flow_director_queue, + (void *)&cmd_flow_director_queue_id, + (void *)&cmd_flow_director_fd_id, + (void *)&cmd_flow_director_fd_id_value, + NULL, + }, +}; + +cmdline_parse_inst_t cmd_add_del_mac_vlan_flow_director = { + .f = cmd_flow_director_filter_parsed, + .data = NULL, + .help_str = "add or delete a MAC VLAN flow director entry on NIC", + .tokens = { + (void *)&cmd_flow_director_filter, + (void *)&cmd_flow_director_port_id, + (void *)&cmd_flow_director_mode, + (void *)&cmd_flow_director_mode_mac_vlan, + (void *)&cmd_flow_director_ops, + (void *)&cmd_flow_director_mac, + (void *)&cmd_flow_director_mac_addr, + (void *)&cmd_flow_director_vlan, + (void *)&cmd_flow_director_vlan_value, + (void *)&cmd_flow_director_flexbytes, + (void *)&cmd_flow_director_flexbytes_value, + (void *)&cmd_flow_director_drop, + (void *)&cmd_flow_director_queue, + (void *)&cmd_flow_director_queue_id, + (void *)&cmd_flow_director_fd_id, + (void *)&cmd_flow_director_fd_id_value, + NULL, + }, +}; + +cmdline_parse_inst_t cmd_add_del_tunnel_flow_director = { + .f = cmd_flow_director_filter_parsed, + .data = NULL, + .help_str = "add or delete a tunnel flow director entry on NIC", + .tokens = { + (void *)&cmd_flow_director_filter, + (void *)&cmd_flow_director_port_id, + (void *)&cmd_flow_director_mode, + (void *)&cmd_flow_director_mode_tunnel, + (void *)&cmd_flow_director_ops, + (void *)&cmd_flow_director_mac, + (void *)&cmd_flow_director_mac_addr, + (void *)&cmd_flow_director_vlan, + (void *)&cmd_flow_director_vlan_value, + (void *)&cmd_flow_director_tunnel, + (void *)&cmd_flow_director_tunnel_type, + (void *)&cmd_flow_director_tunnel_id, + (void *)&cmd_flow_director_tunnel_id_value, + (void *)&cmd_flow_director_flexbytes, + (void *)&cmd_flow_director_flexbytes_value, + (void *)&cmd_flow_director_drop, + (void *)&cmd_flow_director_queue, + (void *)&cmd_flow_director_queue_id, + (void *)&cmd_flow_director_fd_id, + (void *)&cmd_flow_director_fd_id_value, + NULL, + }, +}; + struct cmd_flush_flow_director_result { cmdline_fixed_string_t flush_flow_director; uint8_t port_id; @@ -8075,8 +8388,10 @@ cmdline_parse_inst_t cmd_flush_flow_director = { struct cmd_flow_director_mask_result { cmdline_fixed_string_t flow_director_mask; uint8_t port_id; + cmdline_fixed_string_t mode; + cmdline_fixed_string_t mode_value; cmdline_fixed_string_t vlan; - uint16_t vlan_value; + uint16_t vlan_mask; cmdline_fixed_string_t src_mask; cmdline_ipaddr_t ipv4_src; cmdline_ipaddr_t ipv6_src; @@ -8085,6 +8400,12 @@ struct cmd_flow_director_mask_result { cmdline_ipaddr_t ipv4_dst; cmdline_ipaddr_t ipv6_dst; uint16_t port_dst; + cmdline_fixed_string_t mac; + uint8_t mac_addr_byte_mask; + cmdline_fixed_string_t tunnel_id; + uint32_t tunnel_id_mask; + cmdline_fixed_string_t tunnel_type; + uint8_t tunnel_type_mask; }; static void @@ -8107,15 +8428,41 @@ cmd_flow_director_mask_parsed(void *parsed_result, printf("Please stop port %d first\n", res->port_id); return; } + mask = &port->dev_conf.fdir_conf.mask; - mask->vlan_tci_mask = res->vlan_value; - IPV4_ADDR_TO_UINT(res->ipv4_src, mask->ipv4_mask.src_ip); - IPV4_ADDR_TO_UINT(res->ipv4_dst, mask->ipv4_mask.dst_ip); - IPV6_ADDR_TO_ARRAY(res->ipv6_src, mask->ipv6_mask.src_ip); - IPV6_ADDR_TO_ARRAY(res->ipv6_dst, mask->ipv6_mask.dst_ip); - mask->src_port_mask = res->port_src; - mask->dst_port_mask = res->port_dst; + if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) { + if (strcmp(res->mode_value, "MAC-VLAN")) { + printf("Please set mode to MAC-VLAN.\n"); + return; + } + + mask->vlan_tci_mask = res->vlan_mask; + mask->mac_addr_byte_mask = res->mac_addr_byte_mask; + } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) { + if (strcmp(res->mode_value, "Tunnel")) { + printf("Please set mode to Tunnel.\n"); + return; + } + + mask->vlan_tci_mask = res->vlan_mask; + mask->mac_addr_byte_mask = res->mac_addr_byte_mask; + mask->tunnel_id_mask = res->tunnel_id_mask; + mask->tunnel_type_mask = res->tunnel_type_mask; + } else { + if (strcmp(res->mode_value, "IP")) { + printf("Please set mode to IP.\n"); + return; + } + + mask->vlan_tci_mask = res->vlan_mask; + IPV4_ADDR_TO_UINT(res->ipv4_src, mask->ipv4_mask.src_ip); + IPV4_ADDR_TO_UINT(res->ipv4_dst, mask->ipv4_mask.dst_ip); + IPV6_ADDR_TO_ARRAY(res->ipv6_src, mask->ipv6_mask.src_ip); + IPV6_ADDR_TO_ARRAY(res->ipv6_dst, mask->ipv6_mask.dst_ip); + mask->src_port_mask = res->port_src; + mask->dst_port_mask = res->port_dst; + } cmd_reconfig_device_queue(res->port_id, 1, 1); } @@ -8131,7 +8478,7 @@ cmdline_parse_token_string_t cmd_flow_director_mask_vlan = vlan, "vlan"); cmdline_parse_token_num_t cmd_flow_director_mask_vlan_value = TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result, - vlan_value, UINT16); + vlan_mask, UINT16); cmdline_parse_token_string_t cmd_flow_director_mask_src = TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, src_mask, "src_mask"); @@ -8156,13 +8503,47 @@ cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv6_dst = cmdline_parse_token_num_t cmd_flow_director_mask_port_dst = TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result, port_dst, UINT16); -cmdline_parse_inst_t cmd_set_flow_director_mask = { + +cmdline_parse_token_string_t cmd_flow_director_mask_mode = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + mode, "mode"); +cmdline_parse_token_string_t cmd_flow_director_mask_mode_ip = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + mode_value, "IP"); +cmdline_parse_token_string_t cmd_flow_director_mask_mode_mac_vlan = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + mode_value, "MAC-VLAN"); +cmdline_parse_token_string_t cmd_flow_director_mask_mode_tunnel = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + mode_value, "Tunnel"); +cmdline_parse_token_string_t cmd_flow_director_mask_mac = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + mac, "mac"); +cmdline_parse_token_num_t cmd_flow_director_mask_mac_value = + TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result, + mac_addr_byte_mask, UINT8); +cmdline_parse_token_string_t cmd_flow_director_mask_tunnel_type = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + tunnel_type, "tunnel-type"); +cmdline_parse_token_num_t cmd_flow_director_mask_tunnel_type_value = + TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result, + tunnel_type_mask, UINT8); +cmdline_parse_token_string_t cmd_flow_director_mask_tunnel_id = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + tunnel_id, "tunnel-id"); +cmdline_parse_token_num_t cmd_flow_director_mask_tunnel_id_value = + TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result, + tunnel_id_mask, UINT32); + +cmdline_parse_inst_t cmd_set_flow_director_ip_mask = { .f = cmd_flow_director_mask_parsed, .data = NULL, - .help_str = "set flow director's mask on NIC", + .help_str = "set IP mode flow director's mask on NIC", .tokens = { (void *)&cmd_flow_director_mask, (void *)&cmd_flow_director_mask_port_id, + (void *)&cmd_flow_director_mask_mode, + (void *)&cmd_flow_director_mask_mode_ip, (void *)&cmd_flow_director_mask_vlan, (void *)&cmd_flow_director_mask_vlan_value, (void *)&cmd_flow_director_mask_src, @@ -8177,6 +8558,44 @@ cmdline_parse_inst_t cmd_set_flow_director_mask = { }, }; +cmdline_parse_inst_t cmd_set_flow_director_mac_vlan_mask = { + .f = cmd_flow_director_mask_parsed, + .data = NULL, + .help_str = "set MAC VLAN mode flow director's mask on NIC", + .tokens = { + (void *)&cmd_flow_director_mask, + (void *)&cmd_flow_director_mask_port_id, + (void *)&cmd_flow_director_mask_mode, + (void *)&cmd_flow_director_mask_mode_mac_vlan, + (void *)&cmd_flow_director_mask_vlan, + (void *)&cmd_flow_director_mask_vlan_value, + (void *)&cmd_flow_director_mask_mac, + (void *)&cmd_flow_director_mask_mac_value, + NULL, + }, +}; + +cmdline_parse_inst_t cmd_set_flow_director_tunnel_mask = { + .f = cmd_flow_director_mask_parsed, + .data = NULL, + .help_str = "set tunnel mode flow director's mask on NIC", + .tokens = { + (void *)&cmd_flow_director_mask, + (void *)&cmd_flow_director_mask_port_id, + (void *)&cmd_flow_director_mask_mode, + (void *)&cmd_flow_director_mask_mode_tunnel, + (void *)&cmd_flow_director_mask_vlan, + (void *)&cmd_flow_director_mask_vlan_value, + (void *)&cmd_flow_director_mask_mac, + (void *)&cmd_flow_director_mask_mac_value, + (void *)&cmd_flow_director_mask_tunnel_type, + (void *)&cmd_flow_director_mask_tunnel_type_value, + (void *)&cmd_flow_director_mask_tunnel_id, + (void *)&cmd_flow_director_mask_tunnel_id_value, + NULL, + }, +}; + /* *** deal with flow director mask on flexible payload *** */ struct cmd_flow_director_flex_mask_result { cmdline_fixed_string_t flow_director_flexmask; @@ -8228,6 +8647,19 @@ cmd_flow_director_flex_mask_parsed(void *parsed_result, return; } + if (!strcmp(res->flow_type, "none")) { + /* means don't specify the flow type */ + flex_mask.flow_type = RTE_ETH_FLOW_UNKNOWN; + for (i = 0; i < RTE_ETH_FLOW_MAX; i++) + memset(&port->dev_conf.fdir_conf.flex_conf.flex_mask[i], + 0, sizeof(struct rte_eth_fdir_flex_mask)); + port->dev_conf.fdir_conf.flex_conf.nb_flexmasks = 1; + (void)rte_memcpy(&port->dev_conf.fdir_conf.flex_conf.flex_mask[0], + &flex_mask, + sizeof(struct rte_eth_fdir_flex_mask)); + cmd_reconfig_device_queue(res->port_id, 1, 1); + return; + } flow_type_mask = fdir_info.flow_types_mask[0]; if (!strcmp(res->flow_type, "all")) { if (!flow_type_mask) { @@ -8265,8 +8697,8 @@ cmdline_parse_token_string_t cmd_flow_director_flexmask_flow = flow, "flow"); cmdline_parse_token_string_t cmd_flow_director_flexmask_flow_type = TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result, - flow_type, "raw#ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#" - "ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#all"); + flow_type, "none#ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#" + "ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#l2_payload#all"); cmdline_parse_token_string_t cmd_flow_director_flexmask_mask = TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result, mask, NULL); @@ -8721,6 +9153,57 @@ cmdline_parse_inst_t cmd_set_hash_global_config = { }, }; +/* *** ADD/REMOVE A MULTICAST MAC ADDRESS TO/FROM A PORT *** */ +struct cmd_mcast_addr_result { + cmdline_fixed_string_t mcast_addr_cmd; + cmdline_fixed_string_t what; + uint8_t port_num; + struct ether_addr mc_addr; +}; + +static void cmd_mcast_addr_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_mcast_addr_result *res = parsed_result; + + if (!is_multicast_ether_addr(&res->mc_addr)) { + printf("Invalid multicast addr %02X:%02X:%02X:%02X:%02X:%02X\n", + res->mc_addr.addr_bytes[0], res->mc_addr.addr_bytes[1], + res->mc_addr.addr_bytes[2], res->mc_addr.addr_bytes[3], + res->mc_addr.addr_bytes[4], res->mc_addr.addr_bytes[5]); + return; + } + if (strcmp(res->what, "add") == 0) + mcast_addr_add(res->port_num, &res->mc_addr); + else + mcast_addr_remove(res->port_num, &res->mc_addr); +} + +cmdline_parse_token_string_t cmd_mcast_addr_cmd = + TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result, + mcast_addr_cmd, "mcast_addr"); +cmdline_parse_token_string_t cmd_mcast_addr_what = + TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result, what, + "add#remove"); +cmdline_parse_token_num_t cmd_mcast_addr_portnum = + TOKEN_NUM_INITIALIZER(struct cmd_mcast_addr_result, port_num, UINT8); +cmdline_parse_token_etheraddr_t cmd_mcast_addr_addr = + TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address); + +cmdline_parse_inst_t cmd_mcast_addr = { + .f = cmd_mcast_addr_parsed, + .data = (void *)0, + .help_str = "mcast_addr add|remove X : add/remove multicast MAC address on port X", + .tokens = { + (void *)&cmd_mcast_addr_cmd, + (void *)&cmd_mcast_addr_what, + (void *)&cmd_mcast_addr_portnum, + (void *)&cmd_mcast_addr_addr, + NULL, + }, +}; + /* ******************************************************************************** */ /* list of instructions */ @@ -8770,6 +9253,7 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_rx_vlan_filter_all, (cmdline_parse_inst_t *)&cmd_rx_vlan_filter, (cmdline_parse_inst_t *)&cmd_tx_vlan_set, + (cmdline_parse_inst_t *)&cmd_tx_vlan_set_qinq, (cmdline_parse_inst_t *)&cmd_tx_vlan_reset, (cmdline_parse_inst_t *)&cmd_tx_vlan_set_pvid, (cmdline_parse_inst_t *)&cmd_csum_set, @@ -8842,14 +9326,20 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_add_del_ip_flow_director, (cmdline_parse_inst_t *)&cmd_add_del_udp_flow_director, (cmdline_parse_inst_t *)&cmd_add_del_sctp_flow_director, + (cmdline_parse_inst_t *)&cmd_add_del_l2_flow_director, + (cmdline_parse_inst_t *)&cmd_add_del_mac_vlan_flow_director, + (cmdline_parse_inst_t *)&cmd_add_del_tunnel_flow_director, (cmdline_parse_inst_t *)&cmd_flush_flow_director, - (cmdline_parse_inst_t *)&cmd_set_flow_director_mask, + (cmdline_parse_inst_t *)&cmd_set_flow_director_ip_mask, + (cmdline_parse_inst_t *)&cmd_set_flow_director_mac_vlan_mask, + (cmdline_parse_inst_t *)&cmd_set_flow_director_tunnel_mask, (cmdline_parse_inst_t *)&cmd_set_flow_director_flex_mask, (cmdline_parse_inst_t *)&cmd_set_flow_director_flex_payload, (cmdline_parse_inst_t *)&cmd_get_sym_hash_ena_per_port, (cmdline_parse_inst_t *)&cmd_set_sym_hash_ena_per_port, (cmdline_parse_inst_t *)&cmd_get_hash_global_config, (cmdline_parse_inst_t *)&cmd_set_hash_global_config, + (cmdline_parse_inst_t *)&cmd_mcast_addr, NULL, }; @@ -8873,14 +9363,7 @@ prompt(void) static void cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue) { - if (!port_id_is_invalid(id, DISABLED_WARN)) { - /* check if need_reconfig has been set to 1 */ - if (ports[id].need_reconfig == 0) - ports[id].need_reconfig = dev; - /* check if need_reconfig_queues has been set to 1 */ - if (ports[id].need_reconfig_queues == 0) - ports[id].need_reconfig_queues = queue; - } else { + if (id == (portid_t)RTE_PORT_ALL) { portid_t pid; FOREACH_PORT(pid, ports) { @@ -8891,10 +9374,18 @@ cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue) if (ports[pid].need_reconfig_queues == 0) ports[pid].need_reconfig_queues = queue; } + } else if (!port_id_is_invalid(id, DISABLED_WARN)) { + /* check if need_reconfig has been set to 1 */ + if (ports[id].need_reconfig == 0) + ports[id].need_reconfig = dev; + /* check if need_reconfig_queues has been set to 1 */ + if (ports[id].need_reconfig_queues == 0) + ports[id].need_reconfig_queues = queue; } } #ifdef RTE_NIC_BYPASS +#include uint8_t bypass_is_supported(portid_t port_id) {