LCOV - code coverage report
Current view: top level - spdk/lib/env_dpdk - pci_dpdk.c (source / functions) Hit Total Coverage
Test: Combined Lines: 45 78 57.7 %
Date: 2024-08-11 07:26:50 Functions: 16 19 84.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 7 52 13.5 %

           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                 :       2624 : dpdk_pci_init(void)
      18                 :            : {
      19                 :       1052 :         uint32_t year;
      20                 :       1052 :         uint32_t month;
      21                 :       1052 :         uint32_t minor;
      22                 :       2624 :         char release[32] = {0}; /* Max size of DPDK version string */
      23                 :            :         int count;
      24                 :            : 
      25         [ -  + ]:       2624 :         count = sscanf(rte_version(), "DPDK %u.%u.%u%s", &year, &month, &minor, release);
      26   [ -  +  -  - ]:       2624 :         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         [ -  + ]:       2624 :         if (strlen(release) != 0) {
      35   [ #  #  #  #  :          0 :                 if (year == 24 && month == 11 && 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         [ -  + ]:       2624 :         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   [ +  -  +  - ]:       2624 :         if (year == 22 && month == 11) {
      50         [ -  + ]:       2624 :                 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                 :       2624 :                 g_dpdk_fn_table = &fn_table_2211;
      61         [ #  # ]:          0 :         } 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         [ #  # ]:          0 :         } else if (year == 24) {
      72                 :            :                 /* Only 24.03.0 and 24.07.0 are supported. */
      73   [ #  #  #  # ]:          0 :                 if ((month != 7 || minor != 0) &&
      74   [ #  #  #  # ]:          0 :                     (month != 3 || minor != 0)) {
      75                 :          0 :                         SPDK_ERRLOG("DPDK version 24.%02d.%d is not supported.\n", month, minor);
      76                 :          0 :                         return -EINVAL;
      77                 :            :                 }
      78                 :            :                 /* There were no changes between 22.11 and 24.*, so use the 22.11 implementation. */
      79                 :          0 :                 g_dpdk_fn_table = &fn_table_2211;
      80   [ #  #  #  #  :          0 :         } else if (year < 21 || (year == 21 && month < 11)) {
                   #  # ]
      81                 :          0 :                 SPDK_ERRLOG("DPDK version %02d.%02d.%d is not supported.\n", year, month, minor);
      82                 :          0 :                 return -EINVAL;
      83                 :            :         } else {
      84                 :            :                 /* Everything else we use the 22.07 implementation. */
      85                 :          0 :                 g_dpdk_fn_table = &fn_table_2207;
      86                 :            :         }
      87                 :       2624 :         return 0;
      88                 :            : }
      89                 :            : 
      90                 :            : struct rte_mem_resource *
      91                 :      19773 : dpdk_pci_device_get_mem_resource(struct rte_pci_device *dev, uint32_t bar)
      92                 :            : {
      93                 :      19773 :         return g_dpdk_fn_table->pci_device_get_mem_resource(dev, bar);
      94                 :            : }
      95                 :            : 
      96                 :            : const char *
      97                 :       1100 : dpdk_pci_device_get_name(struct rte_pci_device *rte_dev)
      98                 :            : {
      99                 :       1100 :         return g_dpdk_fn_table->pci_device_get_name(rte_dev);
     100                 :            : }
     101                 :            : 
     102                 :            : struct rte_devargs *
     103                 :       3907 : dpdk_pci_device_get_devargs(struct rte_pci_device *rte_dev)
     104                 :            : {
     105                 :       3907 :         return g_dpdk_fn_table->pci_device_get_devargs(rte_dev);
     106                 :            : }
     107                 :            : 
     108                 :            : struct rte_pci_addr *
     109                 :       1867 : dpdk_pci_device_get_addr(struct rte_pci_device *rte_dev)
     110                 :            : {
     111                 :       1867 :         return g_dpdk_fn_table->pci_device_get_addr(rte_dev);
     112                 :            : }
     113                 :            : 
     114                 :            : struct rte_pci_id *
     115                 :       1867 : dpdk_pci_device_get_id(struct rte_pci_device *rte_dev)
     116                 :            : {
     117                 :       1867 :         return g_dpdk_fn_table->pci_device_get_id(rte_dev);
     118                 :            : }
     119                 :            : 
     120                 :            : int
     121                 :       1867 : dpdk_pci_device_get_numa_node(struct rte_pci_device *_dev)
     122                 :            : {
     123                 :       1867 :         return g_dpdk_fn_table->pci_device_get_numa_node(_dev);
     124                 :            : }
     125                 :            : 
     126                 :            : int
     127                 :       1151 : dpdk_pci_device_read_config(struct rte_pci_device *dev, void *value, uint32_t len, uint32_t offset)
     128                 :            : {
     129                 :       1151 :         return g_dpdk_fn_table->pci_device_read_config(dev, value, len, offset);
     130                 :            : }
     131                 :            : 
     132                 :            : int
     133                 :       1127 : dpdk_pci_device_write_config(struct rte_pci_device *dev, void *value, uint32_t len, uint32_t offset)
     134                 :            : {
     135                 :       1127 :         return g_dpdk_fn_table->pci_device_write_config(dev, value, len, offset);
     136                 :            : }
     137                 :            : 
     138                 :            : int
     139                 :      12543 : dpdk_pci_driver_register(struct spdk_pci_driver *driver,
     140                 :            :                          int (*probe_fn)(struct rte_pci_driver *driver, struct rte_pci_device *device),
     141                 :            :                          int (*remove_fn)(struct rte_pci_device *device))
     142                 :            : 
     143                 :            : {
     144                 :      12543 :         return g_dpdk_fn_table->pci_driver_register(driver, probe_fn, remove_fn);
     145                 :            : }
     146                 :            : 
     147                 :            : int
     148                 :          0 : dpdk_pci_device_enable_interrupt(struct rte_pci_device *rte_dev)
     149                 :            : {
     150                 :          0 :         return g_dpdk_fn_table->pci_device_enable_interrupt(rte_dev);
     151                 :            : }
     152                 :            : 
     153                 :            : int
     154                 :          0 : dpdk_pci_device_disable_interrupt(struct rte_pci_device *rte_dev)
     155                 :            : {
     156                 :          0 :         return g_dpdk_fn_table->pci_device_disable_interrupt(rte_dev);
     157                 :            : }
     158                 :            : 
     159                 :            : int
     160                 :          0 : dpdk_pci_device_get_interrupt_efd(struct rte_pci_device *rte_dev)
     161                 :            : {
     162                 :          0 :         return g_dpdk_fn_table->pci_device_get_interrupt_efd(rte_dev);
     163                 :            : }
     164                 :            : 
     165                 :            : int
     166                 :     105968 : dpdk_bus_probe(void)
     167                 :            : {
     168                 :     105968 :         return g_dpdk_fn_table->bus_probe();
     169                 :            : }
     170                 :            : 
     171                 :            : void
     172                 :     108655 : dpdk_bus_scan(void)
     173                 :            : {
     174                 :     108655 :         g_dpdk_fn_table->bus_scan();
     175                 :     108655 : }
     176                 :            : 
     177                 :            : struct rte_devargs *
     178                 :    1105293 : dpdk_device_get_devargs(struct rte_device *dev)
     179                 :            : {
     180                 :    1105293 :         return g_dpdk_fn_table->device_get_devargs(dev);
     181                 :            : }
     182                 :            : 
     183                 :            : void
     184                 :      82010 : dpdk_device_set_devargs(struct rte_device *dev, struct rte_devargs *devargs)
     185                 :            : {
     186                 :      82010 :         g_dpdk_fn_table->device_set_devargs(dev, devargs);
     187                 :      82010 : }
     188                 :            : 
     189                 :            : const char *
     190                 :      82010 : dpdk_device_get_name(struct rte_device *dev)
     191                 :            : {
     192                 :      82010 :         return g_dpdk_fn_table->device_get_name(dev);
     193                 :            : }
     194                 :            : 
     195                 :            : bool
     196                 :      82010 : dpdk_device_scan_allowed(struct rte_device *dev)
     197                 :            : {
     198                 :      82010 :         return g_dpdk_fn_table->device_scan_allowed(dev);
     199                 :            : }

Generated by: LCOV version 1.14