driver core: add devm_device_add_group() and friends

Many drivers create additional driver-specific device attributes when
binding to the device, and providing managed version of
device_create_group() will simplify unbinding and error handling in probe
path for such drivers.

Without managed version driver writers either have to mix manual and
managed resources, which is prone to errors, or open-code this function by
providing a wrapper to device_add_group() and use it with devm_add_action()
or devm_add_action_or_reset().

Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 130 insertions, 0 deletions

diff --git a/drivers/base/core.c b/drivers/base/core.c
index 14f8cf5c8b05..09723532725d 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -1035,6 +1035,136 @@ void device_remove_groups(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(device_remove_groups);
 
+union device_attr_group_devres {
+        const struct attribute_group *group;
+        const struct attribute_group **groups;
+};
+
+static int devm_attr_group_match(struct device *dev, void *res, void *data)
+{
+        return ((union device_attr_group_devres *)res)->group == data;
+}
+
+static void devm_attr_group_remove(struct device *dev, void *res)
+{
+        union device_attr_group_devres *devres = res;
+        const struct attribute_group *group = devres->group;
+
+        dev_dbg(dev, "%s: removing group %p\n", __func__, group);
+        sysfs_remove_group(&dev->kobj, group);
+}
+
+static void devm_attr_groups_remove(struct device *dev, void *res)
+{
+        union device_attr_group_devres *devres = res;
+        const struct attribute_group **groups = devres->groups;
+
+        dev_dbg(dev, "%s: removing groups %p\n", __func__, groups);
+        sysfs_remove_groups(&dev->kobj, groups);
+}
+
+/**
+ * devm_device_add_group - given a device, create a managed attribute group
+ * @dev:        The device to create the group for
+ * @grp:        The attribute group to create
+ *
+ * This function creates a group for the first time.  It will explicitly
+ * warn and error if any of the attribute files being created already exist.
+ *
+ * Returns 0 on success or error code on failure.
+ */
+int devm_device_add_group(struct device *dev, const struct attribute_group *grp)
+{
+        union device_attr_group_devres *devres;
+        int error;
+
+        devres = devres_alloc(devm_attr_group_remove,
+                              sizeof(*devres), GFP_KERNEL);
+        if (!devres)
+                return -ENOMEM;
+
+        error = sysfs_create_group(&dev->kobj, grp);
+        if (error) {
+                devres_free(devres);
+                return error;
+        }
+
+        devres->group = grp;
+        devres_add(dev, devres);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(devm_device_add_group);
+
+/**
+ * devm_device_remove_group: remove a managed group from a device
+ * @dev:        device to remove the group from
+ * @grp:        group to remove
+ *
+ * This function removes a group of attributes from a device. The attributes
+ * previously have to have been created for this group, otherwise it will fail.
+ */
+void devm_device_remove_group(struct device *dev,
+                              const struct attribute_group *grp)
+{
+        WARN_ON(devres_release(dev, devm_attr_group_remove,
+                               devm_attr_group_match,
+                               /* cast away const */ (void *)grp));
+}
+EXPORT_SYMBOL_GPL(devm_device_remove_group);
+
+/**
+ * devm_device_add_groups - create a bunch of managed attribute groups
+ * @dev:        The device to create the group for
+ * @groups:     The attribute groups to create, NULL terminated
+ *
+ * This function creates a bunch of managed attribute groups.  If an error
+ * occurs when creating a group, all previously created groups will be
+ * removed, unwinding everything back to the original state when this
+ * function was called.  It will explicitly warn and error if any of the
+ * attribute files being created already exist.
+ *
+ * Returns 0 on success or error code from sysfs_create_group on failure.
+ */
+int devm_device_add_groups(struct device *dev,
+                           const struct attribute_group **groups)
+{
+        union device_attr_group_devres *devres;
+        int error;
+
+        devres = devres_alloc(devm_attr_groups_remove,
+                              sizeof(*devres), GFP_KERNEL);
+        if (!devres)
+                return -ENOMEM;
+
+        error = sysfs_create_groups(&dev->kobj, groups);
+        if (error) {
+                devres_free(devres);
+                return error;
+        }
+
+        devres->groups = groups;
+        devres_add(dev, devres);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(devm_device_add_groups);
+
+/**
+ * devm_device_remove_groups - remove a list of managed groups
+ *
+ * @dev:        The device for the groups to be removed from
+ * @groups:     NULL terminated list of groups to be removed
+ *
+ * If groups is not NULL, remove the specified groups from the device.
+ */
+void devm_device_remove_groups(struct device *dev,
+                               const struct attribute_group **groups)
+{
+        WARN_ON(devres_release(dev, devm_attr_groups_remove,
+                               devm_attr_group_match,
+                               /* cast away const */ (void *)groups));
+}
+EXPORT_SYMBOL_GPL(devm_device_remove_groups);
+
 static int device_add_attrs(struct device *dev)
 {
         struct class *class = dev->class;