Add NUMA aware async_schedule calls
Subsystems (6)
v10 cover Add NUMA aware async_schedule calls
This patch set provides functionality that will help to improve the locality of the async_schedule calls used to provide deferred initialization.
This patch set originally started out focused on just the one call to async_schedule_domain in the nvdimm tree that was being used to defer the device_add call however after doing some digging I realized the scope of this was much broader than I had originally planned. As such I went through and reworked the underlying infrastructure down to replacing the queue_work call itself with a function of my own and opted to try and provide a NUMA aware solution that would work for a broader audience.
In addition I have added several tweaks and/or clean-ups to the front of the patch set. Patches 1 through 3 address a number of issues that actually were causing the existing async_schedule calls to not show the performance that they could due to either not scaling on a per device basis, or due to issues that could result in a potential race. For example, patch 3 addresses the fact that we were calling async_schedule once per driver instead of once per device, and as a result we would have still ended up with devices being probed on a non-local node without addressing this first.
I have also updated the kernel module used to test async driver probing so that it can expose the original issue I was attempting to address. It will fail on a system of asynchronous work either takes longer than it takes to load a single device and a single driver with a device already added. It will also fail if the NUMA node that the driver is loaded on does not match the NUMA node the device is associated with.
RFC->v1:
Dropped nvdimm patch to submit later.
It relies on code in libnvdimm development tree.
Simplified queue_work_near to just convert node into a CPU. Split up drivers core and PM core patches.v1->v2:
Renamed queue_work_near to queue_work_node
Added WARN_ON_ONCE if we use queue_work_node with per-cpu workqueuev2->v3:
Added Acked-by for queue_work_node patch
Continued rename from _near to _node to be consistent with queue_work_node
Renamed async_schedule_near_domain to async_schedule_node_domain Renamed async_schedule_near to async_schedule_node
Added kerneldoc for new async_schedule_XXX functions
Updated patch description for patch 4 to include data on potential gainsv3->v4
Added patch to consolidate use of need_parent_lock
Make asynchronous driver probing explicit about use of drvdatav4->v5
Added patch to move async_synchronize_full to address deadlock Added bit async_probe to act as mutex for probe/remove calls Added back nvdimm patch as code it relies on is now in Linus's tree Incorporated review comments on parent & device locking consolidation Rebased on latest linux-nextv5->v6:
Drop the "This patch" or "This change" from start of patch descriptions. Drop unnecessary parenthesis in first patch
Use same wording for "selecting a CPU" in comments added in first patch Added kernel documentation for async_probe member of device Fixed up comments for async_schedule calls in patch 2
Moved code related setting async driver out of device.h and into dd.c Added Reviewed-by for several patchesv6->v7:
Fixed typo which had kernel doc refer to "lock" when I meant "unlock" Dropped "bool X:1" to "u8 X:1" from patch description
Added async_driver to device_private structure to store driver Dropped unecessary code shuffle from async_probe patch Reordered patches to move fixes up to front
Added Reviewed-by for several patches
Updated cover page and patch descriptions throughout the setv7->v8:
Replaced async_probe value with dead, only apply dead in device_del Dropped Reviewed-by from patch 2 due to significant changes Added Reviewed-by for patches reviewed by Luis Chamberlainv8->v9:
Dropped patch 1 as it was applied, shifted remaining patches by 1 Added new patch 9 that adds test framework for NUMA and sequential init Tweaked what is now patch 1, and added Reviewed-by from Dan Williamsv9->v10:
Moved "dead" from device struct to device_private struct Added Reviewed-by from Rafael to patch 1
Rebased on latest linux-next
---
Alexander Duyck (9):
driver core: Establish order of operations for device_add and device_del via bitflag device core: Consolidate locking and unlocking of parent and device driver core: Probe devices asynchronously instead of the driver
workqueue: Provide queue_work_node to queue work near a given NUMA node
async: Add support for queueing on specific NUMA node
driver core: Attach devices on CPU local to device node
PM core: Use new async_schedule_dev command
libnvdimm: Schedule device registration on node local to the device driver core: Rewrite test_async_driver_probe to cover serialization and NUMA affinity
drivers/base/base.h | 8 + drivers/base/bus.c | 46 +---- drivers/base/core.c | 11 + drivers/base/dd.c | 160 +++++++++++++---- drivers/base/power/main.c | 12 + drivers/base/test/test_async_driver_probe.c | 261 +++++++++++++++++++++------ drivers/nvdimm/bus.c | 11 + include/linux/async.h | 82 ++++++++ include/linux/workqueue.h | 2 kernel/async.c | 53 +++-- kernel/workqueue.c | 84 +++++++++ 11 files changed, 564 insertions(+), 166 deletions(-)
--
PATCH v10 1/9 driver core: Establish order of operations for device_add and device_del via bitflag
Add an additional bit flag to the device_private struct named "dead".
This additional flag provides a guarantee that when a device_del is executed on a given interface an async worker will not attempt to attach the driver following the earlier device_del call. Previously this guarantee was not present and could result in the device_del call attempting to remove a driver from an interface only to have the async worker attempt to probe the driver later when it finally completes the asynchronous probe call.
One additional change added was that I pulled the check for dev->driver out of the __device_attach_driver call and instead placed it in the __device_attach_async_helper call. This was motivated by the fact that the only other caller of this, __device_attach, had already taken the device_lock() and checked for dev->driver. Instead of testing for this twice in this path it makes more sense to just consolidate the dev->dead and dev->driver checks together into one set of checks.
--- drivers/base/base.h | 4 ++++ drivers/base/core.c | 11 +++++++++++ drivers/base/dd.c | 22 +++++++++++----------- 3 files changed, 26 insertions(+), 11 deletions(-)
drivers/base/base.h +4 -0
@@ -67,6 +67,9 @@ struct driver_private {* probed first. * @device - pointer back to the struct device that this structure is * associated with. +* @dead - This device is currently either in the process of or has been +* removed from the system. Any asynchronous events scheduled for this +* device should exit without taking any action. * * Nothing outside of the driver core should ever touch these fields. */
@@ -78,6 +81,7 @@ struct device_private {struct klist_node knode_class;struct list_head deferred_probe;struct device *device; + u8 dead:1; };#define to_device_private_parent (obj) \ container_of(obj, struct device_private, knode_parent)
drivers/base/core.c +11 -0
@@ -2080,6 +2080,17 @@ void device_del(struct device *dev)struct kobject *glue_dir =NULL ;struct class_interface *class_intf; +/* +* Hold the device lock and set the "dead" flag to guarantee that +* the update behavior is consistent with the other bitfields near +* it and that we cannot have an asynchronous probe routine trying +* to run while we are tearing out the bus/class/sysfs from +* underneath the device. +*/ +device_lock (dev); + dev->p->dead = true; +device_unlock (dev); +/* Notify clients of device removal. This call must come * before dpm_sysfs_remove(). */
drivers/base/dd.c +11 -11
@@ -731,15 +731,6 @@ static int __device_attach_driver(struct device_driver *drv, void *_data)bool async_allowed;int ret; -/* -* Check if device has already been claimed. This may -* happen with driver loading, device discovery/registration, -* and deferred probe processing happens all at once with -* multiple threads. -*/ -if (dev->driver) -return -EBUSY ; - ret =driver_match_device (drv, dev);if (ret ==0 ) {/* no match */
@@ -774,6 +765,15 @@ static void __device_attach_async_helper(void *_dev, async_cookie_t cookie)device_lock (dev); +/* +* Check if device has already been removed or claimed. This may +* happen with driver loading, device discovery/registration, +* and deferred probe processing happens all at once with +* multiple threads. +*/ +if (dev->p->dead || dev->driver) + goto out_unlock; +if (dev->parent)pm_runtime_get_sync (dev->parent);
@@ -784,7 +784,7 @@ static void __device_attach_async_helper(void *_dev, async_cookie_t cookie)if (dev->parent)pm_runtime_put (dev->parent); - +out_unlock:device_unlock (dev);put_device (dev);
@@ -897,7 +897,7 @@ static int __driver_attach(struct device *dev, void *data)if (dev->parent && dev->bus->need_parent_lock)device_lock (dev->parent);device_lock (dev); -if (!dev->driver) +if (!dev->p->dead && !dev->driver)driver_probe_device (drv, dev);device_unlock (dev);if (dev->parent && dev->bus->need_parent_lock)
PATCH v10 2/9 device core: Consolidate locking and unlocking of parent and device
In reply to Alexander DuyckTry to consolidate all of the locking and unlocking of both the parent and device when attaching or removing a driver from a given device.
To do that I first consolidated the lock pattern into two functions __device_driver_lock and __device_driver_unlock. After doing that I then created functions specific to attaching and detaching the driver while acquiring these locks. By doing this I was able to reduce the number of spots where we touch need_parent_lock from 12 down to 4.
This patch should produce no functional changes, it is meant to be a code clean-up/consolidation only.
--- drivers/base/base.h | 2 + drivers/base/bus.c | 23 ++---------- drivers/base/dd.c | 95 ++++++++++++++++++++++++++++++++++++++++----------- 3 files changed, 81 insertions(+), 39 deletions(-)
drivers/base/base.h +2 -0
@@ -132,6 +132,8 @@ extern int driver_add_groups(struct device_driver *drv, const struct attribute_group **groups);extern void driver_remove_groups (struct device_driver *drv,const struct attribute_group **groups); +int device_driver_attach (struct device_driver *drv,struct device *dev); +void device_driver_detach (struct device *dev);extern char *make_class_name (const char *name,struct kobject *kobj);
drivers/base/bus.c +4 -19
@@ -187,11 +187,7 @@ static ssize_t unbind_store(struct device_driver *drv, const char *buf, dev =bus_find_device_by_name (bus,NULL , buf);if (dev && dev->driver == drv) { -if (dev->parent && dev->bus->need_parent_lock) -device_lock (dev->parent); -device_release_driver (dev); -if (dev->parent && dev->bus->need_parent_lock) -device_unlock (dev->parent); +device_driver_detach (dev); err = count; }put_device (dev);
@@ -214,13 +210,7 @@ static ssize_t bind_store(struct device_driver *drv, const char *buf, dev =bus_find_device_by_name (bus,NULL , buf);if (dev && dev->driver ==NULL &&driver_match_device (drv, dev)) { -if (dev->parent && bus->need_parent_lock) -device_lock (dev->parent); -device_lock (dev); - err =driver_probe_device (drv, dev); -device_unlock (dev); -if (dev->parent && bus->need_parent_lock) -device_unlock (dev->parent); + err =device_driver_attach (drv, dev);if (err >0 ) {/* success */
@@ -773,13 +763,8 @@ EXPORT_SYMBOL_GPL(bus_rescan_devices);*/ int device_reprobe (struct device *dev) { -if (dev->driver) { -if (dev->parent && dev->bus->need_parent_lock) -device_lock (dev->parent); -device_release_driver (dev); -if (dev->parent && dev->bus->need_parent_lock) -device_unlock (dev->parent); - } +if (dev->driver) +device_driver_detach (dev);return bus_rescan_devices_helper (dev,NULL ); }EXPORT_SYMBOL_GPL (device_reprobe);
drivers/base/dd.c +75 -20
132 lines not on this page · raw message
PATCH v10 3/9 driver core: Probe devices asynchronously instead of the driver
In reply to Alexander DuyckProbe devices asynchronously instead of the driver. This results in us seeing the same behavior if the device is registered before the driver or after. This way we can avoid serializing the initialization should the driver not be loaded until after the devices have already been added.
The motivation behind this is that if we have a set of devices that take a significant amount of time to load we can greatly reduce the time to load by processing them in parallel instead of one at a time. In addition, each device can exist on a different node so placing a single thread on one CPU to initialize all of the devices for a given driver can result in poor performance on a system with multiple nodes.
This approach can reduce the time needed to scan SCSI LUNs significantly. The only way to realize that speedup is by enabling more concurrency which is what is achieved with this patch.
To achieve this it was necessary to add a new member "async_driver" to the device_private structure to store the driver pointer while we wait on the deferred probe call.
--- drivers/base/base.h | 2 ++ drivers/base/bus.c | 23 +++-------------------- drivers/base/dd.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 48 insertions(+), 20 deletions(-)
drivers/base/base.h +2 -0
@@ -65,6 +65,7 @@ struct driver_private {* binding of drivers which were unable to get all the resources needed by * the device; typically because it depends on another driver getting * probed first. +* @async_driver - pointer to device driver awaiting probe via async_probe * @device - pointer back to the struct device that this structure is * associated with. * @dead - This device is currently either in the process of or has been
@@ -80,6 +81,7 @@ struct device_private {struct klist_node knode_bus;struct klist_node knode_class;struct list_head deferred_probe; +struct device_driver *async_driver;struct device *device; u8 dead:1; };
drivers/base/bus.c +3 -20
@@ -610,17 +610,6 @@ static ssize_t uevent_store(struct device_driver *drv, const char *buf, }static DRIVER_ATTR_WO (uevent); -static void driver_attach_async (void *_drv,async_cookie_t cookie) -{ -struct device_driver *drv = _drv; -int ret; - - ret =driver_attach (drv); - -pr_debug ("bus: '%s': driver %s async attach completed: %d\n" , - drv->bus->name, drv->name, ret); -} -/** * bus_add_driver - Add a driver to the bus. * @drv: driver.
@@ -653,15 +642,9 @@ int bus_add_driver(struct device_driver *drv)klist_add_tail (&priv->knode_bus, &bus->p->klist_drivers);if (drv->bus->p->drivers_autoprobe) { -if (driver_allows_async_probing (drv)) { -pr_debug ("bus: '%s': probing driver %s asynchronously\n" , - drv->bus->name, drv->name); -async_schedule (driver_attach_async, drv); - }else { - error =driver_attach (drv); -if (error) - goto out_unregister; - } + error =driver_attach (drv); +if (error) + goto out_unregister; }module_add_driver (drv->owner, drv);
drivers/base/dd.c +43 -0
55 lines not on this page · raw message
Re: [driver-core PATCH v10 3/9] driver core: Probe devices asynchronously instead of the driver
Quoted 16 lines · CET Alexander Duyck
Probe devices asynchronously instead of the driver. This results in us seeing the same behavior if the device is registered before the driver or after. This way we can avoid serializing the initialization should the driver not be loaded until after the devices have already been added.
The motivation behind this is that if we have a set of devices that take a significant amount of time to load we can greatly reduce the time to load by processing them in parallel instead of one at a time. In addition, each device can exist on a different node so placing a single thread on one CPU to initialize all of the devices for a given driver can result in poor performance on a system with multiple nodes.
This approach can reduce the time needed to scan SCSI LUNs significantly. The only way to realize that speedup is by enabling more concurrency which is what is achieved with this patch.
Quoted 7 lines
To achieve this it was necessary to add a new member "
async_driver" to thedevice_privatestructure to store the driver pointer while we wait on the deferred probe call.Reviewed-by Bart Van Assche <[email protected]>Reviewed-by Dan Williams <[email protected]>Signed-off-by Alexander Duyck <[email protected]>
Quoted 130 lines
--- drivers/base/base.h | 2 ++ drivers/base/bus.c | 23 +++-------------------- drivers/base/dd.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 48 insertions(+), 20 deletions(-)drivers/base/base.h +2
-0@@ -65,6 +65,7 @@ struct driver_private {* binding of drivers which were unable to get all the resources needed by * the device; typically because it depends on another driver getting * probed first. +* @async_driver - pointer to device driver awaiting probe via async_probe * @device - pointer back to the struct device that this structure is * associated with. * @dead - This device is currently either in the process of or has been @@ -80,6 +81,7 @@ struct device_private {struct klist_node knode_bus;struct klist_node knode_class;struct list_head deferred_probe; +struct device_driver *async_driver;struct device *device; u8 dead:1; };drivers/base/bus.c +3
-20@@ -610,17 +610,6 @@ static ssize_t uevent_store(struct device_driver *drv, const char *buf, }static DRIVER_ATTR_WO (uevent); -static void driver_attach_async (void *_drv,async_cookie_t cookie) -{ -struct device_driver *drv = _drv; -int ret; - - ret =driver_attach (drv); - -pr_debug ("bus: '%s': driver %s async attach completed: %d\n" , - drv->bus->name, drv->name, ret); -} -/** * bus_add_driver - Add a driver to the bus. * @drv: driver. @@ -653,15 +642,9 @@ int bus_add_driver(struct device_driver *drv)klist_add_tail (&priv->knode_bus, &bus->p->klist_drivers);if (drv->bus->p->drivers_autoprobe) { -if (driver_allows_async_probing (drv)) { -pr_debug ("bus: '%s': probing driver %s asynchronously\n" , - drv->bus->name, drv->name); -async_schedule (driver_attach_async, drv); - }else { - error =driver_attach (drv); -if (error) - goto out_unregister; - } + error =driver_attach (drv); +if (error) + goto out_unregister; }module_add_driver (drv->owner, drv);drivers/base/dd.c +43
-0@@ -925,6 +925,30 @@ int device_driver_attach(struct device_driver *drv, struct device *dev)return ret; } +static void __driver_attach_async_helper (void *_dev,async_cookie_t cookie) +{ +struct device *dev = _dev; +struct device_driver *drv; +int ret =0 ; + +__device_driver_lock (dev, dev->parent); + + drv = dev->p->async_driver; + +/* +* If device has been removed or someone has already successfully +* bound a driver before us just skip the driver probe call. +*/ +if (!dev->p->dead && !dev->driver) + ret =driver_probe_device (drv, dev); + +__device_driver_unlock (dev, dev->parent); + +dev_dbg (dev,"driver %s async attach completed: %d\n" , drv->name, ret); + +put_device (dev); +} +static int __driver_attach (struct device *dev,void *data) {struct device_driver *drv = data;@@ -952,6 +976,25 @@ static int __driver_attach(struct device *dev, void *data)return ret; }/* ret > 0 means positive match */ +if (driver_allows_async_probing (drv)) { +/* +* Instead of probing the device synchronously we will +* probe it asynchronously to allow for more parallelism. +* +* We only take the device lock here in order to guarantee +* that the dev->driver and async_driver fields are protected +*/ +dev_dbg (dev,"probing driver %s asynchronously\n" , drv->name); +device_lock (dev); +if (!dev->driver) { +get_device (dev); + dev->p->async_driver = drv; +async_schedule (__driver_attach_async_helper, dev); + } +device_unlock (dev); +return 0 ; + } +device_driver_attach (drv, dev);return 0 ;
PATCH v10 4/9 workqueue: Provide queue_work_node to queue work near a given NUMA node
In reply to Alexander DuyckProvide a new function, queue_work_node, which is meant to schedule work on a "random" CPU of the requested NUMA node. The main motivation for this is to help assist asynchronous init to better improve boot times for devices that are local to a specific node.
For now we just default to the first CPU that is in the intersection of the cpumask of the node and the online cpumask. The only exception is if the CPU is local to the node we will just use the current CPU. This should work for our purposes as we are currently only using this for unbound work so the CPU will be translated to a node anyway instead of being directly used.
As we are only using the first CPU to represent the NUMA node for now I am limiting the scope of the function so that it can only be used with unbound workqueues.
--- include/linux/workqueue.h | 2 + kernel/workqueue.c | 84 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 86 insertions(+)
include/linux/workqueue.h +2 -0
@@ -463,6 +463,8 @@ int workqueue_set_unbound_cpumask(cpumask_var_t cpumask);extern bool queue_work_on (int cpu,struct workqueue_struct *wq,struct work_struct *work); +extern bool queue_work_node (int node,struct workqueue_struct *wq, +struct work_struct *work);extern bool queue_delayed_work_on (int cpu,struct workqueue_struct *wq,struct delayed_work *work,unsigned long delay); extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
kernel/workqueue.c +84 -0
90 lines not on this page · raw message
PATCH v10 5/9 async: Add support for queueing on specific NUMA node
In reply to Alexander DuyckIntroduce four new variants of the async_schedule_ functions that allow scheduling on a specific NUMA node.
The first two functions are async_schedule_near and async_schedule_near_domain end up mapping to async_schedule and async_schedule_domain, but provide NUMA node specific functionality. They replace the original functions which were moved to inline function definitions that call the new functions while passing NUMA_NO_NODE.
The second two functions are async_schedule_dev and async_schedule_dev_domain which provide NUMA specific functionality when passing a device as the data member and that device has a NUMA node other than NUMA_NO_NODE.
The main motivation behind this is to address the need to be able to schedule device specific init work on specific NUMA nodes in order to improve performance of memory initialization.
I have seen a significant improvement in initialziation time for persistent memory as a result of this approach. In the case of 3TB of memory on a single node the initialization time in the worst case went from 36s down to about 26s for a 10s improvement. As such the data shows a general benefit for affinitizing the async work to the node local to the device.
--- include/linux/async.h | 82 +++++++++++++++++++++++++++++++++++++++++++++++-- kernel/async.c | 53 +++++++++++++++++--------------- 2 files changed, 108 insertions(+), 27 deletions(-)
include/linux/async.h +79 -3
@@ -14,6 +14,8 @@#include <linux/types.h> #include <linux/list.h> +#include <linux/numa.h> +#include <linux/device.h> typedef u64 async_cookie_t ;typedef void (*async_func_t ) (void *data,async_cookie_t cookie);
@@ -37,9 +39,83 @@ struct async_domain {struct async_domain _name = { .pending =LIST_HEAD_INIT (_name.pending), \ .registered = 0 } -extern async_cookie_t async_schedule (async_func_t func,void *data); -extern async_cookie_t async_schedule_domain (async_func_t func,void *data, -struct async_domain *domain); +async_cookie_t async_schedule_node (async_func_t func,void *data, +int node); +async_cookie_t async_schedule_node_domain (async_func_t func,void *data, +int node, +struct async_domain *domain); + +/** +* async_schedule - schedule a function for asynchronous execution +* @func: function to execute asynchronously +* @data: data pointer to pass to the function +* +* Returns an async_cookie_t that may be used for checkpointing later. +* Note: This function may be called from atomic or non-atomic contexts. +*/ +static inline async_cookie_t async_schedule (async_func_t func,void *data) +{ +return async_schedule_node (func, data,NUMA_NO_NODE ); +} + +/** +* async_schedule_domain - schedule a function for asynchronous execution within a certain domain +* @func: function to execute asynchronously +* @data: data pointer to pass to the function +* @domain: the domain +* +* Returns an async_cookie_t that may be used for checkpointing later. +* @domain may be used in the async_synchronize_*_domain() functions to +* wait within a certain synchronization domain rather than globally. +* Note: This function may be called from atomic or non-atomic contexts. +*/ +static inline async_cookie_t +async_schedule_domain (async_func_t func,void *data, +struct async_domain *domain) +{ +return async_schedule_node_domain (func, data,NUMA_NO_NODE , domain); +} + +/** +* async_schedule_dev - A device specific version of async_schedule +* @func: function to execute asynchronously +* @dev: device argument to be passed to function +* +* Returns an async_cookie_t that may be used for checkpointing later. +* @dev is used as both the argument for the function and to provide NUMA +* context for where to run the function. By doing this we can try to +* provide for the best possible outcome by operating on the device on the +* CPUs closest to the device. +* Note: This function may be called from atomic or non-atomic contexts. +*/ +static inline async_cookie_t +async_schedule_dev (async_func_t func,struct device *dev) +{ +return async_schedule_node (func, dev,dev_to_node (dev)); +} + +/** +* async_schedule_dev_domain - A device specific version of async_schedule_domain +* @func: function to execute asynchronously +* @dev: device argument to be passed to function +* @domain: the domain +* +* Returns an async_cookie_t that may be used for checkpointing later. +* @dev is used as both the argument for the function and to provide NUMA +* context for where to run the function. By doing this we can try to +* provide for the best possible outcome by operating on the device on the +* CPUs closest to the device. +* @domain may be used in the async_synchronize_*_domain() functions to +* wait within a certain synchronization domain rather than globally. +* Note: This function may be called from atomic or non-atomic contexts. +*/ +static inline async_cookie_t +async_schedule_dev_domain (async_func_t func,struct device *dev, +struct async_domain *domain) +{ +return async_schedule_node_domain (func, dev,dev_to_node (dev), domain); +} +void async_unregister_domain (struct async_domain *domain);extern void async_synchronize_full (void );extern void async_synchronize_full_domain (struct async_domain *domain);
kernel/async.c +29 -24
79 lines not on this page · raw message
PATCH v10 6/9 driver core: Attach devices on CPU local to device node
In reply to Alexander DuyckCall the asynchronous probe routines on a CPU local to the device node. By doing this we should be able to improve our initialization time significantly as we can avoid having to access the device from a remote node which may introduce higher latency.
For example, in the case of initializing memory for NVDIMM this can have a significant impact as initialing 3TB on remote node can take up to 39 seconds while initialing it on a local node only takes 23 seconds. It is situations like this where we will see the biggest improvement.
--- drivers/base/dd.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/base/dd.c +2 -2
@@ -829,7 +829,7 @@ static int __device_attach(struct device *dev, bool allow_async)*/ dev_dbg (dev,"scheduling asynchronous probe\n" );get_device (dev); -async_schedule (__device_attach_async_helper, dev); +async_schedule_dev (__device_attach_async_helper, dev); }else {pm_request_idle (dev); }
@@ -989,7 +989,7 @@ static int __driver_attach(struct device *dev, void *data)if (!dev->driver) {get_device (dev); dev->p->async_driver = drv; -async_schedule (__driver_attach_async_helper, dev); +async_schedule_dev (__driver_attach_async_helper, dev); }device_unlock (dev);return 0 ;
Re: [driver-core PATCH v10 6/9] driver core: Attach devices on CPU local to device node
Quoted 5 lines · CET Alexander Duyck
Call the asynchronous probe routines on a CPU local to the device node. By doing this we should be able to improve our initialization time significantly as we can avoid having to access the device from a remote node which may introduce higher latency.
Quoted 8 lines
For example, in the case of initializing memory for NVDIMM this can have a significant impact as initialing 3TB on remote node can take up to 39 seconds while initialing it on a local node only takes 23 seconds. It is situations like this where we will see the biggest improvement.
Reviewed-by Dan Williams <[email protected]>Reviewed-by Bart Van Assche <[email protected]>Signed-off-by Alexander Duyck <[email protected]>
Quoted 28 lines
--- drivers/base/dd.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)drivers/base/dd.c +2
-2@@ -829,7 +829,7 @@ static int __device_attach(struct device *dev, bool allow_async)*/ dev_dbg (dev,"scheduling asynchronous probe\n" );get_device (dev); -async_schedule (__device_attach_async_helper, dev); +async_schedule_dev (__device_attach_async_helper, dev); }else {pm_request_idle (dev); }@@ -989,7 +989,7 @@ static int __driver_attach(struct device *dev, void *data)if (!dev->driver) {get_device (dev); dev->p->async_driver = drv; -async_schedule (__driver_attach_async_helper, dev); +async_schedule_dev (__driver_attach_async_helper, dev); }device_unlock (dev);return 0 ;
PATCH v10 7/9 PM core: Use new async_schedule_dev command
In reply to Alexander DuyckUse the device specific version of the async_schedule commands to defer various tasks related to power management. By doing this we should see a slight improvement in performance as any device that is sensitive to latency/locality in the setup will now be initializing on the node closest to the device.
--- drivers/base/power/main.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/base/power/main.c +6 -6
@@ -727,7 +727,7 @@ void dpm_noirq_resume_devices(pm_message_t state)reinit_completion (&dev->power.completion);if (is_async (dev)) {get_device (dev); -async_schedule (async_resume_noirq, dev); +async_schedule_dev (async_resume_noirq, dev); } }
@@ -884,7 +884,7 @@ void dpm_resume_early(pm_message_t state)reinit_completion (&dev->power.completion);if (is_async (dev)) {get_device (dev); -async_schedule (async_resume_early, dev); +async_schedule_dev (async_resume_early, dev); } }
@@ -1048,7 +1048,7 @@ void dpm_resume(pm_message_t state)reinit_completion (&dev->power.completion);if (is_async (dev)) {get_device (dev); -async_schedule (async_resume, dev); +async_schedule_dev (async_resume, dev); } }
@@ -1368,7 +1368,7 @@ static int device_suspend_noirq(struct device *dev)if (is_async (dev)) {get_device (dev); -async_schedule (async_suspend_noirq, dev); +async_schedule_dev (async_suspend_noirq, dev);return 0 ; }return __device_suspend_noirq (dev, pm_transition, false);
@@ -1571,7 +1571,7 @@ static int device_suspend_late(struct device *dev)if (is_async (dev)) {get_device (dev); -async_schedule (async_suspend_late, dev); +async_schedule_dev (async_suspend_late, dev);return 0 ; }
@@ -1835,7 +1835,7 @@ static int device_suspend(struct device *dev)if (is_async (dev)) {get_device (dev); -async_schedule (async_suspend, dev); +async_schedule_dev (async_suspend, dev);return 0 ; }
PATCH v10 8/9 libnvdimm: Schedule device registration on node local to the device
In reply to Alexander DuyckForce the device registration for nvdimm devices to be closer to the actual device. This is achieved by using either the NUMA node ID of the region, or of the parent. By doing this we can have everything above the region based on the region, and everything below the region based on the nvdimm bus.
By guaranteeing NUMA locality I see an improvement of as high as 25% for per-node init of a system with 12TB of persistent memory.
--- drivers/nvdimm/bus.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)
drivers/nvdimm/bus.c +8 -3
@@ -23,6 +23,7 @@#include <linux/ndctl.h> #include <linux/sched.h> #include <linux/slab.h> +#include <linux/cpu.h> #include <linux/fs.h> #include <linux/io.h> #include <linux/mm.h>
@@ -534,11 +535,15 @@ void __nd_device_register(struct device *dev)set_dev_node (dev,to_nd_region (dev)->numa_node); dev->bus = &nvdimm_bus_type; -if (dev->parent) +if (dev->parent) {get_device (dev->parent); +if (dev_to_node (dev) ==NUMA_NO_NODE ) +set_dev_node (dev,dev_to_node (dev->parent)); + }get_device (dev); -async_schedule_domain (nd_async_device_register, dev, - &nd_async_domain); + +async_schedule_dev_domain (nd_async_device_register, dev, + &nd_async_domain); }void nd_device_register (struct device *dev)
PATCH v10 9/9 driver core: Rewrite test_async_driver_probe to cover serialization and NUMA affinity
In reply to Alexander DuyckThe current async_probe test code is only testing one device allocated prior to driver load and only loading one device afterwards. Instead of doing things this way it makes much more sense to load one device per CPU in order to actually stress the async infrastructure. By doing this we should see delays significantly increase in the event of devices being serialized.
In addition I have updated the test to verify that we are trying to place the work on the correct NUMA node when we are running in async mode. By doing this we can verify the best possible outcome for device and driver load times.
I have added a timeout value that is used to disable the sleep and instead cause the probe routine to report an error indicating it timed out. By doing this we limit the maximum runtime for the test to 20 seconds or less.
The last major change in this set is that I have gone through and tuned it for handling the massive number of possible events that will be scheduled. Instead of reporting the sleep for each individual device it is moved to only being displayed if we enable debugging.
With this patch applied below are what a failing test and a passing test should look like. I elided a few hundred lines in the failing test that were duplicated since the system I was testing on had a massive number of CPU cores:
-- Failing --
[ 243.524697] test_async_driver_probe: registering first set of asynchronous devices... [ 243.535625] test_async_driver_probe: registering asynchronous driver... [ 243.543038] test_async_driver_probe: registration took 0 msecs [ 243.549559] test_async_driver_probe: registering second set of asynchronous devices... [ 243.568350] platform test_async_driver.447: registration took 9 msecs [ 243.575544] test_async_driver_probe: registering first synchronous device... [ 243.583454] test_async_driver_probe: registering synchronous driver... [ 248.825920] test_async_driver_probe: registration took 5235 msecs [ 248.825922] test_async_driver_probe: registering second synchronous device... [ 248.825928] test_async_driver test_async_driver.443: NUMA node mismatch 3 != 1 [ 248.825932] test_async_driver test_async_driver.445: NUMA node mismatch 3 != 1 [ 248.825935] test_async_driver test_async_driver.446: NUMA node mismatch 3 != 1 [ 248.825939] test_async_driver test_async_driver.440: NUMA node mismatch 3 != 1 [ 248.825943] test_async_driver test_async_driver.441: NUMA node mismatch 3 != 1 ... [ 248.827150] test_async_driver test_async_driver.229: NUMA node mismatch 0 != 1 [ 248.827158] test_async_driver test_async_driver.228: NUMA node mismatch 0 != 1 [ 248.827220] test_async_driver test_async_driver.281: NUMA node mismatch 2 != 1 [ 248.827229] test_async_driver test_async_driver.282: NUMA node mismatch 2 != 1 [ 248.827240] test_async_driver test_async_driver.280: NUMA node mismatch 2 != 1 [ 253.945834] test_async_driver test_async_driver.1: NUMA node mismatch 0 != 1 [ 253.945878] test_sync_driver test_sync_driver.1: registration took 5119 msecs [ 253.961693] test_async_driver_probe: async events still pending, forcing timeout and synchronize [ 259.065839] test_async_driver test_async_driver.2: NUMA node mismatch 0 != 1 [ 259.073786] test_async_driver test_async_driver.3: async probe took too long [ 259.081669] test_async_driver test_async_driver.3: NUMA node mismatch 0 != 1 [ 259.089569] test_async_driver test_async_driver.4: async probe took too long [ 259.097451] test_async_driver test_async_driver.4: NUMA node mismatch 0 != 1 [ 259.105338] test_async_driver test_async_driver.5: async probe took too long [ 259.113204] test_async_driver test_async_driver.5: NUMA node mismatch 0 != 1 [ 259.121089] test_async_driver test_async_driver.6: async probe took too long [ 259.128961] test_async_driver test_async_driver.6: NUMA node mismatch 0 != 1 [ 259.136850] test_async_driver test_async_driver.7: async probe took too long ... [ 262.124062] test_async_driver test_async_driver.221: async probe took too long [ 262.132130] test_async_driver test_async_driver.221: NUMA node mismatch 3 != 1 [ 262.140206] test_async_driver test_async_driver.222: async probe took too long [ 262.148277] test_async_driver test_async_driver.222: NUMA node mismatch 3 != 1 [ 262.156351] test_async_driver test_async_driver.223: async probe took too long [ 262.164419] test_async_driver test_async_driver.223: NUMA node mismatch 3 != 1 [ 262.172630] test_async_driver_probe: Test failed with 222 errors and 336 warnings
-- Passing --
[ 105.419247] test_async_driver_probe: registering first set of asynchronous devices... [ 105.432040] test_async_driver_probe: registering asynchronous driver... [ 105.439718] test_async_driver_probe: registration took 0 msecs [ 105.446239] test_async_driver_probe: registering second set of asynchronous devices... [ 105.477986] platform test_async_driver.447: registration took 22 msecs [ 105.485276] test_async_driver_probe: registering first synchronous device... [ 105.493169] test_async_driver_probe: registering synchronous driver... [ 110.597981] test_async_driver_probe: registration took 5097 msecs [ 110.604806] test_async_driver_probe: registering second synchronous device... [ 115.707490] test_sync_driver test_sync_driver.1: registration took 5094 msecs [ 115.715478] test_async_driver_probe: completed successfully
--- drivers/base/test/test_async_driver_probe.c | 261 +++++++++++++++++++++------ 1 file changed, 201 insertions(+), 60 deletions(-)
drivers/base/test/test_async_driver_probe.c +201 -60
@@ -11,16 +11,47 @@#include <linux/module.h> #include <linux/platform_device.h> #include <linux/time.h> +#include <linux/numa.h> +#include <linux/nodemask.h> +#include <linux/topology.h> #define TEST_PROBE_DELAY (5 * 1000)/* 5 sec */ #define TEST_PROBE_THRESHOLD (TEST_PROBE_DELAY / 2) +static atomic_t warnings, errors, timeout, async_completed; +static int test_probe (struct platform_device *pdev) { -dev_info (&pdev->dev,"sleeping for %d msecs in probe\n" , -TEST_PROBE_DELAY ); -msleep (TEST_PROBE_DELAY ); -dev_info (&pdev->dev,"done sleeping\n" ); +struct device *dev = &pdev->dev; + +/* +* Determine if we have hit the "timeout" limit for the test if we +* have then report it as an error, otherwise we wil sleep for the +* required amount of time and then report completion. +*/ +if (atomic_read (&timeout)) { +dev_err (dev,"async probe took too long\n" ); +atomic_inc (&errors); + }else { +dev_dbg (&pdev->dev,"sleeping for %d msecs in probe\n" , +TEST_PROBE_DELAY ); +msleep (TEST_PROBE_DELAY ); +dev_dbg (&pdev->dev,"done sleeping\n" ); + } + +/* +* Report NUMA mismatch if device node is set and we are not +* performing an async init on that node. +*/ +if (dev->driver->probe_type ==PROBE_PREFER_ASYNCHRONOUS ) { +if (dev_to_node (dev) !=numa_node_id ()) { +dev_warn (dev,"NUMA node mismatch %d != %d\n" , +dev_to_node (dev),numa_node_id ()); +atomic_inc (&warnings); + } + +atomic_inc (&async_completed); + }return 0 ; }
@@ -41,31 +72,64 @@ static struct platform_driver sync_driver = { .probe = test_probe, }; -static struct platform_device *async_dev_1, *async_dev_2; -static struct platform_device *sync_dev_1; +static struct platform_device *async_dev[NR_CPUS *2 ]; +static struct platform_device *sync_dev[2 ]; + +static struct platform_device * +test_platform_device_register_node (char *name,int id,int nid) +{ +struct platform_device *pdev; +int ret; + + pdev =platform_device_alloc (name, id); +if (!pdev) +return NULL ; + +if (nid !=NUMA_NO_NODE ) +set_dev_node (&pdev->dev, nid); + + ret =platform_device_add (pdev); +if (ret) { +platform_device_put (pdev); +return ERR_PTR (ret); + } + +return pdev; + +}static int __init test_async_probe_init (void ) { -ktime_t calltime, delta; +struct platform_device **pdev =NULL ; +int async_id =0 , sync_id =0 ;unsigned long long duration; -int error; +ktime_t calltime, delta; +int err, nid, cpu; + +pr_info ("registering first set of asynchronous devices...\n" ); -pr_info ("registering first asynchronous device...\n" ); +for_each_online_cpu (cpu) { + nid =cpu_to_node (cpu); + pdev = &async_dev[async_id]; + *pdev =test_platform_device_register_node ("test_async_driver" , + async_id, + nid); +if (IS_ERR (*pdev)) { + err =PTR_ERR (*pdev); + *pdev =NULL ; +pr_err ("failed to create async_dev: %d\n" , err); + goto err_unregister_async_devs; + } - async_dev_1 =platform_device_register_simple ("test_async_driver" ,1 , -NULL ,0 ); -if (IS_ERR (async_dev_1)) { - error =PTR_ERR (async_dev_1); -pr_err ("failed to create async_dev_1: %d\n" , error); -return error; + async_id++; }pr_info ("registering asynchronous driver...\n" ); calltime =ktime_get (); - error =platform_driver_register (&async_driver); -if (error) { -pr_err ("Failed to register async_driver: %d\n" , error); - goto err_unregister_async_dev_1; + err =platform_driver_register (&async_driver); +if (err) { +pr_err ("Failed to register async_driver: %d\n" , err); + goto err_unregister_async_devs; } delta =ktime_sub (ktime_get (), calltime);
@@ -73,86 +137,163 @@ static int __init test_async_probe_init(void)pr_info ("registration took %lld msecs\n" , duration);if (duration >TEST_PROBE_THRESHOLD ) {pr_err ("test failed: probe took too long\n" ); - error = -ETIMEDOUT ; + err = -ETIMEDOUT ; goto err_unregister_async_driver; } -pr_info ("registering second asynchronous device...\n" ); +pr_info ("registering second set of asynchronous devices...\n" ); calltime =ktime_get (); - async_dev_2 =platform_device_register_simple ("test_async_driver" ,2 , -NULL ,0 ); -if (IS_ERR (async_dev_2)) { - error =PTR_ERR (async_dev_2); -pr_err ("failed to create async_dev_2: %d\n" , error); - goto err_unregister_async_driver; +for_each_online_cpu (cpu) { + nid =cpu_to_node (cpu); + pdev = &sync_dev[sync_id]; + + *pdev =test_platform_device_register_node ("test_async_driver" , + async_id, + nid); +if (IS_ERR (*pdev)) { + err =PTR_ERR (*pdev); + *pdev =NULL ; +pr_err ("failed to create async_dev: %d\n" , err); + goto err_unregister_async_driver; + } + + async_id++; } delta =ktime_sub (ktime_get (), calltime); duration = (unsigned long long )ktime_to_ms (delta); -pr_info ("registration took %lld msecs\n" , duration); +dev_info (&(*pdev)->dev, +"registration took %lld msecs\n" , duration);if (duration >TEST_PROBE_THRESHOLD ) { -pr_err ("test failed: probe took too long\n" ); - error = -ETIMEDOUT ; - goto err_unregister_async_dev_2; +dev_err (&(*pdev)->dev, +"test failed: probe took too long\n" ); + err = -ETIMEDOUT ; + goto err_unregister_async_driver; } -pr_info ("registering synchronous driver...\n" ); - error =platform_driver_register (&sync_driver); -if (error) { -pr_err ("Failed to register async_driver: %d\n" , error); - goto err_unregister_async_dev_2; +pr_info ("registering first synchronous device...\n" ); + nid =cpu_to_node (cpu); + pdev = &sync_dev[sync_id]; + + *pdev =test_platform_device_register_node ("test_sync_driver" , + sync_id, +NUMA_NO_NODE ); +if (IS_ERR (*pdev)) { + err =PTR_ERR (*pdev); + *pdev =NULL ; +pr_err ("failed to create sync_dev: %d\n" , err); + goto err_unregister_async_driver; } -pr_info ("registering synchronous device...\n" ); + sync_id++; + +pr_info ("registering synchronous driver...\n" ); calltime =ktime_get (); - sync_dev_1 =platform_device_register_simple ("test_sync_driver" ,1 , -NULL ,0 ); -if (IS_ERR (sync_dev_1)) { - error =PTR_ERR (sync_dev_1); -pr_err ("failed to create sync_dev_1: %d\n" , error); - goto err_unregister_sync_driver; + err =platform_driver_register (&sync_driver); +if (err) { +pr_err ("Failed to register async_driver: %d\n" , err); + goto err_unregister_sync_devs; } delta =ktime_sub (ktime_get (), calltime); duration = (unsigned long long )ktime_to_ms (delta);pr_info ("registration took %lld msecs\n" , duration);if (duration <TEST_PROBE_THRESHOLD ) { -pr_err ("test failed: probe was too quick\n" ); - error = -ETIMEDOUT ; - goto err_unregister_sync_dev_1; +dev_err (&(*pdev)->dev, +"test failed: probe was too quick\n" ); + err = -ETIMEDOUT ; + goto err_unregister_sync_driver; } -pr_info ("completed successfully" ); +pr_info ("registering second synchronous device...\n" ); + pdev = &sync_dev[sync_id]; + calltime =ktime_get (); -return 0 ; + *pdev =test_platform_device_register_node ("test_sync_driver" , + sync_id, +NUMA_NO_NODE ); +if (IS_ERR (*pdev)) { + err =PTR_ERR (*pdev); + *pdev =NULL ; +pr_err ("failed to create sync_dev: %d\n" , err); + goto err_unregister_sync_driver; + } -err_unregister_sync_dev_1: -platform_device_unregister (sync_dev_1); + sync_id++; -err_unregister_sync_driver: -platform_driver_unregister (&sync_driver); + delta =ktime_sub (ktime_get (), calltime); + duration = (unsigned long long )ktime_to_ms (delta); +dev_info (&(*pdev)->dev, +"registration took %lld msecs\n" , duration); +if (duration <TEST_PROBE_THRESHOLD ) { +dev_err (&(*pdev)->dev, +"test failed: probe was too quick\n" ); + err = -ETIMEDOUT ; + goto err_unregister_sync_driver; + } -err_unregister_async_dev_2: -platform_device_unregister (async_dev_2); +/* +* The async events should have completed while we were taking care +* of the synchronous events. We will now terminate any outstanding +* asynchronous probe calls remaining by forcing timeout and remove +* the driver before we return which should force the flush of the +* pending asynchronous probe calls. +* +* Otherwise if they completed without errors or warnings then +* report successful completion. +*/ +if (atomic_read (&async_completed) != async_id) { +pr_err ("async events still pending, forcing timeout\n" ); +atomic_inc (&timeout); + err = -ETIMEDOUT ; + }else if (!atomic_read (&errors) && !atomic_read (&warnings)) { +pr_info ("completed successfully\n" ); +return 0 ; + } +err_unregister_sync_driver: +platform_driver_unregister (&sync_driver); +err_unregister_sync_devs: +while (sync_id--) +platform_device_unregister (sync_dev[sync_id]); err_unregister_async_driver:platform_driver_unregister (&async_driver); +err_unregister_async_devs: +while (async_id--) +platform_device_unregister (async_dev[async_id]); + +/* +* If err is already set then count that as an additional error for +* the test. Otherwise we will report an invalid argument error and +* not count that as we should have reached here as a result of +* errors or warnings being reported by the probe routine. +*/ +if (err) +atomic_inc (&errors); +else + err = -EINVAL ; -err_unregister_async_dev_1: -platform_device_unregister (async_dev_1); +pr_err ("Test failed with %d errors and %d warnings\n" , +atomic_read (&errors),atomic_read (&warnings)); -return error; +return err; }module_init (test_async_probe_init); static void __exit test_async_probe_exit(void) { +int id =2 ; +platform_driver_unregister (&async_driver);platform_driver_unregister (&sync_driver); -platform_device_unregister (async_dev_1); -platform_device_unregister (async_dev_2); -platform_device_unregister (sync_dev_1); + +while (id--) +platform_device_unregister (sync_dev[id]); + + id =NR_CPUS *2 ; +while (id--) +platform_device_unregister (async_dev[id]); }module_exit (test_async_probe_exit);
Greg KH
maintainerQuoted 72 lines · Alexander Duyck
This patch set provides functionality that will help to improve the locality of the
async_schedulecalls used to provide deferred initialization.This patch set originally started out focused on just the one call to
async_schedule_domainin the nvdimm tree that was being used to defer thedevice_addcall however after doing some digging I realized the scope of this was much broader than I had originally planned. As such I went through and reworked the underlying infrastructure down to replacing thequeue_workcall itself with a function of my own and opted to try and provide a NUMA aware solution that would work for a broader audience.In addition I have added several tweaks and/or clean-ups to the front of the patch set. Patches 1 through 3 address a number of issues that actually were causing the existing
async_schedulecalls to not show the performance that they could due to either not scaling on a per device basis, or due to issues that could result in a potential race. For example, patch 3 addresses the fact that we were callingasync_scheduleonce per driver instead of once per device, and as a result we would have still ended up with devices being probed on a non-local node without addressing this first.I have also updated the kernel module used to test async driver probing so that it can expose the original issue I was attempting to address. It will fail on a system of asynchronous work either takes longer than it takes to load a single device and a single driver with a device already added. It will also fail if the NUMA node that the driver is loaded on does not match the NUMA node the device is associated with.
RFC->v1:
Dropped nvdimm patch to submit later.
It relies on code in libnvdimm development tree.
Simplifiedqueue_work_nearto just convert node into a CPU. Split up drivers core and PM core patches.v1->v2:
Renamedqueue_work_neartoqueue_work_node
AddedWARN_ON_ONCEif we usequeue_work_nodewith per-cpu workqueuev2->v3:
Added Acked-by forqueue_work_nodepatch
Continued rename from_nearto_nodeto be consistent withqueue_work_node
Renamedasync_schedule_near_domaintoasync_schedule_node_domainRenamedasync_schedule_neartoasync_schedule_node
Added kerneldoc for newasync_schedule_XXXfunctions
Updated patch description for patch 4 to include data on potential gainsv3->v4
Added patch to consolidate use ofneed_parent_lock
Make asynchronous driver probing explicit about use of drvdatav4->v5
Added patch to moveasync_synchronize_fullto address deadlock Added bitasync_probeto act as mutex for probe/remove calls Added back nvdimm patch as code it relies on is now in Linus's tree Incorporated review comments on parent & device locking consolidation Rebased on latest linux-nextv5->v6:
Drop the "This patch" or "This change" from start of patch descriptions. Drop unnecessary parenthesis in first patch
Use same wording for "selecting a CPU" in comments added in first patch Added kernel documentation forasync_probemember of device Fixed up comments forasync_schedulecalls in patch 2
Moved code related setting async driver out ofdevice.hand intodd.cAdded Reviewed-by for several patchesv6->v7:
Fixed typo which had kernel doc refer to "lock" when I meant "unlock" Dropped "bool X:1" to "u8 X:1" from patch description
Addedasync_drivertodevice_privatestructure to store driver Dropped unecessary code shuffle fromasync_probepatch Reordered patches to move fixes up to front
Added Reviewed-by for several patches
Updated cover page and patch descriptions throughout the setv7->v8:
Replacedasync_probevalue with dead, only apply dead indevice_delDropped Reviewed-by from patch 2 due to significant changes Added Reviewed-by for patches reviewed by Luis Chamberlain
Quoted 8 lines
v8->v9:
Dropped patch 1 as it was applied, shifted remaining patches by 1 Added new patch 9 that adds test framework for NUMA and sequential init Tweaked what is now patch 1, and added Reviewed-by from Dan Williamsv9->v10:
Moved "dead" from device struct todevice_privatestruct Added Reviewed-by from Rafael to patch 1
Rebased on latest linux-next
Thanks for sticking with this, now all queued up.
greg k-h