ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

env_dpdk: add DPDK-independent driver information to spdk_pci_driver

Browse Source 
We want to make struct spdk_pci_driver public, so add env-agnostic
fields that define a driver directly to that struct.
PCI driver registration (potentially in upper layers) will only use
spdk_pci_id-s and spdk pci drv_flags, then those will be translated
to DPDK equivalents inside env_dpdk.

Change-Id: Ia24ecfc99ebf0f54f096eaf27bca5ed9c0dfe01d
Signed-off-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com>
Signed-off-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/3183
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Community-CI: Mellanox Build Bot
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
This commit is contained in:
Darek Stojaczyk 2020-07-03 00:17:43 +02:00 committed by Tomasz Zawadzki
parent acee02acc9
commit e6decf684a
7 changed files with 120 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
lib/env_dpdk/env_internal.h
View File

@ -59,14 +59,32 @@
#define SHIFT_1GB 30 /* (1 << 30) == 1 GB */
#define MASK_1GB ((1ULL << SHIFT_1GB) - 1)
#define SPDK_PMD_REGISTER_PCI(pci_drv) \
#define SPDK_PCI_DRIVER_REGISTER(pci_drv) \
__attribute__((constructor)) static void pci_drv ## _register(void) \
{ \
pci_driver_register(&pci_drv); \
}
/** Device needs PCI BAR mapping (done with either IGB_UIO or VFIO) */
#define SPDK_PCI_DRIVER_NEED_MAPPING 0x0001
/** Device needs PCI BAR mapping with enabled write combining (wc) */
#define SPDK_PCI_DRIVER_WC_ACTIVATE 0x0002
#define SPDK_PCI_DEVICE(vend, dev) \
.class_id = SPDK_PCI_CLASS_ANY_ID, \
.vendor_id = (vend), \
.device_id = (dev), \
.subvendor_id = SPDK_PCI_ANY_ID, \
.subdevice_id = SPDK_PCI_ANY_ID
#define SPDK_PCI_DRIVER_MAX_NAME_LEN 32
struct spdk_pci_driver {
struct rte_pci_driver driver;
const char *name;
const struct spdk_pci_id *id_table;
uint32_t drv_flags;
spdk_pci_enum_cb cb_fn;
void *cb_arg;
TAILQ_ENTRY(spdk_pci_driver) tailq;

63
lib/env_dpdk/pci.c
View File

@ -239,6 +239,67 @@ cleanup_pci_devices(void)
static int scan_pci_bus(bool delay_init);
/* translate spdk_pci_driver to an rte_pci_driver and register it to dpdk */
static int
register_rte_driver(struct spdk_pci_driver *driver)
{
unsigned pci_id_count = 0;
struct rte_pci_id *rte_id_table;
char *rte_name;
size_t rte_name_len;
uint32_t rte_flags;
assert(driver->id_table);
while (driver->id_table[pci_id_count].vendor_id) {
pci_id_count++;
}
assert(pci_id_count > 0);
rte_id_table = calloc(pci_id_count + 1, sizeof(*rte_id_table));
if (!rte_id_table) {
return -ENOMEM;
}
while (pci_id_count > 0) {
struct rte_pci_id *rte_id = &rte_id_table[pci_id_count - 1];
const struct spdk_pci_id *spdk_id = &driver->id_table[pci_id_count - 1];
rte_id->class_id = spdk_id->class_id;
rte_id->vendor_id = spdk_id->vendor_id;
rte_id->device_id = spdk_id->device_id;
rte_id->subsystem_vendor_id = spdk_id->subvendor_id;
rte_id->subsystem_device_id = spdk_id->subdevice_id;
pci_id_count--;
}
assert(driver->name);
rte_name_len = strlen(driver->name) + strlen("spdk_") + 1;
rte_name = calloc(rte_name_len, 1);
if (!rte_name) {
free(rte_id_table);
return -ENOMEM;
}
snprintf(rte_name, rte_name_len, "spdk_%s", driver->name);
driver->driver.driver.name = rte_name;
driver->driver.id_table = rte_id_table;
rte_flags = 0;
if (driver->drv_flags & SPDK_PCI_DRIVER_NEED_MAPPING) {
rte_flags |= RTE_PCI_DRV_NEED_MAPPING;
}
if (driver->drv_flags & SPDK_PCI_DRIVER_WC_ACTIVATE) {
rte_flags |= RTE_PCI_DRV_WC_ACTIVATE;
}
driver->driver.drv_flags = rte_flags;
driver->driver.probe = pci_device_init;
driver->driver.remove = pci_device_fini;
rte_pci_register(&driver->driver);
return 0;
}
static inline void
_pci_env_init(void)
{
@ -260,7 +321,7 @@ pci_env_init(void)
struct spdk_pci_driver *driver;
TAILQ_FOREACH(driver, &g_pci_drivers, tailq) {
rte_pci_register(&driver->driver);
register_rte_driver(driver);
}
_pci_env_init();

19
lib/env_dpdk/pci_idxd.c
View File

@ -35,23 +35,16 @@
#include "spdk/pci_ids.h"
#define SPDK_IDXD_PCI_DEVICE(DEVICE_ID) RTE_PCI_DEVICE(SPDK_PCI_VID_INTEL, DEVICE_ID)
static struct rte_pci_id idxd_driver_id[] = {
#define SPDK_IDXD_PCI_DEVICE(DEVICE_ID) SPDK_PCI_DEVICE(SPDK_PCI_VID_INTEL, DEVICE_ID)
static struct spdk_pci_id idxd_driver_id[] = {
{SPDK_IDXD_PCI_DEVICE(PCI_DEVICE_ID_INTEL_IDXD)},
{ .vendor_id = 0, /* sentinel */ },
};
static struct spdk_pci_driver g_idxd_pci_drv = {
.driver = {
.drv_flags = RTE_PCI_DRV_NEED_MAPPING,
.id_table = idxd_driver_id,
.probe = pci_device_init,
.remove = pci_device_fini,
.driver.name = "spdk_idxd",
},
.cb_fn = NULL,
.cb_arg = NULL,
.name = "idxd",
.id_table = idxd_driver_id,
.drv_flags = SPDK_PCI_DRIVER_NEED_MAPPING
};
struct spdk_pci_driver *
@ -60,4 +53,4 @@ spdk_pci_idxd_get_driver(void)
return &g_idxd_pci_drv;
}
SPDK_PMD_REGISTER_PCI(g_idxd_pci_drv);
SPDK_PCI_DRIVER_REGISTER(g_idxd_pci_drv);

19
lib/env_dpdk/pci_ioat.c
View File

@ -35,8 +35,8 @@
#include "spdk/pci_ids.h"
#define SPDK_IOAT_PCI_DEVICE(DEVICE_ID) RTE_PCI_DEVICE(SPDK_PCI_VID_INTEL, DEVICE_ID)
static struct rte_pci_id ioat_driver_id[] = {
#define SPDK_IOAT_PCI_DEVICE(DEVICE_ID) SPDK_PCI_DEVICE(SPDK_PCI_VID_INTEL, DEVICE_ID)
static struct spdk_pci_id ioat_driver_id[] = {
{SPDK_IOAT_PCI_DEVICE(PCI_DEVICE_ID_INTEL_IOAT_SNB0)},
{SPDK_IOAT_PCI_DEVICE(PCI_DEVICE_ID_INTEL_IOAT_SNB1)},
{SPDK_IOAT_PCI_DEVICE(PCI_DEVICE_ID_INTEL_IOAT_SNB2)},
@ -90,16 +90,9 @@ static struct rte_pci_id ioat_driver_id[] = {
};
static struct spdk_pci_driver g_ioat_pci_drv = {
.driver = {
.drv_flags = RTE_PCI_DRV_NEED_MAPPING,
.id_table = ioat_driver_id,
.probe = pci_device_init,
.remove = pci_device_fini,
.driver.name = "spdk_ioat",
},
.cb_fn = NULL,
.cb_arg = NULL,
.name = "ioat",
.id_table = ioat_driver_id,
.drv_flags = SPDK_PCI_DRIVER_NEED_MAPPING
};
struct spdk_pci_driver *
@ -108,4 +101,4 @@ spdk_pci_ioat_get_driver(void)
return &g_ioat_pci_drv;
}
SPDK_PMD_REGISTER_PCI(g_ioat_pci_drv);
SPDK_PCI_DRIVER_REGISTER(g_ioat_pci_drv);

28
lib/env_dpdk/pci_nvme.c
View File

@ -35,30 +35,22 @@
#include "spdk/pci_ids.h"
static struct rte_pci_id nvme_pci_driver_id[] = {
static struct spdk_pci_id nvme_pci_driver_id[] = {
{
.class_id = SPDK_PCI_CLASS_NVME,
.vendor_id = PCI_ANY_ID,
.device_id = PCI_ANY_ID,
.subsystem_vendor_id = PCI_ANY_ID,
.subsystem_device_id = PCI_ANY_ID,
.vendor_id = SPDK_PCI_ANY_ID,
.device_id = SPDK_PCI_ANY_ID,
.subvendor_id = SPDK_PCI_ANY_ID,
.subdevice_id = SPDK_PCI_ANY_ID,
},
{ .vendor_id = 0, /* sentinel */ },
};
static struct spdk_pci_driver g_nvme_pci_drv = {
.driver = {
.drv_flags = RTE_PCI_DRV_NEED_MAPPING
| RTE_PCI_DRV_WC_ACTIVATE
,
.id_table = nvme_pci_driver_id,
.probe = pci_device_init,
.remove = pci_device_fini,
.driver.name = "spdk_nvme",
},
.cb_fn = NULL,
.cb_arg = NULL,
.name = "nvme",
.id_table = nvme_pci_driver_id,
.drv_flags = SPDK_PCI_DRIVER_NEED_MAPPING |
SPDK_PCI_DRIVER_WC_ACTIVATE
};
struct spdk_pci_driver *
@ -67,4 +59,4 @@ spdk_pci_nvme_get_driver(void)
return &g_nvme_pci_drv;
}
SPDK_PMD_REGISTER_PCI(g_nvme_pci_drv);
SPDK_PCI_DRIVER_REGISTER(g_nvme_pci_drv);

28
lib/env_dpdk/pci_virtio.c
View File

@ -35,27 +35,19 @@
#include "spdk/pci_ids.h"
static struct rte_pci_id virtio_pci_driver_id[] = {
{ RTE_PCI_DEVICE(SPDK_PCI_VID_VIRTIO, PCI_DEVICE_ID_VIRTIO_SCSI_MODERN) },
{ RTE_PCI_DEVICE(SPDK_PCI_VID_VIRTIO, PCI_DEVICE_ID_VIRTIO_BLK_MODERN) },
{ RTE_PCI_DEVICE(SPDK_PCI_VID_VIRTIO, PCI_DEVICE_ID_VIRTIO_SCSI_LEGACY) },
{ RTE_PCI_DEVICE(SPDK_PCI_VID_VIRTIO, PCI_DEVICE_ID_VIRTIO_BLK_LEGACY) },
static struct spdk_pci_id virtio_pci_driver_id[] = {
{ SPDK_PCI_DEVICE(SPDK_PCI_VID_VIRTIO, PCI_DEVICE_ID_VIRTIO_SCSI_MODERN) },
{ SPDK_PCI_DEVICE(SPDK_PCI_VID_VIRTIO, PCI_DEVICE_ID_VIRTIO_BLK_MODERN) },
{ SPDK_PCI_DEVICE(SPDK_PCI_VID_VIRTIO, PCI_DEVICE_ID_VIRTIO_SCSI_LEGACY) },
{ SPDK_PCI_DEVICE(SPDK_PCI_VID_VIRTIO, PCI_DEVICE_ID_VIRTIO_BLK_LEGACY) },
{ .vendor_id = 0, /* sentinel */ },
};
static struct spdk_pci_driver g_virtio_pci_drv = {
.driver = {
.drv_flags = RTE_PCI_DRV_NEED_MAPPING
| RTE_PCI_DRV_WC_ACTIVATE
,
.id_table = virtio_pci_driver_id,
.probe = pci_device_init,
.remove = pci_device_fini,
.driver.name = "spdk_virtio",
},
.cb_fn = NULL,
.cb_arg = NULL,
.name = "virtio",
.id_table = virtio_pci_driver_id,
.drv_flags = SPDK_PCI_DRIVER_NEED_MAPPING |
SPDK_PCI_DRIVER_WC_ACTIVATE
};
struct spdk_pci_driver *
@ -64,4 +56,4 @@ spdk_pci_virtio_get_driver(void)
return &g_virtio_pci_drv;
}
SPDK_PMD_REGISTER_PCI(g_virtio_pci_drv);
SPDK_PCI_DRIVER_REGISTER(g_virtio_pci_drv);

22
lib/env_dpdk/pci_vmd.c
View File

@ -35,24 +35,16 @@
#include "spdk/pci_ids.h"
static struct rte_pci_id vmd_pci_driver_id[] = {
{ RTE_PCI_DEVICE(SPDK_PCI_VID_INTEL, PCI_DEVICE_ID_INTEL_VMD) },
static struct spdk_pci_id vmd_pci_driver_id[] = {
{ SPDK_PCI_DEVICE(SPDK_PCI_VID_INTEL, PCI_DEVICE_ID_INTEL_VMD) },
{ .vendor_id = 0, /* sentinel */ },
};
static struct spdk_pci_driver g_vmd_pci_drv = {
.driver = {
.drv_flags = RTE_PCI_DRV_NEED_MAPPING
| RTE_PCI_DRV_WC_ACTIVATE
,
.id_table = vmd_pci_driver_id,
.probe = pci_device_init,
.remove = pci_device_fini,
.driver.name = "spdk_vmd",
},
.cb_fn = NULL,
.cb_arg = NULL,
.name = "vmd",
.id_table = vmd_pci_driver_id,
.drv_flags = SPDK_PCI_DRIVER_NEED_MAPPING |
SPDK_PCI_DRIVER_WC_ACTIVATE
};
struct spdk_pci_driver *
@ -61,4 +53,4 @@ spdk_pci_vmd_get_driver(void)
return &g_vmd_pci_drv;
}
SPDK_PMD_REGISTER_PCI(g_vmd_pci_drv);
SPDK_PCI_DRIVER_REGISTER(g_vmd_pci_drv);