/
phprus
/
github_dpdk
Обзор
Документация
Войти
/
phprus
/
github_dpdk
Код
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
main
drivers/bus/platform/platform.c
517 строк
12 KB
David Marchand
bus: implement cleanup in EAL
25 июн 2026, 14:24
25 июн 2026, 14:24
add1eb0
Код
Авторство
О чём код?
/* SPDX-License-Identifier: BSD-3-Clause * Copyright(C) 2023 Marvell. */ #include <uapi/linux/vfio.h> #include <dirent.h> #include <inttypes.h> #include <stdlib.h> #include <string.h> #include <sys/ioctl.h> #include <sys/mman.h> #include <sys/queue.h> #include <unistd.h> #include <bus_driver.h> #include <bus_platform_driver.h> #include <eal_export.h> #include <eal_filesystem.h> #include <rte_bus.h> #include <rte_devargs.h> #include <rte_errno.h> #include <rte_log.h> #include <rte_memory.h> #include <rte_string_fns.h> #include <rte_vfio.h> #include "private.h" #define PLATFORM_BUS_DEVICES_PATH "/sys/bus/platform/devices" static struct rte_bus platform_bus; RTE_EXPORT_INTERNAL_SYMBOL(rte_platform_register) void rte_platform_register(struct rte_platform_driver *pdrv) { rte_bus_add_driver(&platform_bus, &pdrv->driver); } RTE_EXPORT_INTERNAL_SYMBOL(rte_platform_unregister) void rte_platform_unregister(struct rte_platform_driver *pdrv) { rte_bus_remove_driver(&platform_bus, &pdrv->driver); } static int dev_add(const char *dev_name) { struct rte_platform_device *pdev, *tmp; char path[PATH_MAX]; unsigned long val; pdev = calloc(1, sizeof(*pdev)); if (pdev == NULL) return -ENOMEM; rte_strscpy(pdev->name, dev_name, sizeof(pdev->name)); pdev->device.name = pdev->name; pdev->device.devargs = rte_bus_find_devargs(&platform_bus, dev_name); snprintf(path, sizeof(path), PLATFORM_BUS_DEVICES_PATH "/%s/numa_node", dev_name); pdev->device.numa_node = eal_parse_sysfs_value(path, &val) ? rte_socket_id() : val; RTE_BUS_FOREACH_DEV(tmp, &platform_bus) { if (!strcmp(tmp->name, pdev->name)) { PLATFORM_LOG_LINE(INFO, "device %s already added", pdev->name); if (tmp->device.devargs != pdev->device.devargs) rte_devargs_remove(pdev->device.devargs); free(pdev); return -EEXIST; } } rte_bus_add_device(&platform_bus, &pdev->device); PLATFORM_LOG_LINE(INFO, "adding device %s to the list", dev_name); return 0; } static char * dev_kernel_driver_name(const char *dev_name) { char path[PATH_MAX], buf[BUFSIZ] = { }; char *kdrv; int ret; snprintf(path, sizeof(path), PLATFORM_BUS_DEVICES_PATH "/%s/driver", dev_name); /* save space for NUL */ ret = readlink(path, buf, sizeof(buf) - 1); if (ret <= 0) return NULL; /* last token is kernel driver name */ kdrv = strrchr(buf, '/'); if (kdrv != NULL) return strdup(kdrv + 1); return NULL; } static bool dev_is_bound_vfio_platform(const char *dev_name) { char *kdrv; int ret; kdrv = dev_kernel_driver_name(dev_name); if (!kdrv) return false; ret = strcmp(kdrv, "vfio-platform"); free(kdrv); return ret == 0; } static int platform_bus_scan(void) { const struct dirent *ent; const char *dev_name; int ret = 0; DIR *dp; dp = opendir(PLATFORM_BUS_DEVICES_PATH); if (dp == NULL) { PLATFORM_LOG_LINE(INFO, "failed to open %s", PLATFORM_BUS_DEVICES_PATH); return -errno; } while ((ent = readdir(dp))) { dev_name = ent->d_name; if (dev_name[0] == '.') continue; if (rte_bus_device_is_ignored(&platform_bus, dev_name)) continue; if (!dev_is_bound_vfio_platform(dev_name)) continue; ret = dev_add(dev_name); if (ret) break; } closedir(dp); return ret; } static int device_map_resource_offset(struct rte_platform_device *pdev, struct rte_platform_resource *res, size_t offset) { res->mem.addr = mmap(NULL, res->mem.len, PROT_READ | PROT_WRITE, MAP_SHARED, pdev->dev_fd, offset); if (res->mem.addr == MAP_FAILED) return -errno; PLATFORM_LOG_LINE(DEBUG, "adding resource va = %p len = %"PRIu64" name = %s", res->mem.addr, res->mem.len, res->name); return 0; } static void device_unmap_resources(struct rte_platform_device *pdev) { struct rte_platform_resource *res; unsigned int i; for (i = 0; i < pdev->num_resource; i++) { res = &pdev->resource[i]; munmap(res->mem.addr, res->mem.len); free(res->name); } free(pdev->resource); pdev->resource = NULL; pdev->num_resource = 0; } static int read_sysfs_string(const char *path, char *buf, size_t size) { FILE *f; char *p; f = fopen(path, "r"); if (f == NULL) return -errno; if (fgets(buf, size, f) == NULL) { fclose(f); return -ENODATA; } fclose(f); p = strrchr(buf, '\n'); if (p != NULL) *p = '\0'; return 0; } static char * of_resource_name(const char *dev_name, int index) { char path[PATH_MAX], buf[BUFSIZ] = { }; int num = 0, ret; char *name; snprintf(path, sizeof(path), PLATFORM_BUS_DEVICES_PATH "/%s/of_node/reg-names", dev_name); ret = read_sysfs_string(path, buf, sizeof(buf) - 1); if (ret) return NULL; for (name = buf; *name != 0; name += strlen(name) + 1) { if (num++ != index) continue; return strdup(name); } return NULL; } static int device_map_resources(struct rte_platform_device *pdev, unsigned int num) { struct rte_platform_resource *res; unsigned int i; int ret; if (num == 0) { PLATFORM_LOG_LINE(WARNING, "device %s has no resources", pdev->name); return 0; } pdev->resource = calloc(num, sizeof(*pdev->resource)); if (pdev->resource == NULL) return -ENOMEM; for (i = 0; i < num; i++) { struct vfio_region_info reg_info = { .argsz = sizeof(reg_info), .index = i, }; ret = ioctl(pdev->dev_fd, VFIO_DEVICE_GET_REGION_INFO, ®_info); if (ret) { PLATFORM_LOG_LINE(ERR, "failed to get region info at %d", i); ret = -errno; goto out; } res = &pdev->resource[i]; res->name = of_resource_name(pdev->name, reg_info.index); res->mem.len = reg_info.size; ret = device_map_resource_offset(pdev, res, reg_info.offset); if (ret) { PLATFORM_LOG_LINE(ERR, "failed to ioremap resource at %d", i); goto out; } pdev->num_resource++; } return 0; out: device_unmap_resources(pdev); return ret; } static void device_cleanup(struct rte_platform_device *pdev) { device_unmap_resources(pdev); rte_vfio_release_device(PLATFORM_BUS_DEVICES_PATH, pdev->name, pdev->dev_fd); } static int device_setup(struct rte_platform_device *pdev) { struct vfio_device_info dev_info = { .argsz = sizeof(dev_info), }; const char *name = pdev->name; int ret; ret = rte_vfio_setup_device(PLATFORM_BUS_DEVICES_PATH, name, &pdev->dev_fd, &dev_info); if (ret) { PLATFORM_LOG_LINE(ERR, "failed to setup %s", name); return -ENODEV; } /* This is an extra check to confirm that platform device was initialized * by a kernel vfio-platform driver. On kernels that predate vfio-platform * driver this flag obviously does not exist. In such scenarios this * check needs to be removed otherwise compilation fails. * * Now, on such old kernels code will never reach here because * there is another check much earlier which verifies whether * device has been bound to vfio-platform driver. */ #ifdef VFIO_DEVICE_FLAGS_PLATFORM if (!(dev_info.flags & VFIO_DEVICE_FLAGS_PLATFORM)) { PLATFORM_LOG_LINE(ERR, "device not backed by vfio-platform"); ret = -ENOTSUP; goto out; } #endif ret = device_map_resources(pdev, dev_info.num_regions); if (ret) { PLATFORM_LOG_LINE(ERR, "failed to setup platform resources"); goto out; } return 0; out: device_cleanup(pdev); return ret; } static int driver_call_probe(struct rte_platform_driver *pdrv, struct rte_platform_device *pdev) { if (pdrv->probe != NULL) return pdrv->probe(pdev); return 0; } static int driver_probe_device(struct rte_platform_driver *pdrv, struct rte_platform_device *pdev) { enum rte_iova_mode iova_mode; int ret; iova_mode = rte_eal_iova_mode(); if (pdrv->drv_flags & RTE_PLATFORM_DRV_NEED_IOVA_AS_VA && iova_mode != RTE_IOVA_VA) { PLATFORM_LOG_LINE(ERR, "driver %s expects VA IOVA mode but current mode is PA", pdrv->driver.name); return -EINVAL; } ret = device_setup(pdev); if (ret) return ret; ret = driver_call_probe(pdrv, pdev); if (ret) device_cleanup(pdev); return ret; } static bool platform_bus_match(const struct rte_driver *drv, const struct rte_device *dev) { const struct rte_platform_driver *pdrv = RTE_BUS_DRIVER(drv, *pdrv); const struct rte_platform_device *pdev = RTE_BUS_DEVICE(dev, *pdev); bool match = false; char *kdrv; kdrv = dev_kernel_driver_name(pdev->name); if (!kdrv) return false; /* match by driver name */ if (!strcmp(kdrv, pdrv->driver.name)) { match = true; goto out; } /* match by driver alias */ if (pdrv->driver.alias != NULL && !strcmp(kdrv, pdrv->driver.alias)) { match = true; goto out; } /* match by device name */ if (!strcmp(pdev->name, pdrv->driver.name)) match = true; out: free(kdrv); return match; } static int platform_bus_probe_device(struct rte_driver *drv, struct rte_device *dev) { if (!dev_is_bound_vfio_platform(dev->name)) return -EPERM; return driver_probe_device(RTE_BUS_DRIVER(drv, struct rte_platform_driver), RTE_BUS_DEVICE(dev, struct rte_platform_device)); } static void device_release_driver(struct rte_platform_device *pdev) { const struct rte_platform_driver *pdrv = RTE_BUS_DRIVER(pdev->device.driver, *pdrv); int ret; if (pdrv->remove != NULL) { ret = pdrv->remove(pdev); if (ret) PLATFORM_LOG_LINE(WARNING, "failed to remove %s", pdev->name); } } static int platform_bus_unplug_device(struct rte_device *dev) { struct rte_platform_device *pdev = RTE_BUS_DEVICE(dev, *pdev); device_release_driver(pdev); device_cleanup(pdev); return 0; } static int platform_bus_parse(const char *name, void *addr) { struct rte_platform_device pdev = { }; struct rte_platform_driver *pdrv; const char **out = addr; rte_strscpy(pdev.name, name, sizeof(pdev.name)); RTE_BUS_FOREACH_DRV(pdrv, &platform_bus) { if (platform_bus_match(&pdrv->driver, &pdev.device)) break; } if (pdrv != NULL && addr != NULL) *out = name; return pdrv != NULL ? 0 : -ENODEV; } static int platform_bus_dma_map(struct rte_device *dev, void *addr, uint64_t iova, size_t len) { struct rte_platform_device *pdev = RTE_BUS_DEVICE(dev, *pdev); const struct rte_platform_driver *pdrv = RTE_BUS_DRIVER(dev->driver, *pdrv); if (pdrv->dma_map != NULL) return pdrv->dma_map(pdev, addr, iova, len); return rte_vfio_container_dma_map(RTE_VFIO_DEFAULT_CONTAINER_FD, (uint64_t)addr, iova, len); } static int platform_bus_dma_unmap(struct rte_device *dev, void *addr, uint64_t iova, size_t len) { struct rte_platform_device *pdev = RTE_BUS_DEVICE(dev, *pdev); const struct rte_platform_driver *pdrv = RTE_BUS_DRIVER(dev->driver, *pdrv); if (pdrv->dma_unmap != NULL) return pdrv->dma_unmap(pdev, addr, iova, len); return rte_vfio_container_dma_unmap(RTE_VFIO_DEFAULT_CONTAINER_FD, (uint64_t)addr, iova, len); } static enum rte_iova_mode platform_bus_get_iommu_class(void) { const struct rte_platform_driver *pdrv; struct rte_platform_device *pdev; RTE_BUS_FOREACH_DEV(pdev, &platform_bus) { if (!rte_dev_is_probed(&pdev->device)) continue; pdrv = RTE_BUS_DRIVER(pdev->device.driver, *pdrv); if (pdrv->drv_flags & RTE_PLATFORM_DRV_NEED_IOVA_AS_VA) return RTE_IOVA_VA; } return RTE_IOVA_DC; } static void platform_free_device(struct rte_device *dev) { free(RTE_BUS_DEVICE(dev, struct rte_platform_device)); } static struct rte_bus platform_bus = { .scan = platform_bus_scan, .probe = rte_bus_generic_probe, .free_device = platform_free_device, .cleanup = rte_bus_generic_cleanup, .find_device = rte_bus_generic_find_device, .match = platform_bus_match, .probe_device = platform_bus_probe_device, .unplug_device = platform_bus_unplug_device, .parse = platform_bus_parse, .dma_map = platform_bus_dma_map, .dma_unmap = platform_bus_dma_unmap, .get_iommu_class = platform_bus_get_iommu_class, .dev_iterate = rte_bus_generic_dev_iterate, }; RTE_REGISTER_BUS(platform, platform_bus); RTE_LOG_REGISTER_DEFAULT(platform_bus_logtype, NOTICE);