[v8] eal: add bus cleanup to eal cleanup
Checks
Commit Message
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 patch 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 patch are the changes required to perform cleanup for
devices on the PCI bus and VDEV bus during eal_cleanup(). 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 <kevin.laatz@intel.com>
Acked-by: Morten Brørup <mb@smartsharesystems.com>
Reviewed-by: Bruce Richardson <bruce.richardson@intel.com>
---
v8:
* rebase
v7:
* free rte_pci_device structs during cleanup
* free rte_vdev_device structs during cleanup
v6:
* fix units in doc API descriptions
v5:
* add doc updates for new APIs
v4:
* fix return value when scaling_freq_max is not set
* fix mismatching comments
v3:
* move setters from arg parse function to init
* consider 0 as 'not set' for scaling_freq_max
* other minor fixes
v2:
* add doc update for l3fwd-power
* order version.map additions alphabetically
---
drivers/bus/pci/pci_common.c | 28 ++++++++++++++++++++++++++++
drivers/bus/vdev/vdev.c | 27 +++++++++++++++++++++++++++
lib/eal/common/eal_common_bus.c | 17 +++++++++++++++++
lib/eal/common/eal_private.h | 10 ++++++++++
lib/eal/freebsd/eal.c | 1 +
lib/eal/include/bus_driver.h | 13 +++++++++++++
lib/eal/linux/eal.c | 1 +
lib/eal/windows/eal.c | 1 +
8 files changed, 98 insertions(+)
Comments
On Tue, Oct 4, 2022 at 3:08 PM Kevin Laatz <kevin.laatz@intel.com> wrote:
>
> 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 patch 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 patch are the changes required to perform cleanup for
> devices on the PCI bus and VDEV bus during eal_cleanup(). 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 <kevin.laatz@intel.com>
> Acked-by: Morten Brørup <mb@smartsharesystems.com>
> Reviewed-by: Bruce Richardson <bruce.richardson@intel.com>
>
Thanks for the rebase.
Most of it lgtm, just one question/comment.
[snip]
> diff --git a/lib/eal/freebsd/eal.c b/lib/eal/freebsd/eal.c
> index a1bb5363b1..b9a7792c19 100644
> --- a/lib/eal/freebsd/eal.c
> +++ b/lib/eal/freebsd/eal.c
> @@ -896,6 +896,7 @@ rte_eal_cleanup(void)
> rte_mp_channel_cleanup();
> rte_trace_save();
> eal_trace_fini();
> + eal_bus_cleanup();
> /* after this point, any DPDK pointers will become dangling */
> rte_eal_memory_detach();
> rte_eal_alarm_cleanup();
Do you have a reason to put the bus cleanup after the traces are
stored and the trace subsystem is uninitialised?
With the current location for eal_bus_cleanup(), it means that this
function (and any code it calls) is not traceable.
To be fair, I don't think we have any trace points in this code at the
moment, but we might have in the future.
On 04/10/2022 16:28, David Marchand wrote:
> On Tue, Oct 4, 2022 at 3:08 PM Kevin Laatz <kevin.laatz@intel.com> wrote:
>> 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 patch 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 patch are the changes required to perform cleanup for
>> devices on the PCI bus and VDEV bus during eal_cleanup(). 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 <kevin.laatz@intel.com>
>> Acked-by: Morten Brørup <mb@smartsharesystems.com>
>> Reviewed-by: Bruce Richardson <bruce.richardson@intel.com>
>>
> Thanks for the rebase.
> Most of it lgtm, just one question/comment.
>
> [snip]
>
>> diff --git a/lib/eal/freebsd/eal.c b/lib/eal/freebsd/eal.c
>> index a1bb5363b1..b9a7792c19 100644
>> --- a/lib/eal/freebsd/eal.c
>> +++ b/lib/eal/freebsd/eal.c
>> @@ -896,6 +896,7 @@ rte_eal_cleanup(void)
>> rte_mp_channel_cleanup();
>> rte_trace_save();
>> eal_trace_fini();
>> + eal_bus_cleanup();
>> /* after this point, any DPDK pointers will become dangling */
>> rte_eal_memory_detach();
>> rte_eal_alarm_cleanup();
> Do you have a reason to put the bus cleanup after the traces are
> stored and the trace subsystem is uninitialised?
>
> With the current location for eal_bus_cleanup(), it means that this
> function (and any code it calls) is not traceable.
> To be fair, I don't think we have any trace points in this code at the
> moment, but we might have in the future.
No reason for doing it after trace un-init. I'll move and resend.
Thanks!
@@ -25,6 +25,7 @@
#include <rte_common.h>
#include <rte_devargs.h>
#include <rte_vfio.h>
+#include <rte_tailq.h>
#include "private.h"
@@ -439,6 +440,32 @@ pci_probe(void)
return (probed && probed == failed) ? -1 : 0;
}
+static int
+pci_cleanup(void)
+{
+ struct rte_pci_device *dev, *tmp_dev;
+ int error = 0;
+
+ RTE_TAILQ_FOREACH_SAFE(dev, &rte_pci_bus.device_list, next, tmp_dev) {
+ struct rte_pci_driver *drv = dev->driver;
+ int ret = 0;
+
+ if (drv == NULL || drv->remove == NULL)
+ continue;
+
+ ret = drv->remove(dev);
+ if (ret < 0) {
+ rte_errno = errno;
+ error = -1;
+ }
+ dev->driver = NULL;
+ dev->device.driver = NULL;
+ free(dev);
+ }
+
+ return error;
+}
+
/* dump one device */
static int
pci_dump_one_device(FILE *f, struct rte_pci_device *dev)
@@ -856,6 +883,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,
@@ -567,6 +567,32 @@ vdev_probe(void)
return ret;
}
+static int
+vdev_cleanup(void)
+{
+ struct rte_vdev_device *dev, *tmp_dev;
+ int error = 0;
+
+ RTE_TAILQ_FOREACH_SAFE(dev, &vdev_device_list, next, tmp_dev) {
+ const struct rte_vdev_driver *drv;
+ int ret = 0;
+
+ drv = container_of(dev->device.driver, const struct rte_vdev_driver, driver);
+
+ if (drv == NULL || drv->remove == NULL)
+ continue;
+
+ ret = drv->remove(dev);
+ if (ret < 0)
+ error = -1;
+
+ dev->device.driver = NULL;
+ free(dev);
+ }
+
+ return error;
+}
+
struct rte_device *
rte_vdev_find_device(const struct rte_device *start, rte_dev_cmp_t cmp,
const void *data)
@@ -625,6 +651,7 @@ vdev_get_iommu_class(void)
static struct rte_bus rte_vdev_bus = {
.scan = vdev_scan,
.probe = vdev_probe,
+ .cleanup = vdev_cleanup,
.find_device = rte_vdev_find_device,
.plug = vdev_plug,
.unplug = vdev_unplug,
@@ -91,6 +91,23 @@ rte_bus_probe(void)
return 0;
}
+/* Clean up all devices of all buses */
+int
+eal_bus_cleanup(void)
+{
+ int ret = 0;
+ struct rte_bus *bus;
+
+ TAILQ_FOREACH(bus, &rte_bus_list, next) {
+ if (bus->cleanup == NULL)
+ continue;
+ if (bus->cleanup() != 0)
+ ret = -1;
+ }
+
+ return ret;
+}
+
/* Dump information of a single bus */
static int
bus_dump_one(FILE *f, struct rte_bus *bus)
@@ -441,6 +441,16 @@ int rte_eal_memory_detach(void);
*/
struct rte_bus *rte_bus_find_by_device_name(const char *str);
+/**
+ * For each device on the buses, call the driver-specific function for
+ * device cleanup.
+ *
+ * @return
+ * 0 for successful cleanup
+ * !0 otherwise
+ */
+int eal_bus_cleanup(void);
+
/**
* Create the unix channel for primary/secondary communication.
*
@@ -896,6 +896,7 @@ rte_eal_cleanup(void)
rte_mp_channel_cleanup();
rte_trace_save();
eal_trace_fini();
+ eal_bus_cleanup();
/* after this point, any DPDK pointers will become dangling */
rte_eal_memory_detach();
rte_eal_alarm_cleanup();
@@ -205,6 +205,18 @@ typedef int (*rte_bus_hot_unplug_handler_t)(struct rte_device *dev);
*/
typedef int (*rte_bus_sigbus_handler_t)(const void *failure_addr);
+/**
+ * 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);
+
/**
* Bus scan policies
*/
@@ -256,6 +268,7 @@ struct rte_bus {
/**< handle hot-unplug failure on the bus */
rte_bus_sigbus_handler_t sigbus_handler;
/**< handle sigbus error on the bus */
+ rte_bus_cleanup_t cleanup; /**< Cleanup devices on bus */
};
/**
@@ -1365,6 +1365,7 @@ rte_eal_cleanup(void)
rte_mp_channel_cleanup();
rte_trace_save();
eal_trace_fini();
+ eal_bus_cleanup();
/* after this point, any DPDK pointers will become dangling */
rte_eal_memory_detach();
eal_mp_dev_hotplug_cleanup();
@@ -263,6 +263,7 @@ rte_eal_cleanup(void)
eal_intr_thread_cancel();
eal_mem_virt2iova_cleanup();
+ eal_bus_cleanup();
/* after this point, any DPDK pointers will become dangling */
rte_eal_memory_detach();
eal_cleanup_config(internal_conf);