From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 96AF8A00BE; Tue, 19 Apr 2022 18:14:48 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 3F4804068E; Tue, 19 Apr 2022 18:14:48 +0200 (CEST) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by mails.dpdk.org (Postfix) with ESMTP id 04C5D40687 for ; Tue, 19 Apr 2022 18:14:46 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1650384887; x=1681920887; h=from:to:cc:subject:date:message-id:mime-version: content-transfer-encoding; bh=ZIanRpTj3YReFaNoPD+N8r03xB8YtSqVHIjzMb9FnQQ=; b=gDHIxhmtu1qB3jb2Ts4hNvHac0KpJYgsaJZSj7c5TJW/UH5bDKIZhaHy A2/+9vfdoWxiBHPlQ2O2wWE9MB9JPBl19d5rAYRD/ukj1T11zTqeYByNg 0apB6w9jtW1cdVXBln3sFltR2LqzCCo6IOJfz39rYruCJ0kjWFKdsiHkr PgMe+31y65fy4PoemQ9hb4CjDEq/uu/HF5lCQQNmfP0fTUNP84a32jmee 0tJgp5cSbNEtkV7bf+6WTP0EXkG/zmAc3uT8GO4zVMq5/+RRkuVJ5jvIn N4m9jt0kZNWv3Cf+RUU0GCvXY5R5pq/aZXi7+an9IPqkHNgtzXJdwT4ZD A==; X-IronPort-AV: E=McAfee;i="6400,9594,10322"; a="251110482" X-IronPort-AV: E=Sophos;i="5.90,273,1643702400"; d="scan'208";a="251110482" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 19 Apr 2022 09:14:44 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.90,273,1643702400"; d="scan'208";a="727125408" Received: from silpixa00401122.ir.intel.com ([10.55.128.10]) by orsmga005.jf.intel.com with ESMTP; 19 Apr 2022 09:14:43 -0700 From: Kevin Laatz To: dev@dpdk.org Cc: Kevin Laatz Subject: [RFC] eal: add bus cleanup to eal cleanup Date: Tue, 19 Apr 2022 17:14:38 +0100 Message-Id: <20220419161438.1837860-1-kevin.laatz@intel.com> X-Mailer: git-send-email 2.31.1 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org During EAL init, all buses are probed and the devices found are initialized. On eal_cleanup(), the inverse does not happen, meaning any allocated memory and other configuration will not be cleaned up appropriately on exit. Currently, in order for device cleanup to take place, applications must call the driver-relevant functions to ensure proper cleanup is done before the application exits. Since initialization occurs for all devices on the bus, not just the devices used by an application, it requires a) application awareness of all bus devices that could have been probed on the system, and b) code duplication across applications to ensure cleanup is performed. An example of this is rte_eth_dev_close() which is commonly used across the example applications. This RFC proposes adding bus cleanup to the eal_cleanup() to make EAL's init/exit more symmetrical, ensuring all bus devices are cleaned up appropriately without the application needing to be aware of all bus types that may have been probed during initialization. Contained in this RFC are the changes required to perform cleanup for devices on the PCI bus during eal_cleanup(). This can be expanded in subsequent versions if these changes are desired. There would be an ask for bus maintainers to add the relevant cleanup for their buses since they have the domain expertise. Signed-off-by: Kevin Laatz --- drivers/bus/pci/pci_common.c | 29 +++++++++++++++++++++++++++++ lib/eal/common/eal_common_bus.c | 18 ++++++++++++++++++ lib/eal/include/rte_bus.h | 23 +++++++++++++++++++++++ lib/eal/linux/eal.c | 1 + 4 files changed, 71 insertions(+) diff --git a/drivers/bus/pci/pci_common.c b/drivers/bus/pci/pci_common.c index 37ab879779..ee6cce8fc6 100644 --- a/drivers/bus/pci/pci_common.c +++ b/drivers/bus/pci/pci_common.c @@ -394,6 +394,34 @@ pci_probe(void) return (probed && probed == failed) ? -1 : 0; } +static int +pci_cleanup(void) +{ + struct rte_pci_device *dev = NULL; + int ret = 0; + + FOREACH_DEVICE_ON_PCIBUS(dev) { + struct rte_pci_addr *loc = &dev->addr; + struct rte_pci_driver *drv = dev->driver; + + RTE_LOG(INFO, EAL, + "Clean up PCI driver: %s (%x:%x) device: "PCI_PRI_FMT" (socket %i)\n", + drv->driver.name, dev->id.vendor_id, dev->id.device_id, + loc->domain, loc->bus, loc->devid, loc->function, + dev->device.numa_node); + + ret = drv->remove(dev); + if (ret < 0) { + RTE_LOG(ERR, EAL, "Cleanup for device "PCI_PRI_FMT" failed\n", + dev->addr.domain, dev->addr.bus, dev->addr.devid, + dev->addr.function); + rte_errno = errno; + } + } + + return ret; +} + /* dump one device */ static int pci_dump_one_device(FILE *f, struct rte_pci_device *dev) @@ -813,6 +841,7 @@ struct rte_pci_bus rte_pci_bus = { .bus = { .scan = rte_pci_scan, .probe = pci_probe, + .cleanup = pci_cleanup, .find_device = pci_find_device, .plug = pci_plug, .unplug = pci_unplug, diff --git a/lib/eal/common/eal_common_bus.c b/lib/eal/common/eal_common_bus.c index baa5b532af..046a06a2bf 100644 --- a/lib/eal/common/eal_common_bus.c +++ b/lib/eal/common/eal_common_bus.c @@ -85,6 +85,24 @@ rte_bus_probe(void) return 0; } +/* Clean up all devices of all buses */ +int +rte_bus_cleanup(void) +{ + int ret; + struct rte_bus *bus; + + TAILQ_FOREACH(bus, &rte_bus_list, next) { + if (bus->cleanup == NULL) + continue; + ret = bus->cleanup(); + if (ret) + RTE_LOG(ERR, EAL, "Bus (%s) cleanup failed.\n", bus->name); + } + + return 0; +} + /* Dump information of a single bus */ static int bus_dump_one(FILE *f, struct rte_bus *bus) diff --git a/lib/eal/include/rte_bus.h b/lib/eal/include/rte_bus.h index bbbb6efd28..7dbc398408 100644 --- a/lib/eal/include/rte_bus.h +++ b/lib/eal/include/rte_bus.h @@ -66,6 +66,18 @@ typedef int (*rte_bus_scan_t)(void); */ typedef int (*rte_bus_probe_t)(void); +/** + * Implementation specific cleanup function which is responsible for cleaning up + * devices on that bus with applicable drivers. + * + * This is called while iterating over each registered bus. + * + * @return + * 0 for successful cleanup + * !0 for any error during cleanup + */ +typedef int (*rte_bus_cleanup_t)(void); + /** * Device iterator to find a device on a bus. * @@ -263,6 +275,7 @@ struct rte_bus { const char *name; /**< Name of the bus */ rte_bus_scan_t scan; /**< Scan for devices attached to bus */ rte_bus_probe_t probe; /**< Probe devices on bus */ + rte_bus_cleanup_t cleanup; /**< Cleanup devices on bus */ rte_bus_find_device_t find_device; /**< Find a device on the bus */ rte_bus_plug_t plug; /**< Probe single device for drivers */ rte_bus_unplug_t unplug; /**< Remove single device from driver */ @@ -317,6 +330,16 @@ int rte_bus_scan(void); */ int rte_bus_probe(void); +/** + * For each device on the buses, perform a driver 'match' and call the + * driver-specific function for device cleanup. + * + * @return + * 0 for successful match/cleanup + * !0 otherwise + */ +int rte_bus_cleanup(void); + /** * Dump information of all the buses registered with EAL. * diff --git a/lib/eal/linux/eal.c b/lib/eal/linux/eal.c index 025e5cc10d..37983b98c0 100644 --- a/lib/eal/linux/eal.c +++ b/lib/eal/linux/eal.c @@ -1268,6 +1268,7 @@ rte_eal_cleanup(void) vfio_mp_sync_cleanup(); #endif rte_mp_channel_cleanup(); + rte_bus_cleanup(); /* after this point, any DPDK pointers will become dangling */ rte_eal_memory_detach(); eal_mp_dev_hotplug_cleanup(); -- 2.31.1