LCOV - code coverage report
Current view: top level - spdk/lib/env_dpdk - pci_dpdk.c (source / functions) Hit Total Coverage
Test: Combined Lines: 47 77 61.0 %
Date: 2024-07-15 21:23:26 Functions: 16 19 84.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 9 48 18.8 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2022 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include <rte_config.h>
       7                 :            : #include <rte_version.h>
       8                 :            : #include "pci_dpdk.h"
       9                 :            : #include "spdk/log.h"
      10                 :            : 
      11                 :            : extern struct dpdk_fn_table fn_table_2207;
      12                 :            : extern struct dpdk_fn_table fn_table_2211;
      13                 :            : 
      14                 :            : static struct dpdk_fn_table *g_dpdk_fn_table;
      15                 :            : 
      16                 :            : int
      17                 :       3046 : dpdk_pci_init(void)
      18                 :            : {
      19                 :       1273 :         uint32_t year;
      20                 :       1273 :         uint32_t month;
      21                 :       1273 :         uint32_t minor;
      22                 :       3046 :         char release[32] = {0}; /* Max size of DPDK version string */
      23                 :            :         int count;
      24                 :            : 
      25         [ -  + ]:       3046 :         count = sscanf(rte_version(), "DPDK %u.%u.%u%s", &year, &month, &minor, release);
      26   [ -  +  -  - ]:       3046 :         if (count != 3 && count != 4) {
      27                 :          0 :                 SPDK_ERRLOG("Unrecognized DPDK version format '%s'\n", rte_version());
      28                 :          0 :                 return -EINVAL;
      29                 :            :         }
      30                 :            : 
      31                 :            :         /* Add support for DPDK main branch, should be updated after each new release.
      32                 :            :          * Only DPDK in development has additional suffix past minor version.
      33                 :            :          */
      34         [ -  + ]:       3046 :         if (strlen(release) != 0) {
      35   [ #  #  #  #  :          0 :                 if (year == 24 && month == 7 && minor == 0) {
                   #  # ]
      36                 :          0 :                         g_dpdk_fn_table = &fn_table_2211;
      37                 :          0 :                         SPDK_NOTICELOG("In-development %s is used. There is no support for it in SPDK. "
      38                 :            :                                        "Enabled only for validation.\n", rte_version());
      39                 :          0 :                         return 0;
      40                 :            :                 }
      41                 :            :         }
      42                 :            : 
      43                 :            :         /* Anything 25.x or higher is not supported. */
      44         [ -  + ]:       3046 :         if (year >= 25) {
      45                 :          0 :                 SPDK_ERRLOG("DPDK version %d.%02d.%d not supported.\n", year, month, minor);
      46                 :          0 :                 return -EINVAL;
      47                 :            :         }
      48                 :            : 
      49   [ -  +  -  - ]:       3046 :         if (year == 22 && month == 11) {
      50         [ #  # ]:          0 :                 if (minor > 4) {
      51                 :            :                         /* It is possible that LTS minor release changed private ABI, so we
      52                 :            :                          * cannot assume fn_table_2211 works for minor releases.  As 22.11
      53                 :            :                          * minor releases occur, this will need to be updated to either affirm
      54                 :            :                          * no ABI changes for the minor release, or add new header files and
      55                 :            :                          * pci_dpdk_xxx.c implementation for the new minor release.
      56                 :            :                          */
      57                 :          0 :                         SPDK_ERRLOG("DPDK LTS version 22.11.%d not supported.\n", minor);
      58                 :          0 :                         return -EINVAL;
      59                 :            :                 }
      60                 :          0 :                 g_dpdk_fn_table = &fn_table_2211;
      61         [ -  + ]:       3046 :         } else if (year == 23) {
      62                 :            :                 /* Only 23.11.0, 23.07.0 and 23.03.0 are supported. */
      63   [ #  #  #  # ]:          0 :                 if ((month != 11 || minor != 0) &&
      64   [ #  #  #  # ]:          0 :                     (month != 7 || minor != 0) &&
      65   [ #  #  #  # ]:          0 :                     (month != 3 || minor != 0)) {
      66                 :          0 :                         SPDK_ERRLOG("DPDK version 23.%02d.%d is not supported.\n", month, minor);
      67                 :          0 :                         return -EINVAL;
      68                 :            :                 }
      69                 :            :                 /* There were no changes between 22.11 and 23.11, so use the 22.11 implementation. */
      70                 :          0 :                 g_dpdk_fn_table = &fn_table_2211;
      71         [ +  - ]:       3046 :         } else if (year == 24) {
      72                 :            :                 /* Only 24.03.0 is supported. */
      73   [ +  -  -  + ]:       3046 :                 if (month != 3 || minor != 0) {
      74                 :          0 :                         SPDK_ERRLOG("DPDK version 24.%02d.%d is not supported.\n", month, minor);
      75                 :          0 :                         return -EINVAL;
      76                 :            :                 }
      77                 :            :                 /* There were no changes between 22.11 and 24.03, so use the 22.11 implementation. */
      78                 :       3046 :                 g_dpdk_fn_table = &fn_table_2211;
      79   [ #  #  #  #  :          0 :         } else if (year < 21 || (year == 21 && month < 11)) {
                   #  # ]
      80                 :          0 :                 SPDK_ERRLOG("DPDK version %02d.%02d.%d is not supported.\n", year, month, minor);
      81                 :          0 :                 return -EINVAL;
      82                 :            :         } else {
      83                 :            :                 /* Everything else we use the 22.07 implementation. */
      84                 :          0 :                 g_dpdk_fn_table = &fn_table_2207;
      85                 :            :         }
      86                 :       3046 :         return 0;
      87                 :            : }
      88                 :            : 
      89                 :            : struct rte_mem_resource *
      90                 :      18048 : dpdk_pci_device_get_mem_resource(struct rte_pci_device *dev, uint32_t bar)
      91                 :            : {
      92                 :      18048 :         return g_dpdk_fn_table->pci_device_get_mem_resource(dev, bar);
      93                 :            : }
      94                 :            : 
      95                 :            : const char *
      96                 :       1055 : dpdk_pci_device_get_name(struct rte_pci_device *rte_dev)
      97                 :            : {
      98                 :       1055 :         return g_dpdk_fn_table->pci_device_get_name(rte_dev);
      99                 :            : }
     100                 :            : 
     101                 :            : struct rte_devargs *
     102                 :       3787 : dpdk_pci_device_get_devargs(struct rte_pci_device *rte_dev)
     103                 :            : {
     104                 :       3787 :         return g_dpdk_fn_table->pci_device_get_devargs(rte_dev);
     105                 :            : }
     106                 :            : 
     107                 :            : struct rte_pci_addr *
     108                 :       1796 : dpdk_pci_device_get_addr(struct rte_pci_device *rte_dev)
     109                 :            : {
     110                 :       1796 :         return g_dpdk_fn_table->pci_device_get_addr(rte_dev);
     111                 :            : }
     112                 :            : 
     113                 :            : struct rte_pci_id *
     114                 :       1796 : dpdk_pci_device_get_id(struct rte_pci_device *rte_dev)
     115                 :            : {
     116                 :       1796 :         return g_dpdk_fn_table->pci_device_get_id(rte_dev);
     117                 :            : }
     118                 :            : 
     119                 :            : int
     120                 :       1796 : dpdk_pci_device_get_numa_node(struct rte_pci_device *_dev)
     121                 :            : {
     122                 :       1796 :         return g_dpdk_fn_table->pci_device_get_numa_node(_dev);
     123                 :            : }
     124                 :            : 
     125                 :            : int
     126                 :       1082 : dpdk_pci_device_read_config(struct rte_pci_device *dev, void *value, uint32_t len, uint32_t offset)
     127                 :            : {
     128                 :       1082 :         return g_dpdk_fn_table->pci_device_read_config(dev, value, len, offset);
     129                 :            : }
     130                 :            : 
     131                 :            : int
     132                 :       1082 : dpdk_pci_device_write_config(struct rte_pci_device *dev, void *value, uint32_t len, uint32_t offset)
     133                 :            : {
     134                 :       1082 :         return g_dpdk_fn_table->pci_device_write_config(dev, value, len, offset);
     135                 :            : }
     136                 :            : 
     137                 :            : int
     138                 :      14183 : dpdk_pci_driver_register(struct spdk_pci_driver *driver,
     139                 :            :                          int (*probe_fn)(struct rte_pci_driver *driver, struct rte_pci_device *device),
     140                 :            :                          int (*remove_fn)(struct rte_pci_device *device))
     141                 :            : 
     142                 :            : {
     143                 :      14183 :         return g_dpdk_fn_table->pci_driver_register(driver, probe_fn, remove_fn);
     144                 :            : }
     145                 :            : 
     146                 :            : int
     147                 :          0 : dpdk_pci_device_enable_interrupt(struct rte_pci_device *rte_dev)
     148                 :            : {
     149                 :          0 :         return g_dpdk_fn_table->pci_device_enable_interrupt(rte_dev);
     150                 :            : }
     151                 :            : 
     152                 :            : int
     153                 :          0 : dpdk_pci_device_disable_interrupt(struct rte_pci_device *rte_dev)
     154                 :            : {
     155                 :          0 :         return g_dpdk_fn_table->pci_device_disable_interrupt(rte_dev);
     156                 :            : }
     157                 :            : 
     158                 :            : int
     159                 :          0 : dpdk_pci_device_get_interrupt_efd(struct rte_pci_device *rte_dev)
     160                 :            : {
     161                 :          0 :         return g_dpdk_fn_table->pci_device_get_interrupt_efd(rte_dev);
     162                 :            : }
     163                 :            : 
     164                 :            : int
     165                 :      83932 : dpdk_bus_probe(void)
     166                 :            : {
     167                 :      83932 :         return g_dpdk_fn_table->bus_probe();
     168                 :            : }
     169                 :            : 
     170                 :            : void
     171                 :      87035 : dpdk_bus_scan(void)
     172                 :            : {
     173                 :      87035 :         g_dpdk_fn_table->bus_scan();
     174                 :      87035 : }
     175                 :            : 
     176                 :            : struct rte_devargs *
     177                 :     917020 : dpdk_device_get_devargs(struct rte_device *dev)
     178                 :            : {
     179                 :     917020 :         return g_dpdk_fn_table->device_get_devargs(dev);
     180                 :            : }
     181                 :            : 
     182                 :            : void
     183                 :      93748 : dpdk_device_set_devargs(struct rte_device *dev, struct rte_devargs *devargs)
     184                 :            : {
     185                 :      93748 :         g_dpdk_fn_table->device_set_devargs(dev, devargs);
     186                 :      93748 : }
     187                 :            : 
     188                 :            : const char *
     189                 :      93748 : dpdk_device_get_name(struct rte_device *dev)
     190                 :            : {
     191                 :      93748 :         return g_dpdk_fn_table->device_get_name(dev);
     192                 :            : }
     193                 :            : 
     194                 :            : bool
     195                 :      93748 : dpdk_device_scan_allowed(struct rte_device *dev)
     196                 :            : {
     197                 :      93748 :         return g_dpdk_fn_table->device_scan_allowed(dev);
     198                 :            : }

Generated by: LCOV version 1.14