Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright (C), 2025, Wuxi Stars Micro System Technologies Co., Ltd.
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <rte_malloc.h>
       6                 :            : #include <arpa/inet.h>
       7                 :            : 
       8                 :            : #include "sxe2_common_log.h"
       9                 :            : #include "sxe2_ethdev.h"
      10                 :            : #include "sxe2_dump.h"
      11                 :            : #include "sxe2_stats.h"
      12                 :            : 
      13                 :            : static void
      14                 :          0 : sxe2_dump_dev_feature_capability(FILE *file, struct rte_eth_dev *dev)
      15                 :            : {
      16                 :          0 :         uint32_t i;
      17                 :          0 :         struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
      18                 :          0 :         const struct {
      19                 :            :                 uint32_t cap_bit;
      20                 :            :                 const char *name;
      21                 :          0 :         } caps_name[] = {
      22                 :            :                 {SXE2_DEV_CAPS_OFFLOAD_L2, "L2"},
      23                 :            :                 {SXE2_DEV_CAPS_OFFLOAD_VLAN, "VLAN"},
      24                 :            :                 {SXE2_DEV_CAPS_OFFLOAD_IPSEC, "IPSEC"},
      25                 :            :                 {SXE2_DEV_CAPS_OFFLOAD_RSS, "RSS"},
      26                 :            :                 {SXE2_DEV_CAPS_OFFLOAD_FNAV, "FNAV"},
      27                 :            :                 {SXE2_DEV_CAPS_OFFLOAD_TM, "TM"},
      28                 :            :                 {SXE2_DEV_CAPS_OFFLOAD_PTP, "PTP"},
      29                 :            :         };
      30         [ #  # ]:          0 :         if (adapter->is_dev_repr)
      31                 :          0 :                 goto l_end;
      32                 :            : 
      33                 :          0 :         fprintf(file, "  - Dev Capability:\n");
      34         [ #  # ]:          0 :         for (i = 0; i < RTE_DIM(caps_name); i++) {
      35                 :          0 :                 fprintf(file, "\t  -- support %s: %s\n", caps_name[i].name,
      36         [ #  # ]:          0 :                         (adapter->cap_flags & caps_name[i].cap_bit) ? "Yes" :
      37                 :            :                                                                          "No");
      38                 :            :         }
      39                 :          0 : l_end:
      40                 :          0 :         return;
      41                 :            : }
      42                 :            : 
      43                 :            : static void
      44                 :          0 : sxe2_dump_device_basic_info(FILE *file, struct rte_eth_dev *dev)
      45                 :            : {
      46                 :          0 :         struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
      47                 :            : 
      48                 :          0 :         fprintf(file,
      49                 :            :                 "  - Device Base Info:\n"
      50                 :            :                 "\t  -- name: %s\n"
      51                 :            :                 "\t  -- pf_idx: %u port_idx: %u\n"
      52                 :            :                 "\t  -- tx_mode_flags: 0x%x rx_mode_flags: 0x%x\n"
      53                 :            :                 "\t  -- flow_isolate_cfg: 0x%x flow_isolated: 0x%x\n"
      54                 :            :                 "\t  -- dev_type: 0x%x is_switchdev: 0x%x\n"
      55                 :            :                 "\t  -- is_dev_repr: 0x%x dev_port_id: 0x%x\n"
      56                 :            :                 "\t  -- dev_flags: 0x%x\n"
      57                 :            :                 "\t  -- intr_conf lsc: %u rxq: %u rmv: %u\n",
      58                 :          0 :                 dev->data->name,
      59                 :          0 :                 adapter->pf_idx, adapter->port_idx,
      60                 :            :                 adapter->tx_mode_flags, adapter->rx_mode_flags,
      61                 :          0 :                 adapter->flow_isolate_cfg, adapter->flow_isolated,
      62                 :          0 :                 adapter->dev_type, adapter->switchdev_info.is_switchdev,
      63                 :          0 :                 adapter->is_dev_repr, adapter->dev_port_id,
      64                 :            :                 dev->data->dev_flags,
      65                 :          0 :                 dev->data->dev_conf.intr_conf.lsc,
      66                 :          0 :                 dev->data->dev_conf.intr_conf.rxq,
      67                 :          0 :                 dev->data->dev_conf.intr_conf.rmv);
      68                 :          0 : }
      69                 :            : 
      70                 :            : static void
      71                 :          0 : sxe2_dump_dev_args_info(FILE *file, struct rte_eth_dev *dev)
      72                 :            : {
      73                 :          0 :         struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
      74                 :            : 
      75         [ #  # ]:          0 :         if (adapter->is_dev_repr)
      76                 :          0 :                 goto l_end;
      77                 :            : 
      78                 :          0 :         fprintf(file,
      79                 :            :                 "  - Device Args Info:\n"
      80                 :            :                 "\t  -- no_sched_mode: %s\n"
      81                 :            :                 "\t  -- flow-duplicate-pattern: %u\n"
      82                 :            :                 "\t  -- fnav-stat-type: %u\n"
      83                 :            :                 "\t  -- sched_layer_mode: %u\n"
      84                 :            :                 "\t  -- rx_low_latency: %s\n"
      85                 :            :                 "\t  -- function-flow-direct: %s\n",
      86                 :          0 :                 adapter->devargs.no_sched_mode ? "On" : "Off",
      87                 :          0 :                 adapter->devargs.flow_dup_pattern_mode,
      88                 :          0 :                 adapter->devargs.fnav_stat_type,
      89         [ #  # ]:          0 :                 adapter->devargs.sched_layer_mode,
      90         [ #  # ]:          0 :                 adapter->devargs.rx_low_latency ? "On" : "Off",
      91         [ #  # ]:          0 :                 adapter->devargs.func_flow_direct_en ? "On" : "Off");
      92                 :          0 : l_end:
      93                 :          0 :         return;
      94                 :            : }
      95                 :            : 
      96                 :          0 : static void sxe2_dump_filter_info(FILE *file, struct rte_eth_dev *dev)
      97                 :            : {
      98                 :          0 :         struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
      99                 :          0 :         struct sxe2_mac_filter *mac_entry;
     100                 :          0 :         struct sxe2_mac_filter *next_mac_entry;
     101                 :          0 :         struct sxe2_vlan_filter *vlan_entry;
     102                 :          0 :         struct sxe2_vlan_filter *next_vlan_entry;
     103                 :            : 
     104         [ #  # ]:          0 :         if (adapter->is_dev_repr)
     105                 :          0 :                 goto l_end;
     106                 :            : 
     107                 :          0 :         fprintf(file,
     108                 :            :                 "  - Device Filter Info:\n"
     109                 :            :                 "\t  -- cur_promisc:0x%x hw_promisc:0x%x\n"
     110                 :            :                 "\t  -- unicast_num: %u multicast_num: %u\n"
     111                 :            :                 "\t  -- vlan_num: %u filter_on: %u hw_filter_on: %u\n"
     112                 :            :                 "\t  -- vlan max_cnt: %u cnt: %u\n"
     113                 :            :                 "\t  -- tpid: 0x%x vid: 0x%x\n"
     114                 :            :                 "\t  -- vlan_outer_insert: 0x%x vlan_outer_strip: 0x%x\n"
     115                 :            :                 "\t  -- vlan_inner_insert: 0x%x vlan_inner_strip: 0x%x\n",
     116                 :            :                 adapter->filter_ctxt.cur_promisc_flags,
     117                 :            :                 adapter->filter_ctxt.hw_promisc_flags,
     118                 :          0 :                 adapter->filter_ctxt.uc_num,
     119                 :          0 :                 adapter->filter_ctxt.mc_num,
     120                 :          0 :                 adapter->filter_ctxt.vlan_num,
     121                 :          0 :                 adapter->filter_ctxt.vlan_info.filter_on,
     122                 :          0 :                 adapter->filter_ctxt.vlan_info.hw_filter_on,
     123                 :          0 :                 adapter->filter_ctxt.vlan_info.max_cnt,
     124                 :          0 :                 adapter->filter_ctxt.vlan_info.cnt,
     125                 :          0 :                 adapter->filter_ctxt.vlan_info.tpid,
     126                 :          0 :                 adapter->filter_ctxt.vlan_info.vid,
     127                 :          0 :                 adapter->filter_ctxt.vlan_info.outer_insert,
     128                 :          0 :                 adapter->filter_ctxt.vlan_info.outer_strip,
     129                 :          0 :                 adapter->filter_ctxt.vlan_info.inner_insert,
     130                 :          0 :                 adapter->filter_ctxt.vlan_info.inner_strip);
     131                 :            : 
     132         [ #  # ]:          0 :         if (adapter->filter_ctxt.uc_num > 0) {
     133                 :          0 :                 fprintf(file,
     134                 :            :                         "\t  -- Unicast entry:\n");
     135         [ #  # ]:          0 :                 RTE_TAILQ_FOREACH_SAFE(mac_entry, &adapter->filter_ctxt.uc_list, next,
     136                 :            :                                        next_mac_entry) {
     137                 :          0 :                         fprintf(file,
     138                 :            :                                 "\t  -- addr: %02x:%02x:%02x:%02x:%02x:%02x hw status:%u "
     139                 :            :                                 "default:%u\n",
     140                 :          0 :                                 mac_entry->mac_addr.addr_bytes[0],
     141                 :          0 :                                 mac_entry->mac_addr.addr_bytes[1],
     142                 :          0 :                                 mac_entry->mac_addr.addr_bytes[2],
     143                 :          0 :                                 mac_entry->mac_addr.addr_bytes[3],
     144                 :          0 :                                 mac_entry->mac_addr.addr_bytes[4],
     145                 :          0 :                                 mac_entry->mac_addr.addr_bytes[5],
     146                 :          0 :                                 mac_entry->hw_config,
     147                 :          0 :                                 mac_entry->default_config);
     148                 :            :                 }
     149                 :            :         }
     150                 :            : 
     151         [ #  # ]:          0 :         if (adapter->filter_ctxt.mc_num > 0) {
     152                 :          0 :                 fprintf(file,
     153                 :            :                         "\t  -- Multicast entry:\n");
     154         [ #  # ]:          0 :                 RTE_TAILQ_FOREACH_SAFE(mac_entry, &adapter->filter_ctxt.mc_list,
     155                 :            :                                        next, next_mac_entry) {
     156                 :          0 :                         fprintf(file,
     157                 :            :                                 "\t  -- addr: %02x:%02x:%02x:%02x:%02x:%02x "
     158                 :            :                                 "hw status:%u default:%u\n",
     159                 :          0 :                                 mac_entry->mac_addr.addr_bytes[0],
     160                 :          0 :                                 mac_entry->mac_addr.addr_bytes[1],
     161                 :          0 :                                 mac_entry->mac_addr.addr_bytes[2],
     162                 :          0 :                                 mac_entry->mac_addr.addr_bytes[3],
     163                 :          0 :                                 mac_entry->mac_addr.addr_bytes[4],
     164                 :          0 :                                 mac_entry->mac_addr.addr_bytes[5],
     165                 :          0 :                                 mac_entry->hw_config,
     166                 :          0 :                                 mac_entry->default_config);
     167                 :            :                 }
     168                 :            :         }
     169                 :            : 
     170         [ #  # ]:          0 :         if (adapter->filter_ctxt.vlan_num > 0) {
     171                 :          0 :                 fprintf(file,
     172                 :            :                         "\t  -- Vlan entry:\n");
     173         [ #  # ]:          0 :                 RTE_TAILQ_FOREACH_SAFE(vlan_entry, &adapter->filter_ctxt.vlan_list,
     174                 :            :                         next, next_vlan_entry) {
     175                 :          0 :                         fprintf(file,
     176                 :            :                                 "\t  -- vlan tpid:0x%04x vid:0x%04x prio:%d "
     177                 :            :                                 "hw status:%u default:%u\n",
     178                 :          0 :                                 vlan_entry->vlan_info.tpid,
     179                 :          0 :                                 vlan_entry->vlan_info.vid,
     180                 :          0 :                                 vlan_entry->vlan_info.prio,
     181                 :          0 :                                 vlan_entry->hw_config,
     182                 :          0 :                                 vlan_entry->default_config);
     183                 :            :                 }
     184                 :            :         }
     185                 :          0 : l_end:
     186                 :          0 :         return;
     187                 :            : }
     188                 :            : 
     189                 :          0 : static const char *sxe2_vsi_id_str(uint16_t vsi_id, char *buf, size_t len)
     190                 :            : {
     191                 :          0 :         if (vsi_id == SXE2_INVALID_VSI_ID)
     192                 :            :                 return "NA";
     193                 :            : 
     194                 :          0 :         snprintf(buf, len, "%u", vsi_id);
     195                 :          0 :         return buf;
     196                 :            : }
     197                 :            : 
     198                 :            : static void
     199                 :          0 : sxe2_dump_switchdev_info(FILE *file, struct rte_eth_dev *dev)
     200                 :            : {
     201                 :          0 :         struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
     202                 :          0 :         uint32_t idx;
     203                 :          0 :         char k_vsi_buf[16];
     204                 :          0 :         char u_vsi_buf[16];
     205                 :            : 
     206   [ #  #  #  # ]:          0 :         if (adapter->is_dev_repr && adapter->repr_priv_data) {
     207                 :          0 :                 fprintf(file,
     208                 :            :                         "  - Reprenstor Info:\n"
     209                 :            :                         "\t  -- repr_id: %u\n"
     210                 :            :                         "\t  -- repr_q_id: %u\n"
     211                 :            :                         "\t  -- repr_pf_id: %u\n"
     212                 :            :                         "\t  -- repr_vf_id: %u\n"
     213                 :            :                         "\t  -- repr_vf_vsi_id: %u\n"
     214                 :            :                         "\t  -- repr_vf_k_vsi_id: %s\n"
     215                 :            :                         "\t  -- repr_vf_u_vsi_id: %s\n",
     216                 :          0 :                         adapter->repr_priv_data->repr_id,
     217                 :          0 :                         adapter->repr_priv_data->repr_q_id,
     218                 :          0 :                         adapter->repr_priv_data->repr_pf_id,
     219                 :          0 :                         adapter->repr_priv_data->repr_vf_id,
     220                 :          0 :                         adapter->repr_priv_data->repr_vf_vsi_id,
     221         [ #  # ]:          0 :                         sxe2_vsi_id_str(adapter->repr_priv_data->repr_vf_k_vsi_id,
     222                 :            :                                         k_vsi_buf, sizeof(k_vsi_buf)),
     223         [ #  # ]:          0 :                         sxe2_vsi_id_str(adapter->repr_priv_data->repr_vf_u_vsi_id,
     224                 :            :                                         u_vsi_buf, sizeof(u_vsi_buf)));
     225                 :          0 :                 goto l_end;
     226                 :            :         }
     227         [ #  # ]:          0 :         if (adapter->switchdev_info.is_switchdev) {
     228                 :          0 :                 fprintf(file,
     229                 :            :                         "  - Switchdev Info:\n"
     230                 :            :                         "\t  -- primary:0x%x\n"
     231                 :            :                         "\t  -- representor: 0x%x\n"
     232                 :            :                         "\t  -- port_name_type: 0x%x\n"
     233                 :            :                         "\t  -- nb_vf: %u nb_repr_vf: %u\n",
     234                 :          0 :                         adapter->switchdev_info.primary,
     235                 :          0 :                         adapter->switchdev_info.representor,
     236                 :          0 :                         adapter->switchdev_info.port_name_type,
     237                 :          0 :                         adapter->repr_ctxt.nb_vf,
     238                 :          0 :                         adapter->repr_ctxt.nb_repr_vf);
     239         [ #  # ]:          0 :                 if (adapter->repr_ctxt.nb_vf > 0) {
     240                 :          0 :                         fprintf(file,
     241                 :            :                                 "\t  -- vf entry:\n");
     242         [ #  # ]:          0 :                         for (idx = 0; idx < adapter->repr_ctxt.nb_vf; idx++) {
     243                 :          0 :                                 fprintf(file,
     244                 :            :                                         "\t  -- func_id:%u vsi_type:%u kernel_vsi_id:%u dpdk_vsi_id:%u\n",
     245                 :          0 :                                         adapter->repr_ctxt.repr_vf_id[idx].func_id,
     246                 :          0 :                                         adapter->repr_ctxt.repr_vf_id[idx].vsi_type,
     247                 :          0 :                                         adapter->repr_ctxt.repr_vf_id[idx].kernel_vsi_id,
     248                 :          0 :                                         adapter->repr_ctxt.repr_vf_id[idx].dpdk_vsi_id);
     249                 :            :                         }
     250                 :            :                 }
     251                 :            :         }
     252                 :            : 
     253                 :          0 : l_end:
     254                 :          0 :         return;
     255                 :            : }
     256                 :            : 
     257                 :          0 : int32_t sxe2_eth_dev_priv_dump(struct rte_eth_dev *dev, FILE *file)
     258                 :            : {
     259                 :          0 :         char *buf = NULL;
     260                 :          0 :         size_t size = 0;
     261                 :          0 :         FILE *str;
     262                 :          0 :         int32_t ret = -1;
     263                 :            : 
     264                 :          0 :         str = open_memstream(&buf, &size);
     265         [ #  # ]:          0 :         if (!str) {
     266                 :          0 :                 PMD_LOG_ERR(DRV, "fopen fail.");
     267                 :          0 :                 goto l_end;
     268                 :            :         }
     269                 :            : 
     270                 :          0 :         sxe2_dump_dev_feature_capability(str, dev);
     271                 :          0 :         sxe2_dump_device_basic_info(str, dev);
     272                 :          0 :         sxe2_dump_dev_args_info(str, dev);
     273                 :          0 :         sxe2_dump_filter_info(str, dev);
     274                 :          0 :         sxe2_dump_switchdev_info(str, dev);
     275                 :            : 
     276                 :          0 :         (void)fflush(str);
     277                 :            : 
     278                 :          0 :         (void)fwrite(buf, 1, size, file);
     279                 :          0 :         (void)fflush(file);
     280                 :            : 
     281                 :          0 :         ret = 0;
     282                 :            : 
     283                 :          0 :         (void)fclose(str);
     284                 :          0 :         free(buf);
     285                 :          0 : l_end:
     286                 :          0 :         return ret;
     287                 :            : }