virtual void clear_extended_stats(CPhyEthIF * _if)=0;
virtual int wait_for_stable_link();
virtual void wait_after_link_up();
- virtual bool flow_control_disable_supported(){return m_port_attr->is_fc_change_supported();}
virtual bool hw_rx_stat_supported(){return false;}
virtual int get_rx_stats(CPhyEthIF * _if, uint32_t *pkts, uint32_t *prev_pkts, uint32_t *bytes, uint32_t *prev_bytes
, int min, int max) {return -1;}
virtual int verify_fw_ver(int i) {return 0;}
virtual CFlowStatParser *get_flow_stat_parser();
virtual int set_rcv_all(CPhyEthIF * _if, bool set_on)=0;
- TRexPortAttr * m_port_attr;
+ virtual TRexPortAttr * create_port_attr(uint8_t port_id) = 0;
};
public:
CTRexExtendedDriverBase1G(){
- m_port_attr = new TRexPortAttr(global_platform_cfg_info.m_if_list.size(), false, true);
+ }
+
+ TRexPortAttr * create_port_attr(uint8_t port_id) {
+ return new DpdkTRexPortAttr(port_id, false, true);
}
static CTRexExtendedDriverBase * create(){
CTRexExtendedDriverBase1GVm(){
/* we are working in mode that we have 1 queue for rx and one queue for tx*/
CGlobalInfo::m_options.preview.set_vm_one_queue_enable(true);
- m_port_attr = new TRexPortAttr(global_platform_cfg_info.m_if_list.size(), true, true);
+ }
+
+ TRexPortAttr * create_port_attr(uint8_t port_id) {
+ return new DpdkTRexPortAttr(port_id, true, true);
}
virtual bool has_crc_added() {
class CTRexExtendedDriverBase10G : public CTRexExtendedDriverBase {
public:
CTRexExtendedDriverBase10G(){
- m_port_attr = new TRexPortAttr(global_platform_cfg_info.m_if_list.size(), false, true);
+ }
+
+ TRexPortAttr * create_port_attr(uint8_t port_id) {
+ return new DpdkTRexPortAttr(port_id, false, true);
}
static CTRexExtendedDriverBase * create(){
// If we want to support more counters in case of card having less interfaces, we
// Will have to identify the number of interfaces dynamically.
m_if_per_card = 4;
+ }
+
+ TRexPortAttr * create_port_attr(uint8_t port_id) {
// disabling flow control on 40G using DPDK API causes the interface to malfunction
- m_port_attr = new TRexPortAttr(global_platform_cfg_info.m_if_list.size(), false, false);
+ return new DpdkTRexPortAttr(port_id, false, false);
}
static CTRexExtendedDriverBase * create(){
class CTRexExtendedDriverBaseVIC : public CTRexExtendedDriverBase40G {
public:
CTRexExtendedDriverBaseVIC(){
- m_port_attr = new TRexPortAttr(global_platform_cfg_info.m_if_list.size(), false, false);
+ }
+
+ TRexPortAttr * create_port_attr(uint8_t port_id) {
+ return new DpdkTRexPortAttr(port_id, false, false);
}
static CTRexExtendedDriverBase * create(){
Get user frienly devices description from saved env. var
Changes certain attributes based on description
*/
-void TRexPortAttr::update_descriptions(){
+void DpdkTRexPortAttr::update_description(){
struct rte_pci_addr pci_addr;
char pci[16];
char * envvar;
std::string pci_envvar_name;
- for (uint8_t port_id=0; port_id<total_ports; port_id++) {
- pci_addr = rte_eth_devices[port_id].pci_dev->addr;
- snprintf(pci, sizeof(pci), "%04x:%02x:%02x.%d", pci_addr.domain, pci_addr.bus, pci_addr.devid, pci_addr.function);
- intf_info_st[port_id].pci_addr = pci;
- pci_envvar_name = "pci" + intf_info_st[port_id].pci_addr;
- std::replace(pci_envvar_name.begin(), pci_envvar_name.end(), ':', '_');
- std::replace(pci_envvar_name.begin(), pci_envvar_name.end(), '.', '_');
- envvar = std::getenv(pci_envvar_name.c_str());
- if (envvar) {
- intf_info_st[port_id].description = envvar;
- } else {
- intf_info_st[port_id].description = "Unknown";
- }
- if (intf_info_st[port_id].description.find("82599ES") != std::string::npos) { // works for 82599EB etc. DPDK does not distinguish them
- flag_is_link_change_supported = false;
- }
- if (intf_info_st[port_id].description.find("82545EM") != std::string::npos) { // in virtual E1000, DPDK claims fc is supported, but it's not
- flag_is_fc_change_supported = false;
- flag_is_led_change_supported = false;
- }
- if ( CGlobalInfo::m_options.preview.getVMode() > 0){
- printf("port %d desc: %s\n", port_id, intf_info_st[port_id].description.c_str());
- }
+ pci_addr = rte_eth_devices[m_port_id].pci_dev->addr;
+ snprintf(pci, sizeof(pci), "%04x:%02x:%02x.%d", pci_addr.domain, pci_addr.bus, pci_addr.devid, pci_addr.function);
+ intf_info_st.pci_addr = pci;
+ pci_envvar_name = "pci" + intf_info_st.pci_addr;
+ std::replace(pci_envvar_name.begin(), pci_envvar_name.end(), ':', '_');
+ std::replace(pci_envvar_name.begin(), pci_envvar_name.end(), '.', '_');
+ envvar = std::getenv(pci_envvar_name.c_str());
+ if (envvar) {
+ intf_info_st.description = envvar;
+ } else {
+ intf_info_st.description = "Unknown";
+ }
+ if (intf_info_st.description.find("82599ES") != std::string::npos) { // works for 82599EB etc. DPDK does not distinguish them
+ flag_is_link_change_supported = false;
+ }
+ if (intf_info_st.description.find("82545EM") != std::string::npos) { // in virtual E1000, DPDK claims fc is supported, but it's not
+ flag_is_fc_change_supported = false;
+ flag_is_led_change_supported = false;
+ }
+ if ( CGlobalInfo::m_options.preview.getVMode() > 0){
+ printf("port %d desc: %s\n", m_port_id, intf_info_st.description.c_str());
}
}
-int TRexPortAttr::set_led(uint8_t port_id, bool on){
+int DpdkTRexPortAttr::set_led(bool on){
if (on) {
- return rte_eth_led_on(port_id);
+ return rte_eth_led_on(m_port_id);
}else{
- return rte_eth_led_off(port_id);
+ return rte_eth_led_off(m_port_id);
}
}
-int TRexPortAttr::get_flow_ctrl(uint8_t port_id, int &mode) {
- int ret = rte_eth_dev_flow_ctrl_get(port_id, &fc_conf_tmp);
+int DpdkTRexPortAttr::get_flow_ctrl(int &mode) {
+ int ret = rte_eth_dev_flow_ctrl_get(m_port_id, &fc_conf_tmp);
if (ret) {
return ret;
}
return 0;
}
-int TRexPortAttr::set_flow_ctrl(uint8_t port_id, int mode) {
+int DpdkTRexPortAttr::set_flow_ctrl(int mode) {
if (!flag_is_fc_change_supported) {
return -ENOTSUP;
}
- int ret = rte_eth_dev_flow_ctrl_get(port_id, &fc_conf_tmp);
+ int ret = rte_eth_dev_flow_ctrl_get(m_port_id, &fc_conf_tmp);
if (ret) {
return ret;
}
fc_conf_tmp.mode = (enum rte_eth_fc_mode) mode;
- return rte_eth_dev_flow_ctrl_set(port_id, &fc_conf_tmp);
+ return rte_eth_dev_flow_ctrl_set(m_port_id, &fc_conf_tmp);
}
-void TRexPortAttr::reset_xstats(uint8_t port_id) {
- rte_eth_xstats_reset(port_id);
+void DpdkTRexPortAttr::reset_xstats() {
+ rte_eth_xstats_reset(m_port_id);
}
-int TRexPortAttr::get_xstats_values(uint8_t port_id, xstats_values_t &xstats_values) {
- int size = rte_eth_xstats_get(port_id, NULL, 0);
+int DpdkTRexPortAttr::get_xstats_values(xstats_values_t &xstats_values) {
+ int size = rte_eth_xstats_get(m_port_id, NULL, 0);
if (size < 0) {
return size;
}
xstats_values_tmp.resize(size);
xstats_values.resize(size);
- size = rte_eth_xstats_get(port_id, xstats_values_tmp.data(), size);
+ size = rte_eth_xstats_get(m_port_id, xstats_values_tmp.data(), size);
if (size < 0) {
return size;
}
return 0;
}
-int TRexPortAttr::get_xstats_names(uint8_t port_id, xstats_names_t &xstats_names){
- int size = rte_eth_xstats_get_names(port_id, NULL, 0);
+int DpdkTRexPortAttr::get_xstats_names(xstats_names_t &xstats_names){
+ int size = rte_eth_xstats_get_names(m_port_id, NULL, 0);
if (size < 0) {
return size;
}
xstats_names_tmp.resize(size);
xstats_names.resize(size);
- size = rte_eth_xstats_get_names(port_id, xstats_names_tmp.data(), size);
+ size = rte_eth_xstats_get_names(m_port_id, xstats_names_tmp.data(), size);
if (size < 0) {
return size;
}
return 0;
}
-void TRexPortAttr::dump_link(uint8_t port_id, FILE *fd){
- fprintf(fd,"port : %d \n",(int)port_id);
+void DpdkTRexPortAttr::dump_link(FILE *fd){
+ fprintf(fd,"port : %d \n",(int)m_port_id);
fprintf(fd,"------------\n");
fprintf(fd,"link : ");
- if (m_link[port_id].link_status) {
+ if (m_link.link_status) {
fprintf(fd," link : Link Up - speed %u Mbps - %s\n",
- (unsigned) m_link[port_id].link_speed,
- (m_link[port_id].link_duplex == ETH_LINK_FULL_DUPLEX) ?
+ (unsigned) m_link.link_speed,
+ (m_link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
("full-duplex") : ("half-duplex\n"));
} else {
fprintf(fd," Link Down\n");
}
- fprintf(fd,"promiscuous : %d \n",get_promiscuous(port_id));
+ fprintf(fd,"promiscuous : %d \n",get_promiscuous());
}
-void TRexPortAttr::update_device_info(uint8_t port_id){
- rte_eth_dev_info_get(port_id, &dev_info[port_id]);
+void DpdkTRexPortAttr::update_device_info(){
+ rte_eth_dev_info_get(m_port_id, &dev_info);
}
-void TRexPortAttr::get_supported_speeds(uint8_t port_id, supp_speeds_t &supp_speeds){
- uint32_t speed_capa = dev_info[port_id].speed_capa;
+void DpdkTRexPortAttr::get_supported_speeds(supp_speeds_t &supp_speeds){
+ uint32_t speed_capa = dev_info.speed_capa;
if (speed_capa & ETH_LINK_SPEED_1G)
supp_speeds.push_back(ETH_SPEED_NUM_1G);
if (speed_capa & ETH_LINK_SPEED_10G)
supp_speeds.push_back(ETH_SPEED_NUM_100G);
}
-void TRexPortAttr::update_link_status(uint8_t port_id){
- rte_eth_link_get(port_id, &m_link[port_id]);
+void DpdkTRexPortAttr::update_link_status(){
+ rte_eth_link_get(m_port_id, &m_link);
}
-bool TRexPortAttr::update_link_status_nowait(uint8_t port_id){
+bool DpdkTRexPortAttr::update_link_status_nowait(){
rte_eth_link new_link;
bool changed = false;
- rte_eth_link_get_nowait(port_id, &new_link);
- if (new_link.link_speed != m_link[port_id].link_speed ||
- new_link.link_duplex != m_link[port_id].link_duplex ||
- new_link.link_autoneg != m_link[port_id].link_autoneg ||
- new_link.link_status != m_link[port_id].link_status) {
+ rte_eth_link_get_nowait(m_port_id, &new_link);
+ if (new_link.link_speed != m_link.link_speed ||
+ new_link.link_duplex != m_link.link_duplex ||
+ new_link.link_autoneg != m_link.link_autoneg ||
+ new_link.link_status != m_link.link_status) {
changed = true;
}
- m_link[port_id] = new_link;
+ m_link = new_link;
return changed;
}
-int TRexPortAttr::add_mac(uint8_t port_id, char * mac){
+int DpdkTRexPortAttr::add_mac(char * mac){
struct ether_addr mac_addr;
for (int i=0; i<6;i++) {
mac_addr.addr_bytes[i] =mac[i];
}
- return rte_eth_dev_mac_addr_add(port_id, &mac_addr,0);
+ return rte_eth_dev_mac_addr_add(m_port_id, &mac_addr,0);
}
-int TRexPortAttr::set_promiscuous(uint8_t port_id, bool enable){
+int DpdkTRexPortAttr::set_promiscuous(bool enable){
if (enable) {
- rte_eth_promiscuous_enable(port_id);
+ rte_eth_promiscuous_enable(m_port_id);
}else{
- rte_eth_promiscuous_disable(port_id);
+ rte_eth_promiscuous_disable(m_port_id);
}
return 0;
}
-int TRexPortAttr::set_link_up(uint8_t port_id, bool up){
+int DpdkTRexPortAttr::set_link_up(bool up){
if (up) {
- return rte_eth_dev_set_link_up(port_id);
+ return rte_eth_dev_set_link_up(m_port_id);
}else{
- return rte_eth_dev_set_link_down(port_id);
+ return rte_eth_dev_set_link_down(m_port_id);
}
}
-bool TRexPortAttr::get_promiscuous(uint8_t port_id){
- int ret=rte_eth_promiscuous_get(port_id);
+bool DpdkTRexPortAttr::get_promiscuous(){
+ int ret=rte_eth_promiscuous_get(m_port_id);
if (ret<0) {
rte_exit(EXIT_FAILURE, "rte_eth_promiscuous_get: "
"err=%d, port=%u\n",
- ret, port_id);
+ ret, m_port_id);
}
return ( ret?true:false);
}
-void TRexPortAttr::macaddr_get(uint8_t port_id, struct ether_addr *mac_addr){
- rte_eth_macaddr_get(port_id , mac_addr);
+void DpdkTRexPortAttr::macaddr_get(struct ether_addr *mac_addr){
+ rte_eth_macaddr_get(m_port_id , mac_addr);
}
int CPhyEthIF::dump_fdir_global_stats(FILE *fd) {
CRxCoreStateless m_rx_sl; // stateless RX core
CTrexGlobalIoMode m_io_modes;
CTRexExtendedDriverBase * m_drv;
- TRexPortAttr * m_port_attr;
private:
CLatencyHWPort m_latency_vports[TREX_MAX_PORTS]; /* read hardware driver */
int i;
for (i=0; i<m_max_ports; i++) {
CPhyEthIF * _if=&m_ports[i];
- m_port_attr->update_link_status(i);
+ _if->get_port_attr()->update_link_status();
if ( dump ){
_if->dump_stats(stdout);
}
- if ( m_port_attr->is_link_up(i) == false){
+ if ( _if->get_port_attr()->is_link_up() == false){
all_link_are=false;
break;
}
_if->configure_rx_duplicate_rules();
if ( ! get_vm_one_queue_enable() && ! CGlobalInfo::m_options.preview.get_is_disable_flow_control_setting()
- && get_ex_drv()->flow_control_disable_supported()) {
+ && _if->get_port_attr()->is_fc_change_supported()) {
_if->disable_flow_control();
}
- m_port_attr->add_mac(i, (char *)CGlobalInfo::m_options.get_src_mac_addr(i));
+ _if->get_port_attr()->add_mac((char *)CGlobalInfo::m_options.get_src_mac_addr(i));
fflush(stdout);
}
CTRexExtendedDriverDb::Ins()->set_driver_name(dev_info.driver_name);
m_drv = CTRexExtendedDriverDb::Ins()->get_drv();
- m_port_attr = m_drv->m_port_attr;
// check if firmware version is new enough
for (i = 0; i < m_max_ports; i++) {
void CGlobalTRex::dump_links_status(FILE *fd){
for (int i=0; i<m_max_ports; i++) {
- m_port_attr->update_link_status_nowait(i);
- m_port_attr->dump_link(i, fd);
+ m_ports[i].get_port_attr()->update_link_status_nowait();
+ m_ports[i].get_port_attr()->dump_link(fd);
}
}
CGlobalTRex:: publish_async_port_attr_changed(uint8_t port_id) {
Json::Value data;
data["port_id"] = port_id;
+ TRexPortAttr * _attr = m_ports[port_id].get_port_attr();
/* attributes */
- data["attr"]["speed"] = m_port_attr->get_link_speed(port_id);
- data["attr"]["promiscuous"]["enabled"] = m_port_attr->get_promiscuous(port_id);
- data["attr"]["link"]["up"] = m_port_attr->is_link_up(port_id);
+ data["attr"]["speed"] = _attr->get_link_speed();
+ data["attr"]["promiscuous"]["enabled"] = _attr->get_promiscuous();
+ data["attr"]["link"]["up"] = _attr->is_link_up();
int mode;
- int ret = get_stateless_obj()->get_platform_api()->getPortAttrObj()->get_flow_ctrl(port_id, mode);
+ int ret = _attr->get_flow_ctrl(mode);
if (ret != 0) {
mode = -1;
}
// update speed, link up/down etc.
for (int i=0; i<m_max_ports; i++) {
- bool changed = m_port_attr->update_link_status_nowait(i);
+ bool changed = m_ports[i].get_port_attr()->update_link_status_nowait();
if (changed) {
publish_async_port_attr_changed(i);
}
m_last_rx_rate = 0.0;
m_last_tx_rate = 0.0;
m_last_tx_pps = 0.0;
+ m_port_attr = g_trex.m_drv->create_port_attr(portid);
return true;
}
*
**********************************************************/
int TrexDpdkPlatformApi::get_xstats_values(uint8_t port_id, xstats_values_t &xstats_values) const {
- return g_trex.m_port_attr->get_xstats_values(port_id, xstats_values);
+ return g_trex.m_ports[port_id].get_port_attr()->get_xstats_values(xstats_values);
}
int TrexDpdkPlatformApi::get_xstats_names(uint8_t port_id, xstats_names_t &xstats_names) const {
- return g_trex.m_port_attr->get_xstats_names(port_id, xstats_names);
+ return g_trex.m_ports[port_id].get_port_attr()->get_xstats_names(xstats_names);
}
/* mac INFO */
/* hardware */
- g_trex.m_port_attr->macaddr_get(interface_id, &rte_mac_addr);
+ g_trex.m_ports[interface_id].get_port_attr()->macaddr_get(&rte_mac_addr);
assert(ETHER_ADDR_LEN == 6);
/* software */
return CTRexExtendedDriverDb::Ins()->get_drv()->get_flow_stat_parser();
}
-TRexPortAttr *TrexDpdkPlatformApi::getPortAttrObj() const {
- return g_trex.m_port_attr;
+TRexPortAttr *TrexDpdkPlatformApi::getPortAttrObj(uint8_t port_id) const {
+ return g_trex.m_ports[port_id].get_port_attr();
}
/**
port->get_macaddr(hw_macaddr, src_macaddr, dst_macaddr);
port->get_pci_info(pci_addr, numa);
- main->get_platform_api()->getPortAttrObj()->get_description(i, description);
- main->get_platform_api()->getPortAttrObj()->get_supported_speeds(i, supp_speeds);
+ main->get_platform_api()->getPortAttrObj(i)->get_description(description);
+ main->get_platform_api()->getPortAttrObj(i)->get_supported_speeds(supp_speeds);
section["ports"][i]["index"] = i;
}
section["ports"][i]["rx"]["counters"] = port->get_rx_count_num();
section["ports"][i]["speed"] = (uint16_t) speed / 1000;
- section["ports"][i]["is_fc_supported"] = get_stateless_obj()->get_platform_api()->getPortAttrObj()->is_fc_change_supported();
- section["ports"][i]["is_led_supported"] = get_stateless_obj()->get_platform_api()->getPortAttrObj()->is_led_change_supported();
- section["ports"][i]["is_link_supported"] = get_stateless_obj()->get_platform_api()->getPortAttrObj()->is_link_change_supported();
- section["ports"][i]["is_virtual"] = get_stateless_obj()->get_platform_api()->getPortAttrObj()->is_virtual();
+ section["ports"][i]["is_fc_supported"] = get_stateless_obj()->get_platform_api()->getPortAttrObj(i)->is_fc_change_supported();
+ section["ports"][i]["is_led_supported"] = get_stateless_obj()->get_platform_api()->getPortAttrObj(i)->is_led_change_supported();
+ section["ports"][i]["is_link_supported"] = get_stateless_obj()->get_platform_api()->getPortAttrObj(i)->is_link_change_supported();
+ section["ports"][i]["is_virtual"] = get_stateless_obj()->get_platform_api()->getPortAttrObj(i)->is_virtual();
section["ports"][i]["supp_speeds"] = Json::arrayValue;
for (int speed_id=0; speed_id<supp_speeds.size(); speed_id++) {
section["ports"][i]["supp_speeds"].append(supp_speeds[speed_id]);
for (const std::string &name : attr.getMemberNames()) {
if (name == "promiscuous") {
bool enabled = parse_bool(attr[name], "enabled", result);
- ret = get_stateless_obj()->get_platform_api()->getPortAttrObj()->set_promiscuous(port_id, enabled);
+ ret = get_stateless_obj()->get_platform_api()->getPortAttrObj(port_id)->set_promiscuous(enabled);
}
else if (name == "link_status") {
bool up = parse_bool(attr[name], "up", result);
- ret = get_stateless_obj()->get_platform_api()->getPortAttrObj()->set_link_up(port_id, up);
+ ret = get_stateless_obj()->get_platform_api()->getPortAttrObj(port_id)->set_link_up(up);
}
else if (name == "led_status") {
bool on = parse_bool(attr[name], "on", result);
- ret = get_stateless_obj()->get_platform_api()->getPortAttrObj()->set_led(port_id, on);
+ ret = get_stateless_obj()->get_platform_api()->getPortAttrObj(port_id)->set_led(on);
} else if (name == "flow_ctrl_mode") {
int mode = parse_int(attr[name], "mode", result);
- ret = get_stateless_obj()->get_platform_api()->getPortAttrObj()->set_flow_ctrl(port_id, mode);
+ ret = get_stateless_obj()->get_platform_api()->getPortAttrObj(port_id)->set_flow_ctrl(mode);
} else {
generate_execute_err(result, "Not recognized attribute: " + name);
break;
result["result"]["owner"] = (port->get_owner().is_free() ? "" : port->get_owner().get_name());
result["result"]["state"] = port->get_state_as_string();
result["result"]["max_stream_id"] = port->get_max_stream_id();
- result["result"]["speed"] = get_stateless_obj()->get_platform_api()->getPortAttrObj()->get_link_speed(port_id);
+ result["result"]["speed"] = get_stateless_obj()->get_platform_api()->getPortAttrObj(port_id)->get_link_speed();
/* attributes */
- result["result"]["attr"]["promiscuous"]["enabled"] = get_stateless_obj()->get_platform_api()->getPortAttrObj()->get_promiscuous(port_id);
- result["result"]["attr"]["link"]["up"] = get_stateless_obj()->get_platform_api()->getPortAttrObj()->is_link_up(port_id);
+ result["result"]["attr"]["promiscuous"]["enabled"] = get_stateless_obj()->get_platform_api()->getPortAttrObj(port_id)->get_promiscuous();
+ result["result"]["attr"]["link"]["up"] = get_stateless_obj()->get_platform_api()->getPortAttrObj(port_id)->is_link_up();
int mode;
- int ret = get_stateless_obj()->get_platform_api()->getPortAttrObj()->get_flow_ctrl(port_id, mode);
+ int ret = get_stateless_obj()->get_platform_api()->getPortAttrObj(port_id)->get_flow_ctrl(mode);
if (ret != 0) {
mode = -1;
}
class TRexPortAttr {
public:
- TRexPortAttr(uint8_t total_ports, bool is_virtual, bool fc_change_allowed) : total_ports(total_ports) {
- flag_is_virtual = is_virtual;
- m_link.resize(total_ports);
- intf_info_st.resize(total_ports);
- dev_info.resize(total_ports);
- int tmp;
- flag_is_fc_change_supported = fc_change_allowed && (get_flow_ctrl(0, tmp) != -ENOTSUP);
- flag_is_led_change_supported = (set_led(0, true) != -ENOTSUP);
- flag_is_link_change_supported = (set_link_up(0, true) != -ENOTSUP);
- update_descriptions();
- for (int i=0; i<total_ports; i++) {
- update_device_info(i);
- }
- }
+ virtual ~TRexPortAttr(){}
/* UPDATES */
- virtual void update_link_status(uint8_t port_id);
- virtual bool update_link_status_nowait(uint8_t port_id); // returns true if the status was changed
- virtual void update_device_info(uint8_t port_id);
- virtual void reset_xstats(uint8_t port_id);
- virtual void update_descriptions();
+ virtual void update_link_status() = 0;
+ virtual bool update_link_status_nowait() = 0; // returns true if the status was changed
+ virtual void update_device_info() = 0;
+ virtual void reset_xstats() = 0;
+ virtual void update_description() = 0;
/* GETTERS */
- virtual bool get_promiscuous(uint8_t port_id);
- virtual void macaddr_get(uint8_t port_id, struct ether_addr *mac_addr);
- virtual uint32_t get_link_speed(uint8_t port_id) { return m_link[port_id].link_speed; } // L1 Mbps
- virtual bool is_link_duplex(uint8_t port_id) { return (m_link[port_id].link_duplex ? true : false); }
- virtual bool is_link_autoneg(uint8_t port_id) { return (m_link[port_id].link_autoneg ? true : false); }
- virtual bool is_link_up(uint8_t port_id) { return (m_link[port_id].link_status ? true : false); }
- virtual int get_xstats_values(uint8_t port_id, xstats_values_t &xstats_values);
- virtual int get_xstats_names(uint8_t port_id, xstats_names_t &xstats_names);
- virtual int get_flow_ctrl(uint8_t port_id, int &mode);
+ virtual bool get_promiscuous() = 0;
+ virtual void macaddr_get(struct ether_addr *mac_addr) = 0;
+ virtual uint32_t get_link_speed() { return m_link.link_speed; } // L1 Mbps
+ virtual bool is_link_duplex() { return (m_link.link_duplex ? true : false); }
+ virtual bool is_link_autoneg() { return (m_link.link_autoneg ? true : false); }
+ virtual bool is_link_up() { return (m_link.link_status ? true : false); }
+ virtual int get_xstats_values(xstats_values_t &xstats_values) = 0;
+ virtual int get_xstats_names(xstats_names_t &xstats_names) = 0;
+ virtual int get_flow_ctrl(int &mode) = 0;
virtual bool is_virtual() { return flag_is_virtual; }
virtual bool is_fc_change_supported() { return flag_is_fc_change_supported; }
virtual bool is_led_change_supported() { return flag_is_led_change_supported; }
virtual bool is_link_change_supported() { return flag_is_link_change_supported; }
- virtual void get_description(uint8_t port_id, std::string &description) { description = intf_info_st[port_id].description; }
- virtual void get_supported_speeds(uint8_t port_id, supp_speeds_t &supp_speeds);
+ virtual void get_description(std::string &description) { description = intf_info_st.description; }
+ virtual void get_supported_speeds(supp_speeds_t &supp_speeds) = 0;
/* SETTERS */
- virtual int set_promiscuous(uint8_t port_id, bool enabled);
- virtual int add_mac(uint8_t port_id, char * mac);
- virtual int set_link_up(uint8_t port_id, bool up);
- virtual int set_flow_ctrl(uint8_t port_id, int mode);
- virtual int set_led(uint8_t port_id, bool on);
-
+ virtual int set_promiscuous(bool enabled) = 0;
+ virtual int add_mac(char * mac) = 0;
+ virtual int set_link_up(bool up) = 0;
+ virtual int set_flow_ctrl(int mode) = 0;
+ virtual int set_led(bool on) = 0;
/* DUMPS */
- virtual void dump_link(uint8_t port_id, FILE *fd);
+ virtual void dump_link(FILE *fd) = 0;
-private:
- const uint8_t total_ports;
- rte_eth_fc_conf fc_conf_tmp;
- std::vector<rte_eth_link> m_link;
- std::vector<struct rte_eth_dev_info> dev_info;
- std::vector<struct rte_eth_xstat> xstats_values_tmp;
- std::vector<struct rte_eth_xstat_name> xstats_names_tmp;
+protected:
+ uint8_t m_port_id;
+ rte_eth_link m_link;
+ struct rte_eth_dev_info dev_info;
bool flag_is_virtual;
bool flag_is_fc_change_supported;
bool flag_is_led_change_supported;
bool flag_is_link_change_supported;
- struct mac_cfg_st {
- uint8_t hw_macaddr[6];
- uint8_t src_macaddr[6];
- uint8_t dst_macaddr[6];
- };
-
- struct intf_info_st_type {
- mac_cfg_st mac_info;
+ struct intf_info_st {
std::string pci_addr;
std::string description;
int numa_node;
- };
+ }intf_info_st;
+
+};
+
+class DpdkTRexPortAttr : public TRexPortAttr {
+public:
+
+ DpdkTRexPortAttr(uint8_t port_id, bool is_virtual, bool fc_change_allowed) {
+ m_port_id = port_id;
+ flag_is_virtual = is_virtual;
+ int tmp;
+ flag_is_fc_change_supported = fc_change_allowed && (get_flow_ctrl(tmp) != -ENOTSUP);
+ flag_is_led_change_supported = (set_led(true) != -ENOTSUP);
+ flag_is_link_change_supported = (set_link_up(true) != -ENOTSUP);
+ update_description();
+ update_device_info();
+ }
+
+/* UPDATES */
+ virtual void update_link_status();
+ virtual bool update_link_status_nowait(); // returns true if the status was changed
+ virtual void update_device_info();
+ virtual void reset_xstats();
+ virtual void update_description();
+
+/* GETTERS */
+ virtual bool get_promiscuous();
+ virtual void macaddr_get(struct ether_addr *mac_addr);
+ virtual int get_xstats_values(xstats_values_t &xstats_values);
+ virtual int get_xstats_names(xstats_names_t &xstats_names);
+ virtual int get_flow_ctrl(int &mode);
+ virtual void get_supported_speeds(supp_speeds_t &supp_speeds);
+
+/* SETTERS */
+ virtual int set_promiscuous(bool enabled);
+ virtual int add_mac(char * mac);
+ virtual int set_link_up(bool up);
+ virtual int set_flow_ctrl(int mode);
+ virtual int set_led(bool on);
+
+
+/* DUMPS */
+ virtual void dump_link(FILE *fd);
- std::vector <intf_info_st_type> intf_info_st;
+private:
+ rte_eth_fc_conf fc_conf_tmp;
+ std::vector <struct rte_eth_xstat> xstats_values_tmp;
+ std::vector <struct rte_eth_xstat_name> xstats_names_tmp;
+
+};
+
+
+class SimTRexPortAttr : public TRexPortAttr {
+public:
+ SimTRexPortAttr() {
+ m_link.link_speed = 10000;
+ m_link.link_duplex = 1;
+ m_link.link_autoneg = 0;
+ m_link.link_status = 1;
+ flag_is_virtual = true;
+ flag_is_fc_change_supported = false;
+ flag_is_led_change_supported = false;
+ flag_is_link_change_supported = false;
+ }
+ /* DUMMY */
+ void update_link_status() {}
+ bool update_link_status_nowait() { return false; }
+ void update_device_info() {}
+ void reset_xstats() {}
+ void update_description() {}
+ bool get_promiscuous() { return false; }
+ void macaddr_get(struct ether_addr *mac_addr) {}
+ int get_xstats_values(xstats_values_t &xstats_values) { return -ENOTSUP; }
+ int get_xstats_names(xstats_names_t &xstats_names) { return -ENOTSUP; }
+ int get_flow_ctrl(int &mode) { return -ENOTSUP; }
+ void get_description(std::string &description) {}
+ void get_supported_speeds(supp_speeds_t &supp_speeds) {}
+ int set_promiscuous(bool enabled) { return -ENOTSUP; }
+ int add_mac(char * mac) { return -ENOTSUP; }
+ int set_link_up(bool up) { return -ENOTSUP; }
+ int set_flow_ctrl(int mode) { return -ENOTSUP; }
+ int set_led(bool on) { return -ENOTSUP; }
+ void dump_link(FILE *fd) {}
};
Code Review / trex.git / commitdiff