From: Intel Date: Wed, 18 Sep 2013 10:00:00 +0000 (+0200) Subject: app/testpmd: VMDq and DCB updates X-Git-Tag: spdx-start~11115 X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=7741e4cf16c0548e15d07b847fd96691b44efb29;p=dpdk.git app/testpmd: VMDq and DCB updates Signed-off-by: Intel --- diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index d17b3645ad..8c571c07a6 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -247,6 +247,18 @@ static void cmd_help_long_parsed(void *parsed_result, " Remove a vlan_id, or all identifiers, from the set" " of VLAN identifiers filtered by port_id.\n\n" + "rx_vlan add (vlan_id) port (port_id) vf (vf_mask)\n" + " Add a vlan_id, to the set of VLAN identifiers" + "filtered for VF(s) from port_id.\n\n" + + "rx_vlan rm (vlan_id) port (port_id) vf (vf_mask)\n" + " Remove a vlan_id, to the set of VLAN identifiers" + "filtered for VF(s) from port_id.\n\n" + + "rx_vlan set tpid (value) (port_id)\n" + " Set the outer VLAN TPID for Packet Filtering 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" @@ -281,6 +293,13 @@ static void cmd_help_long_parsed(void *parsed_result, "mac_addr remove (port_id) (XX:XX:XX:XX:XX:XX)\n" " Remove a MAC address from port_id.\n\n" + "mac_addr add port (port_id) vf (vf_id) (mac_address)\n" + " Add a MAC address for a VF on the port.\n\n" + + "set port (port_id) uta (mac_address|all) (on|off)\n" + " Add/Remove a or all unicast hash filter(s)" + "from port X.\n\n" + "set promisc (port_id|all) (on|off)\n" " Set the promiscuous mode on port_id, or all.\n\n" @@ -301,6 +320,37 @@ static void cmd_help_long_parsed(void *parsed_result, " queue on port.\n" " e.g., 'set stat_qmap rx 0 2 5' sets rx queue 2" " on port 0 to mapping 5.\n\n" + + "set port (port_id) vf (vf_id) rx|tx on|off \n" + " Enable/Disable a VF receive/tranmit from a port\n\n" + + "set port (port_id) vf (vf_id) rxmode (AUPE|ROPE|BAM" + "|MPE) (on|off)\n" + " AUPE:accepts untagged VLAN;" + "ROPE:accept unicast hash\n\n" + " BAM:accepts broadcast packets;" + "MPE:accepts all multicast packets\n\n" + " Enable/Disable a VF receive mode of a port\n\n" + + "set port (port_id) mirror-rule (rule_id)" + "(pool-mirror|vlan-mirror)\n" + " (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" + " dst-pool 0 on' enable mirror traffic with vlan 0,1" + " to pool 0.\n\n" + + "set port (port_id) mirror-rule (rule_id)" + "(uplink-mirror|downlink-mirror) dst-pool" + "(pool_id) (on|off)\n" + " Set uplink or downlink type mirror rule on a port.\n" + " e.g., 'set port 0 mirror-rule 0 uplink-mirror dst-pool" + " 0 on' enable mirror income traffic to pool 0.\n\n" + + "reset port (port_id) mirror-rule (rule_id)\n" + " Reset a mirror rule.\n\n" + + "" ); } @@ -2197,6 +2247,45 @@ cmdline_parse_inst_t cmd_tx_cksum_set = { }, }; +/* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */ +struct cmd_set_flush_rx { + cmdline_fixed_string_t set; + cmdline_fixed_string_t flush_rx; + cmdline_fixed_string_t mode; +}; + +static void +cmd_set_flush_rx_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_set_flush_rx *res = parsed_result; + no_flush_rx = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1); +} + +cmdline_parse_token_string_t cmd_setflushrx_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx, + set, "set"); +cmdline_parse_token_string_t cmd_setflushrx_flush_rx = + TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx, + flush_rx, "flush_rx"); +cmdline_parse_token_string_t cmd_setflushrx_mode = + TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx, + mode, "on#off"); + + +cmdline_parse_inst_t cmd_set_flush_rx = { + .f = cmd_set_flush_rx_parsed, + .help_str = "set flush_rx on|off: enable/disable flush on rx streams", + .data = NULL, + .tokens = { + (void *)&cmd_setflushrx_set, + (void *)&cmd_setflushrx_flush_rx, + (void *)&cmd_setflushrx_mode, + NULL, + }, +}; + /* *** SET FORWARDING MODE *** */ struct cmd_set_fwd_mode_result { cmdline_fixed_string_t set; @@ -3811,6 +3900,652 @@ cmdline_parse_inst_t cmd_set_qmap = { }, }; +/* *** CONFIGURE UNICAST HASH TABLE *** */ +struct cmd_set_uc_hash_table { + cmdline_fixed_string_t set; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t what; + struct ether_addr address; + cmdline_fixed_string_t mode; +}; + +static void +cmd_set_uc_hash_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + int ret=0; + struct cmd_set_uc_hash_table *res = parsed_result; + + int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0; + + if (strcmp(res->what, "uta") == 0) + ret = rte_eth_dev_uc_hash_table_set(res->port_id, + &res->address,(uint8_t)is_on); + if (ret < 0) + printf("bad unicast hash table parameter, return code = %d \n", ret); + +} + +cmdline_parse_token_string_t cmd_set_uc_hash_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table, + set, "set"); +cmdline_parse_token_string_t cmd_set_uc_hash_port = + TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table, + port, "port"); +cmdline_parse_token_num_t cmd_set_uc_hash_portid = + TOKEN_NUM_INITIALIZER(struct cmd_set_uc_hash_table, + port_id, UINT8); +cmdline_parse_token_string_t cmd_set_uc_hash_what = + TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table, + what, "uta"); +cmdline_parse_token_etheraddr_t cmd_set_uc_hash_mac = + TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_uc_hash_table, + address); +cmdline_parse_token_string_t cmd_set_uc_hash_mode = + TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table, + mode, "on#off"); + +cmdline_parse_inst_t cmd_set_uc_hash_filter = { + .f = cmd_set_uc_hash_parsed, + .data = NULL, + .help_str = "set port X uta Y on|off(X = port number,Y = MAC address)", + .tokens = { + (void *)&cmd_set_uc_hash_set, + (void *)&cmd_set_uc_hash_port, + (void *)&cmd_set_uc_hash_portid, + (void *)&cmd_set_uc_hash_what, + (void *)&cmd_set_uc_hash_mac, + (void *)&cmd_set_uc_hash_mode, + NULL, + }, +}; + +struct cmd_set_uc_all_hash_table { + cmdline_fixed_string_t set; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t what; + cmdline_fixed_string_t value; + cmdline_fixed_string_t mode; +}; + +static void +cmd_set_uc_all_hash_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + int ret=0; + struct cmd_set_uc_all_hash_table *res = parsed_result; + + int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0; + + if ((strcmp(res->what, "uta") == 0) && + (strcmp(res->value, "all") == 0)) + ret = rte_eth_dev_uc_all_hash_table_set(res->port_id,(uint8_t) is_on); + if (ret < 0) + printf("bad unicast hash table parameter," + "return code = %d \n", ret); +} + +cmdline_parse_token_string_t cmd_set_uc_all_hash_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, + set, "set"); +cmdline_parse_token_string_t cmd_set_uc_all_hash_port = + TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, + port, "port"); +cmdline_parse_token_num_t cmd_set_uc_all_hash_portid = + TOKEN_NUM_INITIALIZER(struct cmd_set_uc_all_hash_table, + port_id, UINT8); +cmdline_parse_token_string_t cmd_set_uc_all_hash_what = + TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, + what, "uta"); +cmdline_parse_token_string_t cmd_set_uc_all_hash_value = + TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, + value,"all"); +cmdline_parse_token_string_t cmd_set_uc_all_hash_mode = + TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, + mode, "on#off"); + +cmdline_parse_inst_t cmd_set_uc_all_hash_filter = { + .f = cmd_set_uc_all_hash_parsed, + .data = NULL, + .help_str = "set port X uta all on|off (X = port number)", + .tokens = { + (void *)&cmd_set_uc_all_hash_set, + (void *)&cmd_set_uc_all_hash_port, + (void *)&cmd_set_uc_all_hash_portid, + (void *)&cmd_set_uc_all_hash_what, + (void *)&cmd_set_uc_all_hash_value, + (void *)&cmd_set_uc_all_hash_mode, + NULL, + }, +}; + +/* *** CONFIGURE VF TRAFFIC CONTROL *** */ +struct cmd_set_vf_traffic { + cmdline_fixed_string_t set; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t vf; + uint8_t vf_id; + cmdline_fixed_string_t what; + cmdline_fixed_string_t mode; +}; + +static void +cmd_set_vf_traffic_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_set_vf_traffic *res = parsed_result; + int is_rx = (strcmp(res->what, "rx") == 0) ? 1 : 0; + int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0; + + set_vf_traffic(res->port_id, (uint8_t)is_rx, res->vf_id,(uint8_t) is_on); +} + +cmdline_parse_token_string_t cmd_setvf_traffic_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, + set, "set"); +cmdline_parse_token_string_t cmd_setvf_traffic_port = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, + port, "port"); +cmdline_parse_token_num_t cmd_setvf_traffic_portid = + TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic, + port_id, UINT8); +cmdline_parse_token_string_t cmd_setvf_traffic_vf = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, + vf, "vf"); +cmdline_parse_token_num_t cmd_setvf_traffic_vfid = + TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic, + vf_id, UINT8); +cmdline_parse_token_string_t cmd_setvf_traffic_what = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, + what, "tx#rx"); +cmdline_parse_token_string_t cmd_setvf_traffic_mode = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, + mode, "on#off"); + +cmdline_parse_inst_t cmd_set_vf_traffic = { + .f = cmd_set_vf_traffic_parsed, + .data = NULL, + .help_str = "set port X vf Y rx|tx on|off (X = port number,Y = vf id)", + .tokens = { + (void *)&cmd_setvf_traffic_set, + (void *)&cmd_setvf_traffic_port, + (void *)&cmd_setvf_traffic_portid, + (void *)&cmd_setvf_traffic_vf, + (void *)&cmd_setvf_traffic_vfid, + (void *)&cmd_setvf_traffic_what, + (void *)&cmd_setvf_traffic_mode, + NULL, + }, +}; + +/* *** CONFIGURE VF RECEIVE MODE *** */ +struct cmd_set_vf_rxmode { + cmdline_fixed_string_t set; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t vf; + uint8_t vf_id; + cmdline_fixed_string_t what; + cmdline_fixed_string_t mode; + cmdline_fixed_string_t on; +}; + +static void +cmd_set_vf_rxmode_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + int ret; + uint16_t rx_mode = 0; + struct cmd_set_vf_rxmode *res = parsed_result; + + int is_on = (strcmp(res->on, "on") == 0) ? 1 : 0; + if (!strcmp(res->what,"rxmode")) { + if (!strcmp(res->mode, "AUPE")) + rx_mode |= ETH_VMDQ_ACCEPT_UNTAG; + else if (!strcmp(res->mode, "ROPE")) + rx_mode |= ETH_VMDQ_ACCEPT_HASH_UC; + else if (!strcmp(res->mode, "BAM")) + rx_mode |= ETH_VMDQ_ACCEPT_BROADCAST; + else if (!strncmp(res->mode, "MPE",3)) + rx_mode |= ETH_VMDQ_ACCEPT_MULTICAST; + } + + ret = rte_eth_dev_set_vf_rxmode(res->port_id,res->vf_id,rx_mode,(uint8_t)is_on); + if (ret < 0) + printf("bad VF receive mode parameter, return code = %d \n", + ret); +} + +cmdline_parse_token_string_t cmd_set_vf_rxmode_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, + set, "set"); +cmdline_parse_token_string_t cmd_set_vf_rxmode_port = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, + port, "port"); +cmdline_parse_token_num_t cmd_set_vf_rxmode_portid = + TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode, + port_id, UINT8); +cmdline_parse_token_string_t cmd_set_vf_rxmode_vf = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, + vf, "vf"); +cmdline_parse_token_num_t cmd_set_vf_rxmode_vfid = + TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode, + vf_id, UINT8); +cmdline_parse_token_string_t cmd_set_vf_rxmode_what = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, + what, "rxmode"); +cmdline_parse_token_string_t cmd_set_vf_rxmode_mode = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, + mode, "AUPE#ROPE#BAM#MPE"); +cmdline_parse_token_string_t cmd_set_vf_rxmode_on = + TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, + on, "on#off"); + +cmdline_parse_inst_t cmd_set_vf_rxmode = { + .f = cmd_set_vf_rxmode_parsed, + .data = NULL, + .help_str = "set port X vf Y rxmode AUPE|ROPE|BAM|MPE on|off", + .tokens = { + (void *)&cmd_set_vf_rxmode_set, + (void *)&cmd_set_vf_rxmode_port, + (void *)&cmd_set_vf_rxmode_portid, + (void *)&cmd_set_vf_rxmode_vf, + (void *)&cmd_set_vf_rxmode_vfid, + (void *)&cmd_set_vf_rxmode_what, + (void *)&cmd_set_vf_rxmode_mode, + (void *)&cmd_set_vf_rxmode_on, + NULL, + }, +}; + +/* *** ADD MAC ADDRESS FILTER FOR A VF OF A PORT *** */ +struct cmd_vf_mac_addr_result { + cmdline_fixed_string_t mac_addr_cmd; + cmdline_fixed_string_t what; + cmdline_fixed_string_t port; + uint8_t port_num; + cmdline_fixed_string_t vf; + uint8_t vf_num; + struct ether_addr address; +}; + +static void cmd_vf_mac_addr_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_vf_mac_addr_result *res = parsed_result; + int ret = 0; + + if (strcmp(res->what, "add") == 0) + ret = rte_eth_dev_mac_addr_add(res->port_num, + &res->address, res->vf_num); + if(ret < 0) + printf("vf_mac_addr_cmd error: (%s)\n", strerror(-ret)); + +} + +cmdline_parse_token_string_t cmd_vf_mac_addr_cmd = + TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, + mac_addr_cmd,"mac_addr"); +cmdline_parse_token_string_t cmd_vf_mac_addr_what = + TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, + what,"add"); +cmdline_parse_token_string_t cmd_vf_mac_addr_port = + TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, + port,"port"); +cmdline_parse_token_num_t cmd_vf_mac_addr_portnum = + TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result, + port_num, UINT8); +cmdline_parse_token_string_t cmd_vf_mac_addr_vf = + TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, + vf,"vf"); +cmdline_parse_token_num_t cmd_vf_mac_addr_vfnum = + TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result, + vf_num, UINT8); +cmdline_parse_token_etheraddr_t cmd_vf_mac_addr_addr = + TOKEN_ETHERADDR_INITIALIZER(struct cmd_vf_mac_addr_result, + address); + +cmdline_parse_inst_t cmd_vf_mac_addr_filter = { + .f = cmd_vf_mac_addr_parsed, + .data = (void *)0, + .help_str = "mac_addr add port X vf Y ethaddr:(X = port number," + "Y = VF number)add MAC address filtering for a VF on port X", + .tokens = { + (void *)&cmd_vf_mac_addr_cmd, + (void *)&cmd_vf_mac_addr_what, + (void *)&cmd_vf_mac_addr_port, + (void *)&cmd_vf_mac_addr_portnum, + (void *)&cmd_vf_mac_addr_vf, + (void *)&cmd_vf_mac_addr_vfnum, + (void *)&cmd_vf_mac_addr_addr, + NULL, + }, +}; + +/* *** ADD/REMOVE A VLAN IDENTIFIER TO/FROM A PORT VLAN RX FILTER *** */ +struct cmd_vf_rx_vlan_filter { + cmdline_fixed_string_t rx_vlan; + cmdline_fixed_string_t what; + uint16_t vlan_id; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t vf; + uint64_t vf_mask; +}; + +static void +cmd_vf_rx_vlan_filter_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_vf_rx_vlan_filter *res = parsed_result; + + if (!strcmp(res->what, "add")) + set_vf_rx_vlan(res->port_id, res->vlan_id,res->vf_mask, 1); + else + set_vf_rx_vlan(res->port_id, res->vlan_id,res->vf_mask, 0); +} + +cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_rx_vlan = + TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter, + rx_vlan, "rx_vlan"); +cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_what = + TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter, + what, "add#rm"); +cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vlanid = + TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter, + vlan_id, UINT16); +cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_port = + TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter, + port, "port"); +cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_portid = + TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter, + port_id, UINT8); +cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_vf = + TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter, + vf, "vf"); +cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vf_mask = + TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter, + vf_mask, UINT64); + +cmdline_parse_inst_t cmd_vf_rxvlan_filter = { + .f = cmd_vf_rx_vlan_filter_parsed, + .data = NULL, + .help_str = "rx_vlan add|rm X port Y vf Z (X = VLAN ID," + "Y = port number,Z = hexadecimal VF mask)", + .tokens = { + (void *)&cmd_vf_rx_vlan_filter_rx_vlan, + (void *)&cmd_vf_rx_vlan_filter_what, + (void *)&cmd_vf_rx_vlan_filter_vlanid, + (void *)&cmd_vf_rx_vlan_filter_port, + (void *)&cmd_vf_rx_vlan_filter_portid, + (void *)&cmd_vf_rx_vlan_filter_vf, + (void *)&cmd_vf_rx_vlan_filter_vf_mask, + NULL, + }, +}; + +/* *** CONFIGURE VM MIRROR VLAN/POOL RULE *** */ +struct cmd_set_mirror_mask_result { + cmdline_fixed_string_t set; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t mirror; + uint8_t rule_id; + cmdline_fixed_string_t what; + cmdline_fixed_string_t value; + cmdline_fixed_string_t dstpool; + uint8_t dstpool_id; + cmdline_fixed_string_t on; +}; + +cmdline_parse_token_string_t cmd_mirror_mask_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, + set, "set"); +cmdline_parse_token_string_t cmd_mirror_mask_port = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, + port, "port"); +cmdline_parse_token_string_t cmd_mirror_mask_portid = + TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, + port_id, UINT8); +cmdline_parse_token_string_t cmd_mirror_mask_mirror = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, + mirror, "mirror-rule"); +cmdline_parse_token_num_t cmd_mirror_mask_ruleid = + TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, + 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"); +cmdline_parse_token_string_t cmd_mirror_mask_value = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, + value, NULL); +cmdline_parse_token_string_t cmd_mirror_mask_dstpool = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, + dstpool, "dst-pool"); +cmdline_parse_token_num_t cmd_mirror_mask_poolid = + TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, + dstpool_id, UINT8); +cmdline_parse_token_string_t cmd_mirror_mask_on = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, + on, "on#off"); + +static void +cmd_set_mirror_mask_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + int ret,nb_item,i; + struct cmd_set_mirror_mask_result *res = parsed_result; + struct rte_eth_vmdq_mirror_conf mr_conf; + + memset(&mr_conf,0,sizeof(struct rte_eth_vmdq_mirror_conf)); + + unsigned int vlan_list[ETH_VMDQ_MAX_VLAN_FILTERS]; + + 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 (nb_item <= 0) + return; + + for(i=0; i < nb_item; i++) { + if (vlan_list[i] > ETHER_MAX_VLAN_ID) { + printf("Invalid vlan_id: must be < 4096\n"); + return; + } + + mr_conf.vlan.vlan_id[i] = (uint16_t)vlan_list[i]; + mr_conf.vlan.vlan_mask |= 1ULL << i; + } + } + + 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, + res->rule_id, 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", + .tokens = { + (void *)&cmd_mirror_mask_set, + (void *)&cmd_mirror_mask_port, + (void *)&cmd_mirror_mask_portid, + (void *)&cmd_mirror_mask_mirror, + (void *)&cmd_mirror_mask_ruleid, + (void *)&cmd_mirror_mask_what, + (void *)&cmd_mirror_mask_value, + (void *)&cmd_mirror_mask_dstpool, + (void *)&cmd_mirror_mask_poolid, + (void *)&cmd_mirror_mask_on, + NULL, + }, +}; + +/* *** CONFIGURE VM MIRROR UDLINK/DOWNLINK RULE *** */ +struct cmd_set_mirror_link_result { + cmdline_fixed_string_t set; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t mirror; + uint8_t rule_id; + cmdline_fixed_string_t what; + cmdline_fixed_string_t dstpool; + uint8_t dstpool_id; + cmdline_fixed_string_t on; +}; + +cmdline_parse_token_string_t cmd_mirror_link_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, + set, "set"); +cmdline_parse_token_string_t cmd_mirror_link_port = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, + port, "port"); +cmdline_parse_token_string_t cmd_mirror_link_portid = + TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, + port_id, UINT8); +cmdline_parse_token_string_t cmd_mirror_link_mirror = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, + mirror, "mirror-rule"); +cmdline_parse_token_num_t cmd_mirror_link_ruleid = + TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, + rule_id, UINT8); +cmdline_parse_token_string_t cmd_mirror_link_what = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, + what, "uplink-mirror#downlink-mirror"); +cmdline_parse_token_string_t cmd_mirror_link_dstpool = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, + dstpool, "dst-pool"); +cmdline_parse_token_num_t cmd_mirror_link_poolid = + TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, + dstpool_id, UINT8); +cmdline_parse_token_string_t cmd_mirror_link_on = + TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, + on, "on#off"); + +static void +cmd_set_mirror_link_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + int ret; + struct cmd_set_mirror_link_result *res = parsed_result; + struct rte_eth_vmdq_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; + + mr_conf.dst_pool = res->dstpool_id; + + 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, + res->rule_id, 0); + + /* check the return value and print it if is < 0 */ + if(ret < 0) + printf("mirror rule add error: (%s)\n", strerror(-ret)); + +} + +cmdline_parse_inst_t cmd_set_mirror_link = { + .f = cmd_set_mirror_link_parsed, + .data = NULL, + .help_str = "set port X mirror-rule Y uplink-mirror|" + "downlink-mirror dst-pool Z on|off", + .tokens = { + (void *)&cmd_mirror_link_set, + (void *)&cmd_mirror_link_port, + (void *)&cmd_mirror_link_portid, + (void *)&cmd_mirror_link_mirror, + (void *)&cmd_mirror_link_ruleid, + (void *)&cmd_mirror_link_what, + (void *)&cmd_mirror_link_dstpool, + (void *)&cmd_mirror_link_poolid, + (void *)&cmd_mirror_link_on, + NULL, + }, +}; + +/* *** RESET VM MIRROR RULE *** */ +struct cmd_rm_mirror_rule_result { + cmdline_fixed_string_t reset; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t mirror; + uint8_t rule_id; +}; + +cmdline_parse_token_string_t cmd_rm_mirror_rule_reset = + TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, + reset, "reset"); +cmdline_parse_token_string_t cmd_rm_mirror_rule_port = + TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, + port, "port"); +cmdline_parse_token_string_t cmd_rm_mirror_rule_portid = + TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result, + port_id, UINT8); +cmdline_parse_token_string_t cmd_rm_mirror_rule_mirror = + TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, + mirror, "mirror-rule"); +cmdline_parse_token_num_t cmd_rm_mirror_rule_ruleid = + TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result, + rule_id, UINT8); + +static void +cmd_reset_mirror_rule_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + int ret; + struct cmd_set_mirror_link_result *res = parsed_result; + /* check rule_id */ + ret = rte_eth_mirror_rule_reset(res->port_id,res->rule_id); + if(ret < 0) + printf("mirror rule remove error: (%s)\n", strerror(-ret)); +} + +cmdline_parse_inst_t cmd_reset_mirror_rule = { + .f = cmd_reset_mirror_rule_parsed, + .data = NULL, + .help_str = "reset port X mirror-rule Y", + .tokens = { + (void *)&cmd_rm_mirror_rule_reset, + (void *)&cmd_rm_mirror_rule_port, + (void *)&cmd_rm_mirror_rule_portid, + (void *)&cmd_rm_mirror_rule_mirror, + (void *)&cmd_rm_mirror_rule_ruleid, + NULL, + }, +}; + /* ******************************************************************************** */ /* list of instructions */ @@ -3833,6 +4568,7 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_set_promisc_mode_all, (cmdline_parse_inst_t *)&cmd_set_allmulti_mode_one, (cmdline_parse_inst_t *)&cmd_set_allmulti_mode_all, + (cmdline_parse_inst_t *)&cmd_set_flush_rx, (cmdline_parse_inst_t *)&cmd_vlan_offload, (cmdline_parse_inst_t *)&cmd_vlan_tpid, (cmdline_parse_inst_t *)&cmd_rx_vlan_filter_all, @@ -3874,6 +4610,15 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_config_burst, (cmdline_parse_inst_t *)&cmd_config_thresh, (cmdline_parse_inst_t *)&cmd_config_threshold, + (cmdline_parse_inst_t *)&cmd_set_vf_rxmode, + (cmdline_parse_inst_t *)&cmd_set_uc_hash_filter, + (cmdline_parse_inst_t *)&cmd_set_uc_all_hash_filter, + (cmdline_parse_inst_t *)&cmd_vf_mac_addr_filter , + (cmdline_parse_inst_t *)&cmd_set_vf_traffic, + (cmdline_parse_inst_t *)&cmd_vf_rxvlan_filter, + (cmdline_parse_inst_t *)&cmd_set_mirror_mask, + (cmdline_parse_inst_t *)&cmd_set_mirror_link, + (cmdline_parse_inst_t *)&cmd_reset_mirror_rule, NULL, }; diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c index 50657df183..5ae65537f0 100644 --- a/app/test-pmd/config.c +++ b/app/test-pmd/config.c @@ -270,6 +270,8 @@ port_infos_display(portid_t port_id) rte_eth_allmulticast_get(port_id) ? "enabled" : "disabled"); printf("Maximum number of MAC addresses: %u\n", (unsigned int)(port->dev_info.max_mac_addrs)); + printf("Maximum number of MAC addresses of hash filtering: %u\n", + (unsigned int)(port->dev_info.max_hash_mac_addrs)); vlan_offload = rte_eth_dev_get_vlan_offload(port_id); if (vlan_offload >= 0){ @@ -893,7 +895,7 @@ dcb_rxq_2_txq_mapping(queueid_t rxq, queueid_t *txq) * - TxPk = (RxPi + 1) if RxPi is even, (RxPi - 1) if RxPi is odd * - TxQl = RxQj * In non-VT mode, - * - TxPk = (RxPi + 1) if RxPi is even, (RxPi - 1) if RxPi is odd + * - TxPk = (RxPi + 1) if RxPi is even, (RxPi - 1) if RxPi is odd * There is a mapping of RxQj to TxQl to be required,and the mapping was implemented * in dcb_rxq_2_txq_mapping function. */ @@ -905,7 +907,7 @@ dcb_fwd_config_setup(void) queueid_t rxq; queueid_t nb_q; lcoreid_t lc_id; - uint8_t sm_id; + uint16_t sm_id; nb_q = nb_rxq; @@ -1096,7 +1098,7 @@ set_fwd_ports_list(unsigned int *portlist, unsigned int nb_pt) for (i = 0; i < nb_pt; i++) { port_id = (portid_t) portlist[i]; if (port_id >= nb_ports) { - printf("Invalid port id %u > %u\n", + printf("Invalid port id %u >= %u\n", (unsigned int) port_id, (unsigned int) nb_ports); return; @@ -1589,3 +1591,42 @@ fdir_set_masks(portid_t port_id, struct rte_fdir_masks *fdir_masks) printf("rte_eth_dev_set_masks_filter for port_id=%d failed " "diag=%d\n", port_id, diag); } + +void +set_vf_traffic(portid_t port_id, uint8_t is_rx, uint16_t vf, uint8_t on) +{ + int diag; + + if (port_id_is_invalid(port_id)) + return; + if (is_rx) + diag = rte_eth_dev_set_vf_rx(port_id,vf,on); + else + diag = rte_eth_dev_set_vf_tx(port_id,vf,on); + if (diag == 0) + return; + if(is_rx) + printf("rte_eth_dev_set_vf_rx for port_id=%d failed " + "diag=%d\n", port_id, diag); + else + printf("rte_eth_dev_set_vf_tx for port_id=%d failed " + "diag=%d\n", port_id, diag); + +} + +void +set_vf_rx_vlan(portid_t port_id, uint16_t vlan_id, uint64_t vf_mask, uint8_t on) +{ + int diag; + + if (port_id_is_invalid(port_id)) + return; + if (vlan_id_is_invalid(vlan_id)) + return; + diag = rte_eth_dev_set_vf_vlan_filter(port_id, vlan_id, vf_mask, on); + if (diag == 0) + return; + printf("rte_eth_dev_set_vf_vlan_filter for port_id=%d failed " + "diag=%d\n", port_id, diag); +} + diff --git a/app/test-pmd/parameters.c b/app/test-pmd/parameters.c index 67e3ad3e0e..dbcc113068 100644 --- a/app/test-pmd/parameters.c +++ b/app/test-pmd/parameters.c @@ -178,6 +178,8 @@ usage(char* progname) printf(" --rx-queue-stats-mapping=(port,queue,mapping)[,(port,queue,mapping]: " "rx queues statistics counters mapping " "(0 <= mapping <= %d).\n", RTE_ETHDEV_QUEUE_STAT_CNTRS - 1); + printf(" --no-flush-rx: avoids flushing all rx streams before" + " starts forwarding\n"); } static int @@ -513,6 +515,7 @@ launch_args_parse(int argc, char** argv) { "rxfreet", 1, 0, 0 }, { "tx-queue-stats-mapping", 1, 0, 0 }, { "rx-queue-stats-mapping", 1, 0, 0 }, + { "no-flush-rx", 0, 0, 0 }, { 0, 0, 0, 0 }, }; @@ -933,6 +936,9 @@ launch_args_parse(int argc, char** argv) "invalid RX queue statistics mapping config entered\n"); } } + if (!strcmp(lgopts[opt_idx].name, "no-flush-rx")) + no_flush_rx = 1; + break; case 'h': usage(argv[0]); diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c index bed6275879..0ca0e33666 100644 --- a/app/test-pmd/testpmd.c +++ b/app/test-pmd/testpmd.c @@ -243,6 +243,12 @@ uint16_t rss_hf = ETH_RSS_IPV4 | ETH_RSS_IPV6; /* RSS IP by default. */ */ uint16_t port_topology = PORT_TOPOLOGY_PAIRED; /* Ports are paired by default */ + +/* + * Avoids to flush all the RX streams before starts forwarding. + */ +uint8_t no_flush_rx = 0; /* flush by default */ + /* * Ethernet device configuration. */ @@ -776,20 +782,22 @@ fwd_stream_stats_display(streamid_t stream_id) } static void -flush_all_rx_queues(void) +flush_fwd_rx_queues(void) { struct rte_mbuf *pkts_burst[MAX_PKT_BURST]; portid_t rxp; + portid_t port_id; queueid_t rxq; uint16_t nb_rx; uint16_t i; uint8_t j; for (j = 0; j < 2; j++) { - for (rxp = 0; rxp < nb_ports; rxp++) { + for (rxp = 0; rxp < cur_fwd_config.nb_fwd_ports; rxp++) { for (rxq = 0; rxq < nb_rxq; rxq++) { + port_id = fwd_ports_ids[rxp]; do { - nb_rx = rte_eth_rx_burst(rxp, rxq, + nb_rx = rte_eth_rx_burst(port_id, rxq, pkts_burst, MAX_PKT_BURST); for (i = 0; i < nb_rx; i++) rte_pktmbuf_free(pkts_burst[i]); @@ -892,12 +900,27 @@ start_packet_forwarding(int with_tx_first) printf("Packet forwarding already started\n"); return; } - if((dcb_test) && (nb_fwd_lcores == 1)) { - printf("In DCB mode,the nb forwarding cores should be larger than 1.\n"); - return; + if(dcb_test) { + for (i = 0; i < nb_fwd_ports; i++) { + pt_id = fwd_ports_ids[i]; + port = &ports[pt_id]; + if (!port->dcb_flag) { + printf("In DCB mode, all forwarding ports must " + "be configured in this mode.\n"); + return; + } + } + if (nb_fwd_lcores == 1) { + printf("In DCB mode,the nb forwarding cores " + "should be larger than 1.\n"); + return; + } } test_done = 0; - flush_all_rx_queues(); + + if(!no_flush_rx) + flush_fwd_rx_queues(); + fwd_config_setup(); rxtx_config_display(); @@ -1030,7 +1053,7 @@ stop_packet_forwarding(void) total_rx_dropped = 0; total_tx_dropped = 0; total_rx_nombuf = 0; - for (i = 0; i < ((cur_fwd_config.nb_fwd_ports + 1) & ~0x1); i++) { + for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) { pt_id = fwd_ports_ids[i]; port = &ports[pt_id]; @@ -1646,6 +1669,8 @@ init_port_dcb_config(portid_t pid,struct dcb_config *dcb_conf) rte_eth_macaddr_get(pid, &rte_port->eth_addr); map_port_queue_stats_mapping_registers(pid, rte_port); + + rte_port->dcb_flag = 1; return 0; } diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h index c531253a39..38d7820e92 100644 --- a/app/test-pmd/testpmd.h +++ b/app/test-pmd/testpmd.h @@ -149,6 +149,7 @@ struct rte_port { uint8_t need_reconfig; /**< need reconfiguring port or not */ uint8_t need_reconfig_queues; /**< need reconfiguring queues or not */ uint8_t rss_flag; /**< enable rss or not */ + uint8_t dcb_flag; /**< enable dcb */ struct rte_eth_rxconf rx_conf; /**< rx configuration */ struct rte_eth_txconf tx_conf; /**< tx configuration */ }; @@ -269,6 +270,7 @@ extern uint16_t verbose_level; /**< Drives messages being displayed, if any. */ extern uint8_t interactive; extern uint8_t numa_support; /**< set by "--numa" parameter */ extern uint16_t port_topology; /**< set by "--port-topology" parameter */ +extern uint8_t no_flush_rx; /**