driver core: Functional dependencies tracking support

Currently, there is a problem with taking functional dependencies
between devices into account.

What I mean by a "functional dependency" is when the driver of device
B needs device A to be functional and (generally) its driver to be
present in order to work properly.  This has certain consequences
for power management (suspend/resume and runtime PM ordering) and
shutdown ordering of these devices.  In general, it also implies that
the driver of A needs to be working for B to be probed successfully
and it cannot be unbound from the device before the B's driver.

Support for representing those functional dependencies between
devices is added here to allow the driver core to track them and act
on them in certain cases where applicable.

The argument for doing that in the driver core is that there are
quite a few distinct use cases involving device dependencies, they
are relatively hard to get right in a driver (if one wants to
address all of them properly) and it only gets worse if multiplied
by the number of drivers potentially needing to do it.  Morever, at
least one case (asynchronous system suspend/resume) cannot be handled
in a single driver at all, because it requires the driver of A to
wait for B to suspend (during system suspend) and the driver of B to
wait for A to resume (during system resume).

For this reason, represent dependencies between devices as "links",
with the help of struct device_link objects each containing pointers
to the "linked" devices, a list node for each of them, status
information, flags, and an RCU head for synchronization.

Also add two new list heads, representing the lists of links to the
devices that depend on the given one (consumers) and to the devices
depended on by it (suppliers), and a "driver presence status" field
(needed for figuring out initial states of device links) to struct
device.

The entire data structure consisting of all of the lists of link
objects for all devices is protected by a mutex (for link object
addition/removal and for list walks during device driver probing
and removal) and by SRCU (for list walking in other case that will
be introduced by subsequent change sets).  If CONFIG_SRCU is not
selected, however, an rwsem is used for protecting the entire data
structure.

In addition, each link object has an internal status field whose
value reflects whether or not drivers are bound to the devices
pointed to by the link or probing/removal of their drivers is in
progress etc.  That field is only modified under the device links
mutex, but it may be read outside of it in some cases (introduced by
subsequent change sets), so modifications of it are annotated with
WRITE_ONCE().

New links are added by calling device_link_add() which takes three
arguments: pointers to the devices in question and flags.  In
particular, if DL_FLAG_STATELESS is set in the flags, the link status
is not to be taken into account for this link and the driver core
will not manage it.  In turn, if DL_FLAG_AUTOREMOVE is set in the
flags, the driver core will remove the link automatically when the
consumer device driver unbinds from it.

One of the actions carried out by device_link_add() is to reorder
the lists used for device shutdown and system suspend/resume to
put the consumer device along with all of its children and all of
its consumers (and so on, recursively) to the ends of those lists
in order to ensure the right ordering between all of the supplier
and consumer devices.

For this reason, it is not possible to create a link between two
devices if the would-be supplier device already depends on the
would-be consumer device as either a direct descendant of it or a
consumer of one of its direct descendants or one of its consumers
and so on.

There are two types of link objects, persistent and non-persistent.
The persistent ones stay around until one of the target devices is
deleted, while the non-persistent ones are removed automatically when
the consumer driver unbinds from its device (ie. they are assumed to
be valid only as long as the consumer device has a driver bound to
it).  Persistent links are created by default and non-persistent
links are created when the DL_FLAG_AUTOREMOVE flag is passed
to device_link_add().

Both persistent and non-persistent device links can be deleted
with an explicit call to device_link_del().

Links created without the DL_FLAG_STATELESS flag set are managed
by the driver core using a simple state machine.  There are 5 states
each link can be in: DORMANT (unused), AVAILABLE (the supplier driver
is present and functional), CONSUMER_PROBE (the consumer driver is
probing), ACTIVE (both supplier and consumer drivers are present and
functional), and SUPPLIER_UNBIND (the supplier driver is unbinding).
The driver core updates the link state automatically depending on
what happens to the linked devices and for each link state specific
actions are taken in addition to that.

For example, if the supplier driver unbinds from its device, the
driver core will also unbind the drivers of all of its consumers
automatically under the assumption that they cannot function
properly without the supplier.  Analogously, the driver core will
only allow the consumer driver to bind to its device if the
supplier driver is present and functional (ie. the link is in
the AVAILABLE state).  If that's not the case, it will rely on
the existing deferred probing mechanism to wait for the supplier
driver to become available.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 540 insertions, 0 deletions

diff --git a/drivers/base/core.c b/drivers/base/core.c
index ce057a568673..3c5ff17f578f 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -44,6 +44,541 @@ static int __init sysfs_deprecated_setup(char *arg)
 early_param("sysfs.deprecated", sysfs_deprecated_setup);
 #endif
 
+/* Device links support. */
+
+#ifdef CONFIG_SRCU
+static DEFINE_MUTEX(device_links_lock);
+DEFINE_STATIC_SRCU(device_links_srcu);
+
+static inline void device_links_write_lock(void)
+{
+        mutex_lock(&device_links_lock);
+}
+
+static inline void device_links_write_unlock(void)
+{
+        mutex_unlock(&device_links_lock);
+}
+
+int device_links_read_lock(void)
+{
+        return srcu_read_lock(&device_links_srcu);
+}
+
+void device_links_read_unlock(int idx)
+{
+        srcu_read_unlock(&device_links_srcu, idx);
+}
+#else /* !CONFIG_SRCU */
+static DECLARE_RWSEM(device_links_lock);
+
+static inline void device_links_write_lock(void)
+{
+        down_write(&device_links_lock);
+}
+
+static inline void device_links_write_unlock(void)
+{
+        up_write(&device_links_lock);
+}
+
+int device_links_read_lock(void)
+{
+        down_read(&device_links_lock);
+        return 0;
+}
+
+void device_links_read_unlock(int not_used)
+{
+        up_read(&device_links_lock);
+}
+#endif /* !CONFIG_SRCU */
+
+/**
+ * device_is_dependent - Check if one device depends on another one
+ * @dev: Device to check dependencies for.
+ * @target: Device to check against.
+ *
+ * Check if @target depends on @dev or any device dependent on it (its child or
+ * its consumer etc).  Return 1 if that is the case or 0 otherwise.
+ */
+static int device_is_dependent(struct device *dev, void *target)
+{
+        struct device_link *link;
+        int ret;
+
+        if (WARN_ON(dev == target))
+                return 1;
+
+        ret = device_for_each_child(dev, target, device_is_dependent);
+        if (ret)
+                return ret;
+
+        list_for_each_entry(link, &dev->links.consumers, s_node) {
+                if (WARN_ON(link->consumer == target))
+                        return 1;
+
+                ret = device_is_dependent(link->consumer, target);
+                if (ret)
+                        break;
+        }
+        return ret;
+}
+
+static int device_reorder_to_tail(struct device *dev, void *not_used)
+{
+        struct device_link *link;
+
+        /*
+         * Devices that have not been registered yet will be put to the ends
+         * of the lists during the registration, so skip them here.
+         */
+        if (device_is_registered(dev))
+                devices_kset_move_last(dev);
+
+        if (device_pm_initialized(dev))
+                device_pm_move_last(dev);
+
+        device_for_each_child(dev, NULL, device_reorder_to_tail);
+        list_for_each_entry(link, &dev->links.consumers, s_node)
+                device_reorder_to_tail(link->consumer, NULL);
+
+        return 0;
+}
+
+/**
+ * device_link_add - Create a link between two devices.
+ * @consumer: Consumer end of the link.
+ * @supplier: Supplier end of the link.
+ * @flags: Link flags.
+ *
+ * If the DL_FLAG_AUTOREMOVE is set, the link will be removed automatically
+ * when the consumer device driver unbinds from it.  The combination of both
+ * DL_FLAG_AUTOREMOVE and DL_FLAG_STATELESS set is invalid and will cause NULL
+ * to be returned.
+ *
+ * A side effect of the link creation is re-ordering of dpm_list and the
+ * devices_kset list by moving the consumer device and all devices depending
+ * on it to the ends of these lists (that does not happen to devices that have
+ * not been registered when this function is called).
+ *
+ * The supplier device is required to be registered when this function is called
+ * and NULL will be returned if that is not the case.  The consumer device need
+ * not be registerd, however.
+ */
+struct device_link *device_link_add(struct device *consumer,
+                                    struct device *supplier, u32 flags)
+{
+        struct device_link *link;
+
+        if (!consumer || !supplier ||
+            ((flags & DL_FLAG_STATELESS) && (flags & DL_FLAG_AUTOREMOVE)))
+                return NULL;
+
+        device_links_write_lock();
+        device_pm_lock();
+
+        /*
+         * If the supplier has not been fully registered yet or there is a
+         * reverse dependency between the consumer and the supplier already in
+         * the graph, return NULL.
+         */
+        if (!device_pm_initialized(supplier)
+            || device_is_dependent(consumer, supplier)) {
+                link = NULL;
+                goto out;
+        }
+
+        list_for_each_entry(link, &supplier->links.consumers, s_node)
+                if (link->consumer == consumer)
+                        goto out;
+
+        link = kmalloc(sizeof(*link), GFP_KERNEL);
+        if (!link)
+                goto out;
+
+        get_device(supplier);
+        link->supplier = supplier;
+        INIT_LIST_HEAD(&link->s_node);
+        get_device(consumer);
+        link->consumer = consumer;
+        INIT_LIST_HEAD(&link->c_node);
+        link->flags = flags;
+
+        /* Deterine the initial link state. */
+        if (flags & DL_FLAG_STATELESS) {
+                link->status = DL_STATE_NONE;
+        } else {
+                switch (supplier->links.status) {
+                case DL_DEV_DRIVER_BOUND:
+                        switch (consumer->links.status) {
+                        case DL_DEV_PROBING:
+                                link->status = DL_STATE_CONSUMER_PROBE;
+                                break;
+                        case DL_DEV_DRIVER_BOUND:
+                                link->status = DL_STATE_ACTIVE;
+                                break;
+                        default:
+                                link->status = DL_STATE_AVAILABLE;
+                                break;
+                        }
+                        break;
+                case DL_DEV_UNBINDING:
+                        link->status = DL_STATE_SUPPLIER_UNBIND;
+                        break;
+                default:
+                        link->status = DL_STATE_DORMANT;
+                        break;
+                }
+        }
+
+        /*
+         * Move the consumer and all of the devices depending on it to the end
+         * of dpm_list and the devices_kset list.
+         *
+         * It is necessary to hold dpm_list locked throughout all that or else
+         * we may end up suspending with a wrong ordering of it.
+         */
+        device_reorder_to_tail(consumer, NULL);
+
+        list_add_tail_rcu(&link->s_node, &supplier->links.consumers);
+        list_add_tail_rcu(&link->c_node, &consumer->links.suppliers);
+
+        dev_info(consumer, "Linked as a consumer to %s\n", dev_name(supplier));
+
+ out:
+        device_pm_unlock();
+        device_links_write_unlock();
+        return link;
+}
+EXPORT_SYMBOL_GPL(device_link_add);
+
+static void device_link_free(struct device_link *link)
+{
+        put_device(link->consumer);
+        put_device(link->supplier);
+        kfree(link);
+}
+
+#ifdef CONFIG_SRCU
+static void __device_link_free_srcu(struct rcu_head *rhead)
+{
+        device_link_free(container_of(rhead, struct device_link, rcu_head));
+}
+
+static void __device_link_del(struct device_link *link)
+{
+        dev_info(link->consumer, "Dropping the link to %s\n",
+                 dev_name(link->supplier));
+
+        list_del_rcu(&link->s_node);
+        list_del_rcu(&link->c_node);
+        call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu);
+}
+#else /* !CONFIG_SRCU */
+static void __device_link_del(struct device_link *link)
+{
+        dev_info(link->consumer, "Dropping the link to %s\n",
+                 dev_name(link->supplier));
+
+        list_del(&link->s_node);
+        list_del(&link->c_node);
+        device_link_free(link);
+}
+#endif /* !CONFIG_SRCU */
+
+/**
+ * device_link_del - Delete a link between two devices.
+ * @link: Device link to delete.
+ *
+ * The caller must ensure proper synchronization of this function with runtime
+ * PM.
+ */
+void device_link_del(struct device_link *link)
+{
+        device_links_write_lock();
+        device_pm_lock();
+        __device_link_del(link);
+        device_pm_unlock();
+        device_links_write_unlock();
+}
+EXPORT_SYMBOL_GPL(device_link_del);
+
+static void device_links_missing_supplier(struct device *dev)
+{
+        struct device_link *link;
+
+        list_for_each_entry(link, &dev->links.suppliers, c_node)
+                if (link->status == DL_STATE_CONSUMER_PROBE)
+                        WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
+}
+
+/**
+ * device_links_check_suppliers - Check presence of supplier drivers.
+ * @dev: Consumer device.
+ *
+ * Check links from this device to any suppliers.  Walk the list of the device's
+ * links to suppliers and see if all of them are available.  If not, simply
+ * return -EPROBE_DEFER.
+ *
+ * We need to guarantee that the supplier will not go away after the check has
+ * been positive here.  It only can go away in __device_release_driver() and
+ * that function  checks the device's links to consumers.  This means we need to
+ * mark the link as "consumer probe in progress" to make the supplier removal
+ * wait for us to complete (or bad things may happen).
+ *
+ * Links with the DL_FLAG_STATELESS flag set are ignored.
+ */
+int device_links_check_suppliers(struct device *dev)
+{
+        struct device_link *link;
+        int ret = 0;
+
+        device_links_write_lock();
+
+        list_for_each_entry(link, &dev->links.suppliers, c_node) {
+                if (link->flags & DL_FLAG_STATELESS)
+                        continue;
+
+                if (link->status != DL_STATE_AVAILABLE) {
+                        device_links_missing_supplier(dev);
+                        ret = -EPROBE_DEFER;
+                        break;
+                }
+                WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE);
+        }
+        dev->links.status = DL_DEV_PROBING;
+
+        device_links_write_unlock();
+        return ret;
+}
+
+/**
+ * device_links_driver_bound - Update device links after probing its driver.
+ * @dev: Device to update the links for.
+ *
+ * The probe has been successful, so update links from this device to any
+ * consumers by changing their status to "available".
+ *
+ * Also change the status of @dev's links to suppliers to "active".
+ *
+ * Links with the DL_FLAG_STATELESS flag set are ignored.
+ */
+void device_links_driver_bound(struct device *dev)
+{
+        struct device_link *link;
+
+        device_links_write_lock();
+
+        list_for_each_entry(link, &dev->links.consumers, s_node) {
+                if (link->flags & DL_FLAG_STATELESS)
+                        continue;
+
+                WARN_ON(link->status != DL_STATE_DORMANT);
+                WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
+        }
+
+        list_for_each_entry(link, &dev->links.suppliers, c_node) {
+                if (link->flags & DL_FLAG_STATELESS)
+                        continue;
+
+                WARN_ON(link->status != DL_STATE_CONSUMER_PROBE);
+                WRITE_ONCE(link->status, DL_STATE_ACTIVE);
+        }
+
+        dev->links.status = DL_DEV_DRIVER_BOUND;
+
+        device_links_write_unlock();
+}
+
+/**
+ * __device_links_no_driver - Update links of a device without a driver.
+ * @dev: Device without a drvier.
+ *
+ * Delete all non-persistent links from this device to any suppliers.
+ *
+ * Persistent links stay around, but their status is changed to "available",
+ * unless they already are in the "supplier unbind in progress" state in which
+ * case they need not be updated.
+ *
+ * Links with the DL_FLAG_STATELESS flag set are ignored.
+ */
+static void __device_links_no_driver(struct device *dev)
+{
+        struct device_link *link, *ln;
+
+        list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
+                if (link->flags & DL_FLAG_STATELESS)
+                        continue;
+
+                if (link->flags & DL_FLAG_AUTOREMOVE)
+                        __device_link_del(link);
+                else if (link->status != DL_STATE_SUPPLIER_UNBIND)
+                        WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
+        }
+
+        dev->links.status = DL_DEV_NO_DRIVER;
+}
+
+void device_links_no_driver(struct device *dev)
+{
+        device_links_write_lock();
+        __device_links_no_driver(dev);
+        device_links_write_unlock();
+}
+
+/**
+ * device_links_driver_cleanup - Update links after driver removal.
+ * @dev: Device whose driver has just gone away.
+ *
+ * Update links to consumers for @dev by changing their status to "dormant" and
+ * invoke %__device_links_no_driver() to update links to suppliers for it as
+ * appropriate.
+ *
+ * Links with the DL_FLAG_STATELESS flag set are ignored.
+ */
+void device_links_driver_cleanup(struct device *dev)
+{
+        struct device_link *link;
+
+        device_links_write_lock();
+
+        list_for_each_entry(link, &dev->links.consumers, s_node) {
+                if (link->flags & DL_FLAG_STATELESS)
+                        continue;
+
+                WARN_ON(link->flags & DL_FLAG_AUTOREMOVE);
+                WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND);
+                WRITE_ONCE(link->status, DL_STATE_DORMANT);
+        }
+
+        __device_links_no_driver(dev);
+
+        device_links_write_unlock();
+}
+
+/**
+ * device_links_busy - Check if there are any busy links to consumers.
+ * @dev: Device to check.
+ *
+ * Check each consumer of the device and return 'true' if its link's status
+ * is one of "consumer probe" or "active" (meaning that the given consumer is
+ * probing right now or its driver is present).  Otherwise, change the link
+ * state to "supplier unbind" to prevent the consumer from being probed
+ * successfully going forward.
+ *
+ * Return 'false' if there are no probing or active consumers.
+ *
+ * Links with the DL_FLAG_STATELESS flag set are ignored.
+ */
+bool device_links_busy(struct device *dev)
+{
+        struct device_link *link;
+        bool ret = false;
+
+        device_links_write_lock();
+
+        list_for_each_entry(link, &dev->links.consumers, s_node) {
+                if (link->flags & DL_FLAG_STATELESS)
+                        continue;
+
+                if (link->status == DL_STATE_CONSUMER_PROBE
+                    || link->status == DL_STATE_ACTIVE) {
+                        ret = true;
+                        break;
+                }
+                WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
+        }
+
+        dev->links.status = DL_DEV_UNBINDING;
+
+        device_links_write_unlock();
+        return ret;
+}
+
+/**
+ * device_links_unbind_consumers - Force unbind consumers of the given device.
+ * @dev: Device to unbind the consumers of.
+ *
+ * Walk the list of links to consumers for @dev and if any of them is in the
+ * "consumer probe" state, wait for all device probes in progress to complete
+ * and start over.
+ *
+ * If that's not the case, change the status of the link to "supplier unbind"
+ * and check if the link was in the "active" state.  If so, force the consumer
+ * driver to unbind and start over (the consumer will not re-probe as we have
+ * changed the state of the link already).
+ *
+ * Links with the DL_FLAG_STATELESS flag set are ignored.
+ */
+void device_links_unbind_consumers(struct device *dev)
+{
+        struct device_link *link;
+
+ start:
+        device_links_write_lock();
+
+        list_for_each_entry(link, &dev->links.consumers, s_node) {
+                enum device_link_state status;
+
+                if (link->flags & DL_FLAG_STATELESS)
+                        continue;
+
+                status = link->status;
+                if (status == DL_STATE_CONSUMER_PROBE) {
+                        device_links_write_unlock();
+
+                        wait_for_device_probe();
+                        goto start;
+                }
+                WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
+                if (status == DL_STATE_ACTIVE) {
+                        struct device *consumer = link->consumer;
+
+                        get_device(consumer);
+
+                        device_links_write_unlock();
+
+                        device_release_driver_internal(consumer, NULL,
+                                                       consumer->parent);
+                        put_device(consumer);
+                        goto start;
+                }
+        }
+
+        device_links_write_unlock();
+}
+
+/**
+ * device_links_purge - Delete existing links to other devices.
+ * @dev: Target device.
+ */
+static void device_links_purge(struct device *dev)
+{
+        struct device_link *link, *ln;
+
+        /*
+         * Delete all of the remaining links from this device to any other
+         * devices (either consumers or suppliers).
+         */
+        device_links_write_lock();
+
+        list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
+                WARN_ON(link->status == DL_STATE_ACTIVE);
+                __device_link_del(link);
+        }
+
+        list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) {
+                WARN_ON(link->status != DL_STATE_DORMANT &&
+                        link->status != DL_STATE_NONE);
+                __device_link_del(link);
+        }
+
+        device_links_write_unlock();
+}
+
+/* Device links support end. */
+
 int (*platform_notify)(struct device *dev) = NULL;
 int (*platform_notify_remove)(struct device *dev) = NULL;
 static struct kobject *dev_kobj;
@@ -711,6 +1246,9 @@ void device_initialize(struct device *dev)
 #ifdef CONFIG_GENERIC_MSI_IRQ
         INIT_LIST_HEAD(&dev->msi_list);
 #endif
+        INIT_LIST_HEAD(&dev->links.consumers);
+        INIT_LIST_HEAD(&dev->links.suppliers);
+        dev->links.status = DL_DEV_NO_DRIVER;
 }
 EXPORT_SYMBOL_GPL(device_initialize);
 
@@ -1258,6 +1796,8 @@ void device_del(struct device *dev)
         if (dev->bus)
                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                              BUS_NOTIFY_DEL_DEVICE, dev);
+
+        device_links_purge(dev);
         dpm_sysfs_remove(dev);
         if (parent)
                 klist_del(&dev->p->knode_parent);