driver core: Make driver core own stateful device links

Even though stateful device links are managed by the driver core in
principle, their creators are allowed and sometimes even expected
to drop references to them via device_link_del() or
device_link_remove(), but that doesn't really play well with the
"persistent" link concept.

If "persistent" managed device links are created from driver
probe callbacks, device_link_add() called to do that will take a
new reference on the link each time the callback runs and those
references will never be dropped, which kind of isn't nice.

This issues arises because of the link reference counting carried
out by device_link_add() for existing links, but that is only done to
avoid deleting device links that may still be necessary, which
shouldn't be a concern for managed (stateful) links.  These device
links are managed by the driver core and whoever creates one of them
will need it at least as long as until the consumer driver is detached
from its device and deleting it may be left to the driver core just
fine.

For this reason, rework device_link_add() to apply the reference
counting to stateless links only and make device_link_del() and
device_link_remove() drop references to stateless links only too.
After this change, if called to add a stateful device link for
a consumer-supplier pair for which a stateful device link is
present already, device_link_add() will return the existing link
without incrementing its reference counter.  Accordingly,
device_link_del() and device_link_remove() will WARN() and do
nothing when called to drop a reference to a stateful link.  Thus,
effectively, all stateful device links will be owned by the driver
core.

In addition, clean up the handling of the link management flags,
DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER, so that
(a) they are never set at the same time and (b) if device_link_add()
is called for a consumer-supplier pair with an existing stateful link
between them, the flags of that link will be combined with the flags
passed to device_link_add() to ensure that the life time of the link
is sufficient for all of the callers of device_link_add() for the
same consumer-supplier pair.

Update the device_link_add() kerneldoc comment to reflect the
above changes.

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

1 files changed, 54 insertions, 15 deletions

diff --git a/drivers/base/core.c b/drivers/base/core.c
index 8c7327d45406..9d49b461b1d9 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -192,10 +192,21 @@ static void device_link_rpm_prepare(struct device *consumer,
  * of the link.  If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be
  * ignored.
  *
- * If the DL_FLAG_AUTOREMOVE_CONSUMER flag is set, the link will be removed
- * automatically when the consumer device driver unbinds from it.  Analogously,
- * if DL_FLAG_AUTOREMOVE_SUPPLIER is set in @flags, the link will be removed
- * automatically when the supplier device driver unbinds from it.
+ * If DL_FLAG_STATELESS is set in @flags, the link is not going to be managed by
+ * the driver core and, in particular, the caller of this function is expected
+ * to drop the reference to the link acquired by it directly.
+ *
+ * If that flag is not set, however, the caller of this function is handing the
+ * management of the link over to the driver core entirely and its return value
+ * can only be used to check whether or not the link is present.  In that case,
+ * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link
+ * flags can be used to indicate to the driver core when the link can be safely
+ * deleted.  Namely, setting one of them in @flags indicates to the driver core
+ * that the link is not going to be used (by the given caller of this function)
+ * after unbinding the consumer or supplier driver, respectively, from its
+ * device, so the link can be deleted at that point.  If none of them is set,
+ * the link will be maintained until one of the devices pointed to by it (either
+ * the consumer or the supplier) is unregistered.
  *
  * The combination of DL_FLAG_STATELESS and either DL_FLAG_AUTOREMOVE_CONSUMER
  * or DL_FLAG_AUTOREMOVE_SUPPLIER set in @flags at the same time is invalid and
@@ -241,6 +252,14 @@ struct device_link *device_link_add(struct device *consumer,
                 goto out;
         }
 
+        /*
+         * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed
+         * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both
+         * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER.
+         */
+        if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
+                flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;
+
         list_for_each_entry(link, &supplier->links.consumers, s_node) {
                 if (link->consumer != consumer)
                         continue;
@@ -254,12 +273,6 @@ struct device_link *device_link_add(struct device *consumer,
                         goto out;
                 }
 
-                if (flags & DL_FLAG_AUTOREMOVE_CONSUMER)
-                        link->flags |= DL_FLAG_AUTOREMOVE_CONSUMER;
-
-                if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
-                        link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER;
-
                 if (flags & DL_FLAG_PM_RUNTIME) {
                         if (!(link->flags & DL_FLAG_PM_RUNTIME)) {
                                 device_link_rpm_prepare(consumer, supplier);
@@ -269,7 +282,25 @@ struct device_link *device_link_add(struct device *consumer,
                                 refcount_inc(&link->rpm_active);
                 }
 
-                kref_get(&link->kref);
+                if (flags & DL_FLAG_STATELESS) {
+                        kref_get(&link->kref);
+                        goto out;
+                }
+
+                /*
+                 * If the life time of the link following from the new flags is
+                 * longer than indicated by the flags of the existing link,
+                 * update the existing link to stay around longer.
+                 */
+                if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) {
+                        if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) {
+                                link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;
+                                link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER;
+                        }
+                } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) {
+                        link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER |
+                                         DL_FLAG_AUTOREMOVE_SUPPLIER);
+                }
                 goto out;
         }
 
@@ -419,8 +450,16 @@ static void __device_link_del(struct kref *kref)
 }
 #endif /* !CONFIG_SRCU */
 
+static void device_link_put_kref(struct device_link *link)
+{
+        if (link->flags & DL_FLAG_STATELESS)
+                kref_put(&link->kref, __device_link_del);
+        else
+                WARN(1, "Unable to drop a managed device link reference\n");
+}
+
 /**
- * device_link_del - Delete a link between two devices.
+ * device_link_del - Delete a stateless link between two devices.
  * @link: Device link to delete.
  *
  * The caller must ensure proper synchronization of this function with runtime
@@ -432,14 +471,14 @@ void device_link_del(struct device_link *link)
 {
         device_links_write_lock();
         device_pm_lock();
-        kref_put(&link->kref, __device_link_del);
+        device_link_put_kref(link);
         device_pm_unlock();
         device_links_write_unlock();
 }
 EXPORT_SYMBOL_GPL(device_link_del);
 
 /**
- * device_link_remove - remove a link between two devices.
+ * device_link_remove - Delete a stateless link between two devices.
  * @consumer: Consumer end of the link.
  * @supplier: Supplier end of the link.
  *
@@ -458,7 +497,7 @@ void device_link_remove(void *consumer, struct device *supplier)
 
         list_for_each_entry(link, &supplier->links.consumers, s_node) {
                 if (link->consumer == consumer) {
-                        kref_put(&link->kref, __device_link_del);
+                        device_link_put_kref(link);
                         break;
                 }
         }