Migrate driver-core-owned per-device sysfs to the declarative table introduced earlier in this series. Every standalone file, synthetic symlink, and attribute_group source visible at the top of /sys/<dev>/ becomes one row in driver_core_sysfs_entries[]. Row order matches the eager device_add() readdir(3) order (ABI). The walker runs ADD_ALL forward in device_add() and REMOVE_ALL reverse in device_del().
power/ stays eager. dpm_sysfs_add() runs unconditionally from device_add(), for lazy devices too. In-kernel callers (wakeup_sysfs_add(), dev_pm_qos_*()) sysfs_merge_group() into an existing power/ directory at driver bind, before any userspace access, so deferring power/ would break those merges. device_add() sets ->power_added on lazy devices; the power/ table row then no-ops in create_power() (the latch is already set) and remove_power() is its reverse-order teardown pair, calling dpm_sysfs_remove() only when power/ was actually added. Eager devices (->sysfs_lazy == NULL) also get power/ at device_add() time, and create_power() returns early for them. device_del REMOVE_ALL. device_del() and the SysEntryError unwind path drop the imperative dpm_sysfs_remove() call and reverse the table via REMOVE_ALL. As a consequence the power/ subtree is now torn down LAST (it is declared FIRST in the table and the walker runs in reverse on REMOVE_ALL); the device is already dead (dev->p->dead under device_lock) before the walker runs, so no caller can observe a partially-torn-down state. bus_add_device / bus_remove_device. The bus's dev_groups and the dev->kobj/subsystem symlink are now materialised by walker rows (create_bus_groups, create_bus_subsystem_link). bus_add_device() and bus_remove_device() keep only the bus- directory back-link (sp->devices_kset->kobj/<devname>) which targets a kobject other than dev->kobj and therefore cannot be a per-device row. Cc: Greg Kroah-Hartman <[email protected]> Cc: Rafael J. Wysocki <[email protected]> Cc: Tejun Heo <[email protected]> Cc: Danilo Krummrich <[email protected]> Cc: [email protected] Cc: [email protected] Cc: [email protected] Assisted-by: Claude:claude-opus-4.7 Signed-off-by: Pavol Sakac <[email protected]> --- drivers/base/bus.c | 41 ++- drivers/base/core.c | 708 +++++++++++++++++++++++++++++++---------- fs/sysfs/sysfs.h | 1 + include/linux/device.h | 50 +-- 4 files changed, 578 insertions(+), 222 deletions(-) diff --git a/drivers/base/bus.c b/drivers/base/bus.c index 8b6722ff8590d..4ca1bd0cf4904 100644 --- a/drivers/base/bus.c +++ b/drivers/base/bus.c @@ -563,34 +563,35 @@ int bus_add_device(struct device *dev) pr_debug("bus: '%s': add device %s\n", sp->bus->name, dev_name(dev)); - error = device_add_groups(dev, sp->bus->dev_groups); + error = sysfs_create_link(&sp->devices_kset->kobj, &dev->kobj, dev_name(dev)); if (error) goto out_put; if (dev->bus->driver_override) { error = device_add_group(dev, &driver_override_dev_group); if (error) - goto out_groups; + goto out_kset; } - error = sysfs_create_link(&sp->devices_kset->kobj, &dev->kobj, dev_name(dev)); - if (error) - goto out_override; - - error = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem"); - if (error) - goto out_subsys; + /* + * The bus's dev_groups and the dev->kobj/subsystem symlink + * are created by the driver-core walker through the + * bus-groups wildcard row and the bus-bound "subsystem" row + * of driver_core_sysfs_entries[] (see create_bus_groups() + * and create_bus_subsystem_link() in drivers/base/core.c); + * teardown runs through the REMOVE_ALL walker call in + * device_del(). Only the bus-directory back-link + * (sp->devices_kset->kobj -> dev->kobj, named after the + * device) stays here - it targets a kobject other than + * dev->kobj and therefore does not belong on the per-device + * walker. + */ klist_add_tail(&dev->p->knode_bus, &sp->klist_devices); return 0; -out_subsys: +out_kset: sysfs_remove_link(&sp->devices_kset->kobj, dev_name(dev)); -out_override: - if (dev->bus->driver_override) - device_remove_group(dev, &driver_override_dev_group); -out_groups: - device_remove_groups(dev, sp->bus->dev_groups); out_put: subsys_put(sp); return error; @@ -644,11 +645,17 @@ void bus_remove_device(struct device *dev) sif->remove_dev(dev, sif); mutex_unlock(&sp->mutex); - sysfs_remove_link(&dev->kobj, "subsystem"); + /* + * dev->kobj/subsystem and the bus's dev_groups are torn + * down by the driver-core REMOVE_ALL walker call in + * device_del() (reverse order over + * driver_core_sysfs_entries[]); only the bus-directory + * back-link sp->devices_kset->kobj/<devname> is removed + * here because it targets a kobject other than dev->kobj. + */ sysfs_remove_link(&sp->devices_kset->kobj, dev_name(dev)); if (dev->bus->driver_override) device_remove_group(dev, &driver_override_dev_group); - device_remove_groups(dev, dev->bus->dev_groups); if (klist_node_attached(&dev->p->knode_bus)) klist_del(&dev->p->knode_bus); diff --git a/drivers/base/core.c b/drivers/base/core.c index 975b6e0c4dabd..15a2dcf922d4b 100644 --- a/drivers/base/core.c +++ b/drivers/base/core.c @@ -2556,12 +2556,15 @@ static void device_release(struct kobject *kobj) */ devres_release_all(dev); + kfree(dev->dma_range_map); + kfree(dev->physical_location); + kfree(dev->driver_override.name); + + /* Free per-device lazy state; kfree(NULL) handles never-opted-in. */ if (dev->sysfs_lazy) mutex_destroy(&dev->sysfs_lazy->lock); kfree(dev->sysfs_lazy); - - kfree(dev->dma_range_map); - kfree(dev->driver_override.name); + dev->sysfs_lazy = NULL; if (dev->release) dev->release(dev); @@ -2575,40 +2578,6 @@ static void device_release(struct kobject *kobj) kfree(p); } -/* - * device_sysfs_apply() - declarative per-device sysfs dispatch - * - * Single walker over a sentinel-terminated struct device_sysfs_entry - * table. Intended to be invoked on every dispatch path (device_add - * eager, lazy populate_one, lazy populate_all, device_del teardown) - * so adding a new per-device file is one row, not four open-coded - * branches. Shape follows cftype + cgroup_addrm_files - * (kernel/cgroup/cgroup.c) and pci_sysfs_entries[] - * (drivers/pci/pci-sysfs.c). - * - * ADD_ONE: first row whose applies_to passes and whose name matches - * (or a wildcard row whose create() does not return - * -ENOENT) terminates the walk. -ENOENT from a wildcard - * row's create() signals "not my name"; the walker - * continues. Realize callbacks MUST check existence (via - * sysfs_*_exists()) before calling sysfs_create_*() and - * return 0 if the entry already exists. Reaching - * __kernfs_create_*() for a name that another lazy path - * just created is forbidden under lock - * serialization. If sysfs_warn_dup() ever fires from a - * lazy path, it indicates a lock invariant - * violation or a non-lazy path creating lazy attrs (bug). - * ADD_ALL: every applicable row's create() fires with name = NULL; - * per-row errors are best-effort - the walker discards - * return values and rows log via their own diagnostics. - * REMOVE_ALL: reverse row order; remove() fires for every row whose - * applies_to passes. Teardown never aborts. - * - * The full walker contract (error-absorption matrix, interaction - * with negative-dentry caching, lifecycle caveats) is documented in - * Documentation/driver-api/sysfs-lazy.rst, added later in this - * series. - */ /* * Create one named attr inside @grp; honours grp->is_visible. * Returns 0 on success/hidden/already-present, -ENOENT on no-match. @@ -2990,12 +2959,32 @@ static int device_ktype_populate_one(struct kobject *kobj, const char *name) const struct kobj_type *ktype = dev->kobj.ktype; int ret; - /* Device is being torn down; do not populate. */ - if (dev->p->dead) + /* KERNFS_LAZY implies dev->sysfs_lazy was allocated by device_set_sysfs_lazy(). */ + if (WARN_ON_ONCE(!dev->sysfs_lazy)) + return -ENOENT; + + /* Fast path: directory fully walked, kernfs has authoritative state. */ + if (device_sysfs_populated(dev)) return -ENOENT; + mutex_lock(&dev->sysfs_lazy->lock); + /* Re-check under the lock against a concurrent populate_all. */ + if (device_sysfs_populated(dev)) { + ret = -ENOENT; + goto out; + } + /* + * FIXME: dev->p->dead is device_lock-protected and a bitfield (so not + * READ_ONCE()-able); this lockless re-check is a benign KCSAN data race. + */ + if (dev->p->dead) { + ret = -ENOENT; + goto out; + } ret = device_sysfs_apply(dev, ktype ? ktype->entries : NULL, DEV_SYSFS_ADD_ONE, name); +out: + mutex_unlock(&dev->sysfs_lazy->lock); return ret; } @@ -3004,14 +2993,33 @@ static void device_ktype_populate_all(struct kobject *kobj) struct device *dev = kobj_to_dev(kobj); const struct kobj_type *ktype = dev->kobj.ktype; - /* Device is being torn down; do not populate. */ - if (dev->p->dead) + /* See device_ktype_populate_one() for the invariant. */ + if (WARN_ON_ONCE(!dev->sysfs_lazy)) + return; + + /* Fast path: directory already fully populated. */ + if (device_sysfs_populated(dev)) return; + mutex_lock(&dev->sysfs_lazy->lock); + /* Re-check under the lock. */ + if (device_sysfs_populated(dev)) + goto out; + /* FIXME: same racy dead read; see device_ktype_populate_one(). */ + if (dev->p->dead) + goto out; + device_sysfs_apply(dev, ktype ? ktype->entries : NULL, DEV_SYSFS_ADD_ALL, NULL); + + + device_sysfs_set_populated(dev); +out: + mutex_unlock(&dev->sysfs_lazy->lock); } +static const struct device_sysfs_entry driver_core_sysfs_entries[]; + static const struct kobj_type device_ktype = { .release = device_release, .sysfs_ops = &dev_sysfs_ops, @@ -3019,6 +3027,7 @@ static const struct kobj_type device_ktype = { .get_ownership = device_get_ownership, .populate = device_ktype_populate_one, .populate_all = device_ktype_populate_all, + .entries = driver_core_sysfs_entries, }; @@ -3271,6 +3280,25 @@ void device_remove_groups(struct device *dev, } EXPORT_SYMBOL_GPL(device_remove_groups); +/* Like device_remove_groups() but skips uncreated named subdirs (lazy). */ +static void device_remove_groups_if_present(struct device *dev, + const struct attribute_group *const *groups) +{ + const struct attribute_group *const *g; + + if (!groups) + return; + + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + + for (g = groups; *g; g++) { + if ((*g)->name && !sysfs_group_exists(&dev->kobj, *g)) + continue; + sysfs_remove_group(&dev->kobj, *g); + } +} + union device_attr_group_devres { const struct attribute_group *group; const struct attribute_group **groups; @@ -3317,101 +3345,447 @@ int devm_device_add_group(struct device *dev, const struct attribute_group *grp) } EXPORT_SYMBOL_GPL(devm_device_add_group); -static int device_add_attrs(struct device *dev) +static ssize_t dev_show(struct device *dev, struct device_attribute *attr, + char *buf) { - const struct class *class = dev->class; - const struct device_type *type = dev->type; - int error; + return print_dev_t(buf, dev->devt); +} +static DEVICE_ATTR_RO(dev); - if (class) { - error = device_add_groups(dev, class->dev_groups); - if (error) - return error; - } +/* Per-device sysfs catalogue (creation order; reversed on teardown). */ +#define N_DRIVER_CORE_SYSFS_ENTRIES 14 - if (type) { - error = device_add_groups(dev, type->groups); - if (error) - goto err_remove_class_groups; - } +/* applies_to() predicates: cheap, non-sleeping, lock-free. */ +static bool dev_supports_offline_enabled(struct device *dev) +{ + return device_supports_offline(dev) && !dev->offline_disabled; +} - error = device_add_groups(dev, dev->groups); - if (error) - goto err_remove_type_groups; +static bool dev_has_fwnode_devlink(struct device *dev) +{ + return fw_devlink_flags && !fw_devlink_is_permissive() && + dev->fwnode; +} - if (device_supports_offline(dev) && !dev->offline_disabled) { - error = device_create_file(dev, &dev_attr_online); - if (error) - goto err_remove_dev_groups; - } +static bool dev_removable_valid(struct device *dev) +{ + return dev_removable_is_valid(dev); +} - if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { - error = device_create_file(dev, &dev_attr_waiting_for_supplier); - if (error) - goto err_remove_dev_online; - } +static bool dev_has_physical_location(struct device *dev) +{ + return !!dev->physical_location; +} - if (dev_removable_is_valid(dev)) { - error = device_create_file(dev, &dev_attr_removable); - if (error) - goto err_remove_dev_waiting_for_supplier; - } +static bool dev_has_devt_major(struct device *dev) +{ + return MAJOR(dev->devt) != 0; +} - if (dev_add_physical_location(dev)) { - error = device_add_group(dev, - &dev_attr_physical_location_group); - if (error) - goto err_remove_dev_removable; - } +static bool dev_has_class(struct device *dev) +{ + return !!dev->class; +} - return 0; +static bool dev_has_bus_no_class(struct device *dev) +{ + return !dev->class && dev->bus; +} - err_remove_dev_removable: - device_remove_file(dev, &dev_attr_removable); - err_remove_dev_waiting_for_supplier: - device_remove_file(dev, &dev_attr_waiting_for_supplier); - err_remove_dev_online: +static bool dev_is_class_child(struct device *dev) +{ + return dev->class && dev->parent && device_is_not_partition(dev); +} + +static bool dev_has_class_dev_groups(struct device *dev) +{ + return dev->class && dev->class->dev_groups; +} + +static bool dev_has_type_groups(struct device *dev) +{ + return dev->type && dev->type->groups; +} + +static bool dev_has_own_groups(struct device *dev) +{ + return !!dev->groups; +} + +static bool dev_has_bus_dev_groups(struct device *dev) +{ + return dev->bus && dev->bus->dev_groups; +} + +static bool dev_needs_pm(struct device *dev) +{ + return !device_pm_not_required(dev); +} + +/* Per-row create()/remove() callbacks. */ +static int create_power(struct device *dev, const char *name) +{ + int ret; + + /* dpm_sysfs_add() already ran from device_add() on the eager path. */ + if (!device_is_sysfs_lazy(dev)) + return 0; + + lockdep_assert_held(&dev->sysfs_lazy->lock); + + if (dev->sysfs_lazy->power_added) + return 0; + + /* + * FIXME: unreachable today - device_add() adds power/ eagerly and latches + * power_added for lazy devices too, so the power_added check above wins. + */ + ret = dpm_sysfs_add(dev); + if (!ret) + dev->sysfs_lazy->power_added = true; + return ret; +} + +static void remove_power(struct device *dev) +{ + /* Skip dpm_sysfs_remove() on lazy devices that never materialised power/. */ + if (device_is_sysfs_lazy(dev) && !dev->sysfs_lazy->power_added) + return; + dpm_sysfs_remove(dev); +} + +static int create_class_subsystem_link(struct device *dev, const char *name) +{ + struct subsys_private *sp; + int ret; + + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + + if (sysfs_kn_exists(&dev->kobj, "subsystem")) + return 0; + + sp = class_to_subsys(dev->class); + if (!sp) + return 0; + + ret = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem"); + subsys_put(sp); + return ret; +} + +static void remove_class_subsystem_link(struct device *dev) +{ + sysfs_remove_link(&dev->kobj, "subsystem"); +} + +static int create_bus_subsystem_link(struct device *dev, const char *name) +{ + struct subsys_private *sp; + int ret; + + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + + if (sysfs_kn_exists(&dev->kobj, "subsystem")) + return 0; + + sp = bus_to_subsys(dev->bus); + if (!sp) + return 0; + + ret = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem"); + subsys_put(sp); + return ret; +} + +static void remove_bus_subsystem_link(struct device *dev) +{ + sysfs_remove_link(&dev->kobj, "subsystem"); +} + +static int create_device_backlink(struct device *dev, const char *name) +{ + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + + if (sysfs_kn_exists(&dev->kobj, "device")) + return 0; + + return sysfs_create_link(&dev->kobj, &dev->parent->kobj, "device"); +} + +static void remove_device_backlink(struct device *dev) +{ + sysfs_remove_link(&dev->kobj, "device"); +} + +static int create_uevent(struct device *dev, const char *name) +{ + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + + if (sysfs_kn_exists(&dev->kobj, dev_attr_uevent.attr.name)) + return 0; + + return sysfs_create_file_ns(&dev->kobj, &dev_attr_uevent.attr, NULL); +} + +static void remove_uevent(struct device *dev) +{ + device_remove_file(dev, &dev_attr_uevent); +} + +static int create_online(struct device *dev, const char *name) +{ + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + + if (sysfs_kn_exists(&dev->kobj, dev_attr_online.attr.name)) + return 0; + + return sysfs_create_file_ns(&dev->kobj, &dev_attr_online.attr, NULL); +} + +static void remove_online(struct device *dev) +{ device_remove_file(dev, &dev_attr_online); - err_remove_dev_groups: - device_remove_groups(dev, dev->groups); - err_remove_type_groups: - if (type) - device_remove_groups(dev, type->groups); - err_remove_class_groups: - if (class) - device_remove_groups(dev, class->dev_groups); +} - return error; +static int create_waiting_for_supplier(struct device *dev, const char *name) +{ + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + + if (sysfs_kn_exists(&dev->kobj, dev_attr_waiting_for_supplier.attr.name)) + return 0; + + return sysfs_create_file_ns(&dev->kobj, + &dev_attr_waiting_for_supplier.attr, + NULL); } -static void device_remove_attrs(struct device *dev) +static void remove_waiting_for_supplier(struct device *dev) { - const struct class *class = dev->class; - const struct device_type *type = dev->type; + device_remove_file(dev, &dev_attr_waiting_for_supplier); +} - if (dev->physical_location) { - device_remove_group(dev, &dev_attr_physical_location_group); - kfree(dev->physical_location); - } +static int create_removable(struct device *dev, const char *name) +{ + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + if (sysfs_kn_exists(&dev->kobj, dev_attr_removable.attr.name)) + return 0; + + return sysfs_create_file_ns(&dev->kobj, &dev_attr_removable.attr, NULL); +} + +static void remove_removable(struct device *dev) +{ device_remove_file(dev, &dev_attr_removable); - device_remove_file(dev, &dev_attr_waiting_for_supplier); - device_remove_file(dev, &dev_attr_online); - device_remove_groups(dev, dev->groups); +} - if (type) - device_remove_groups(dev, type->groups); +static int create_physical_location(struct device *dev, const char *name) +{ + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + + /* NULL on non-ACPI nodes; safe under kobj reference. */ + if (!dev->physical_location) + return -ENOENT; - if (class) - device_remove_groups(dev, class->dev_groups); + if (sysfs_group_exists(&dev->kobj, &dev_attr_physical_location_group)) + return 0; + + return sysfs_create_group(&dev->kobj, &dev_attr_physical_location_group); } -static ssize_t dev_show(struct device *dev, struct device_attribute *attr, - char *buf) +static void remove_physical_location(struct device *dev) { - return print_dev_t(buf, dev->devt); + /* dev->physical_location is freed in device_release(), not here. */ + device_remove_group(dev, &dev_attr_physical_location_group); +} + +static int create_dev_attr(struct device *dev, const char *name) +{ + if (device_is_sysfs_lazy(dev)) + lockdep_assert_held(&dev->sysfs_lazy->lock); + + if (sysfs_kn_exists(&dev->kobj, dev_attr_dev.attr.name)) + return 0; + + return sysfs_create_file_ns(&dev->kobj, &dev_attr_dev.attr, NULL); +} + +static void remove_dev_attr(struct device *dev) +{ + device_remove_file(dev, &dev_attr_dev); +} + +/* Wildcard rows for the four attribute_group sources. */ +static int create_class_groups(struct device *dev, const char *name) +{ + if (!dev->class) + return -ENOENT; + return name ? create_attr_in_groups(dev, dev->class->dev_groups, name) + : create_all_in_groups(dev, dev->class->dev_groups); +} + +static void remove_class_groups(struct device *dev) +{ + if (!dev->class) + return; + if (device_is_sysfs_lazy(dev)) + device_remove_groups_if_present(dev, dev->class->dev_groups); + else + device_remove_groups(dev, dev->class->dev_groups); +} + +static int create_type_groups(struct device *dev, const char *name) +{ + if (!dev->type) + return -ENOENT; + return name ? create_attr_in_groups(dev, dev->type->groups, name) + : create_all_in_groups(dev, dev->type->groups); +} + +static void remove_type_groups(struct device *dev) +{ + if (!dev->type) + return; + if (device_is_sysfs_lazy(dev)) + device_remove_groups_if_present(dev, dev->type->groups); + else + device_remove_groups(dev, dev->type->groups); +} + +static int create_dev_own_groups(struct device *dev, const char *name) +{ + return name ? create_attr_in_groups(dev, dev->groups, name) + : create_all_in_groups(dev, dev->groups); +} + +static void remove_dev_own_groups(struct device *dev) +{ + if (device_is_sysfs_lazy(dev)) + device_remove_groups_if_present(dev, dev->groups); + else + device_remove_groups(dev, dev->groups); +} + +static int create_bus_groups(struct device *dev, const char *name) +{ + if (!dev->bus) + return -ENOENT; + return name ? create_attr_in_groups(dev, dev->bus->dev_groups, name) + : create_all_in_groups(dev, dev->bus->dev_groups); } -static DEVICE_ATTR_RO(dev); + +static void remove_bus_groups(struct device *dev) +{ + if (!dev->bus) + return; + if (device_is_sysfs_lazy(dev)) + device_remove_groups_if_present(dev, dev->bus->dev_groups); + else + device_remove_groups(dev, dev->bus->dev_groups); +} + +static const struct device_sysfs_entry driver_core_sysfs_entries[] = { + /* + * Rows are in eager device_add() creation order: ADD_ALL creates + * forward, REMOVE_ALL tears down in reverse, matching the eager + * path. The lazy tree exposes the same set of names and file + * contents as an eager device; readdir(3) order is kernfs name-hash + * order (kernfs_sd_compare), not table order, and is not ABI. + */ + { + /* Created early on the eager path - keep at table top. */ + .name = "power", + .applies_to = dev_needs_pm, + .create = create_power, + .remove = remove_power, + }, + { + .name = "uevent", + .create = create_uevent, + .remove = remove_uevent, + }, + /* Class-side rows. */ + { + .name = "subsystem", + .applies_to = dev_has_class, + .create = create_class_subsystem_link, + .remove = remove_class_subsystem_link, + }, + { + .name = "device", + .applies_to = dev_is_class_child, + .create = create_device_backlink, + .remove = remove_device_backlink, + }, + { + .applies_to = dev_has_class_dev_groups, + .create = create_class_groups, + .remove = remove_class_groups, + }, + /* Groups + standalones in eager device_attrs_create() order. */ + { + .applies_to = dev_has_type_groups, + .create = create_type_groups, + .remove = remove_type_groups, + }, + { + .applies_to = dev_has_own_groups, + .create = create_dev_own_groups, + .remove = remove_dev_own_groups, + }, + { + .name = "online", + .applies_to = dev_supports_offline_enabled, + .create = create_online, + .remove = remove_online, + }, + { + .name = "waiting_for_supplier", + .applies_to = dev_has_fwnode_devlink, + .create = create_waiting_for_supplier, + .remove = remove_waiting_for_supplier, + }, + { + .name = "removable", + .applies_to = dev_removable_valid, + .create = create_removable, + .remove = remove_removable, + }, + { + .name = "physical_location", + .applies_to = dev_has_physical_location, + .create = create_physical_location, + .remove = remove_physical_location, + }, + /* Bus-side rows. */ + { + .name = "subsystem", + .applies_to = dev_has_bus_no_class, + .create = create_bus_subsystem_link, + .remove = remove_bus_subsystem_link, + }, + { + .applies_to = dev_has_bus_dev_groups, + .create = create_bus_groups, + .remove = remove_bus_groups, + }, + /* Late rows. */ + { + .name = "dev", + .applies_to = dev_has_devt_major, + .create = create_dev_attr, + .remove = remove_dev_attr, + }, + { } /* sentinel */ +}; /* /sys/devices/ */ struct kset *devices_kset; @@ -3861,30 +4235,17 @@ static int device_add_class_symlinks(struct device *dev) if (!sp) return 0; - error = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem"); - if (error) - goto out_devnode; - - if (dev->parent && device_is_not_partition(dev)) { - error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, - "device"); - if (error) - goto out_subsys; - } /* link in the class directory pointing to the device */ error = sysfs_create_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); if (error) - goto out_device; - goto exit; + goto out_devnode; + + subsys_put(sp); + return 0; -out_device: - sysfs_remove_link(&dev->kobj, "device"); -out_subsys: - sysfs_remove_link(&dev->kobj, "subsystem"); out_devnode: sysfs_remove_link(&dev->kobj, "of_node"); -exit: subsys_put(sp); return error; } @@ -3899,9 +4260,6 @@ static void device_remove_class_symlinks(struct device *dev) if (!sp) return; - if (dev->parent && device_is_not_partition(dev)) - sysfs_remove_link(&dev->kobj, "device"); - sysfs_remove_link(&dev->kobj, "subsystem"); sysfs_delete_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); subsys_put(sp); } @@ -4061,38 +4419,44 @@ int device_add(struct device *dev) /* notify platform of device entry */ device_platform_notify(dev); - error = device_create_file(dev, &dev_attr_uevent); - if (error) - goto attrError; - error = device_add_class_symlinks(dev); if (error) goto SymlinkError; - /* - * device_set_sysfs_lazy() only allocates ->sysfs_lazy_state for - * non-namespaced devices, and device_is_sysfs_lazy() guards opt-in - * here, so kernfs_set_lazy() should always succeed. WARN_ON catches - * a regression in those preconditions. - */ - if (device_is_sysfs_lazy(dev)) - WARN_ON(kernfs_set_lazy(dev->kobj.sd)); - - error = device_add_attrs(dev); - if (error) - goto AttrsError; error = bus_add_device(dev); if (error) goto BusError; + /* + * Create power/ eagerly even for lazy devices: in-kernel callers + * (wakeup_sysfs_add(), dev_pm_qos_*()) sysfs_merge_group() into an + * existing power/ dir at driver-bind, before any userspace access. + * Mark it added so the lazy create/remove path treats it as done. + */ error = dpm_sysfs_add(dev); if (error) goto DPMError; + if (device_is_sysfs_lazy(dev)) + dev->sysfs_lazy->power_added = true; device_pm_add(dev); - if (MAJOR(dev->devt)) { - error = device_create_file(dev, &dev_attr_dev); - if (error) - goto DevAttrError; + (void)dev_add_physical_location(dev); + /* + * Subsystems that opt a device into lazy sysfs are responsible for + * ensuring the device's kobj.sd is a non-namespaced directory: the + * device_set_sysfs_lazy() contract states the call must precede + * device_add(), and device_is_sysfs_lazy() gates opt-in here. + * kernfs_set_lazy() should therefore always succeed; WARN_ON catches + * a contract violation by an opted-in subsystem. + */ + if (device_is_sysfs_lazy(dev)) + WARN_ON(kernfs_set_lazy(dev->kobj.sd)); + + /* FIXME: eager ADD_ALL return is dropped; a failed create won't fail device_add(). */ + if (!device_is_sysfs_lazy(dev)) + device_sysfs_apply(dev, driver_core_sysfs_entries, + DEV_SYSFS_ADD_ALL, NULL); + + if (MAJOR(dev->devt)) { error = device_create_sys_dev_entry(dev); if (error) goto SysEntryError; @@ -4169,21 +4533,23 @@ int device_add(struct device *dev) put_device(dev); return error; SysEntryError: - if (MAJOR(dev->devt)) - device_remove_file(dev, &dev_attr_dev); - DevAttrError: + device_lock(dev); + kill_device(dev); + device_unlock(dev); + /* REMOVE_ALL: the remove_power() row is the sole power-group teardown. */ + if (device_is_sysfs_lazy(dev)) + mutex_lock(&dev->sysfs_lazy->lock); + device_sysfs_apply(dev, driver_core_sysfs_entries, + DEV_SYSFS_REMOVE_ALL, NULL); + if (device_is_sysfs_lazy(dev)) + mutex_unlock(&dev->sysfs_lazy->lock); device_pm_remove(dev); - dpm_sysfs_remove(dev); DPMError: device_set_driver(dev, NULL); bus_remove_device(dev); BusError: - device_remove_attrs(dev); - AttrsError: device_remove_class_symlinks(dev); SymlinkError: - device_remove_file(dev, &dev_attr_uevent); - attrError: device_platform_notify_remove(dev); kobject_uevent(&dev->kobj, KOBJ_REMOVE); glue_dir = get_glue_dir(dev); @@ -4296,19 +4662,25 @@ void device_del(struct device *dev) if (dev->fwnode && dev->fwnode->dev == dev) dev->fwnode->dev = NULL; - /* Notify clients of device removal. This call must come - * before dpm_sysfs_remove(). - */ + /* Must come before REMOVE_ALL tears down power/. */ noio_flag = memalloc_noio_save(); bus_notify(dev, BUS_NOTIFY_DEL_DEVICE); - dpm_sysfs_remove(dev); + /* Serialize against lazy populate callbacks. dev->p->dead is + * already set so any populate taking this lock after us bails. + */ + if (device_is_sysfs_lazy(dev)) + mutex_lock(&dev->sysfs_lazy->lock); + device_sysfs_apply(dev, driver_core_sysfs_entries, + DEV_SYSFS_REMOVE_ALL, NULL); + if (device_is_sysfs_lazy(dev)) + mutex_unlock(&dev->sysfs_lazy->lock); + if (parent) klist_del(&dev->p->knode_parent); if (MAJOR(dev->devt)) { devtmpfs_delete_node(dev); device_remove_sys_dev_entry(dev); - device_remove_file(dev, &dev_attr_dev); } sp = class_to_subsys(dev->class); @@ -4325,8 +4697,6 @@ void device_del(struct device *dev) mutex_unlock(&sp->mutex); subsys_put(sp); } - device_remove_file(dev, &dev_attr_uevent); - device_remove_attrs(dev); bus_remove_device(dev); device_pm_remove(dev); driver_deferred_probe_del(dev); @@ -4578,6 +4948,10 @@ EXPORT_SYMBOL_GPL(device_find_child); int __init devices_init(void) { + /* Compile-time row-count check (rows + sentinel). */ + BUILD_BUG_ON(ARRAY_SIZE(driver_core_sysfs_entries) != + N_DRIVER_CORE_SYSFS_ENTRIES + 1); + devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); if (!devices_kset) return -ENOMEM; diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h index 94b8aca20bffc..e2ce9e6c12d84 100644 --- a/fs/sysfs/sysfs.h +++ b/fs/sysfs/sysfs.h @@ -28,6 +28,7 @@ void sysfs_warn_dup(struct kernfs_node *parent, const char *name); * file.c */ + /* * symlink.c */ diff --git a/include/linux/device.h b/include/linux/device.h index e5485bfbc6c84..c0a2ee429280c 100644 --- a/include/linux/device.h +++ b/include/linux/device.h @@ -89,16 +89,10 @@ int subsys_virtual_register(const struct bus_type *subsys, const struct attribute_group **groups); /** - * enum dev_sysfs_action - verb selector for device_sysfs_apply() - * @DEV_SYSFS_ADD_ONE: realize a single named entry (lazy populate_one - * miss path); walker stops at the first row whose - * @applies_to passes and whose create() returns - * anything other than -ENOENT. - * @DEV_SYSFS_ADD_ALL: realize every applicable entry (eager device_add - * or lazy populate_all); best-effort, per-row errors - * do not abort the walk. - * @DEV_SYSFS_REMOVE_ALL: tear down every applicable entry in reverse - * row order (device_del teardown). + * enum dev_sysfs_action - operation requested by device_sysfs_apply() + * @DEV_SYSFS_ADD_ONE: create a single named entry + * @DEV_SYSFS_ADD_ALL: create every applicable entry + * @DEV_SYSFS_REMOVE_ALL: tear down every previously-created entry */ enum dev_sysfs_action { DEV_SYSFS_ADD_ONE, @@ -107,35 +101,15 @@ enum dev_sysfs_action { }; /** - * struct device_sysfs_entry - declarative per-device sysfs content row - * @name: Attribute or symlink name at the top level of the device's - * sysfs directory, or %NULL for a wildcard row whose - * create() performs internal name dispatch (typically a - * group-source row iterating an attribute_group array). - * @applies_to: Optional predicate gating row eligibility for this - * device. Must be cheap, non-sleeping, side-effect-free, and - * monotonic for a given device state. MUST NOT acquire any - * lock the walker's caller may already hold (notably - * device_lock()). %NULL means unconditional. - * @create: Required. Creates the row's sysfs content. For a named - * row (@name != NULL) the @name argument equals @e->name on - * ADD_ONE and %NULL on ADD_ALL. For a wildcard row the @name - * argument is the ADD_ONE target (or %NULL on ADD_ALL) and - * the row's create() matches internally, returning -ENOENT - * to signal "not my name" so the walker continues. Must - * convert -EEXIST from concurrent racers to 0. - * @remove: Optional reverse-of-realize teardown. Called on - * REMOVE_ALL in reverse row order. MUST NOT fail the walk. + * struct device_sysfs_entry - per-device sysfs entry + * @name: entry name; %NULL for a wildcard row + * @applies_to: optional predicate gating row eligibility + * @create: creates the row's sysfs content + * @remove: optional teardown * - * Rows are declared in file-static, sentinel-terminated tables whose - * base pointer is published to the walker via struct kobj_type.entries - * (device ktype shares a single driver_core table and dispatches to - * dev->type->entries as well). The row shape mirrors cftype + - * cgroup_addrm_files (kernel/cgroup/cgroup.c) and the - * pci_sysfs_entries[] at drivers/pci/pci-sysfs.c (added later in - * the series); see Documentation/driver-api/sysfs-lazy.rst (also - * added later in the series) for the full walker contract and - * error-handling matrix. + * Rows are declared in file-static, sentinel-terminated tables and + * walked by device_sysfs_apply(). See + * Documentation/driver-api/sysfs-lazy.rst for the walker contract. */ struct device_sysfs_entry { const char *name; -- 2.47.3 Amazon Web Services Development Center Germany GmbH Tamara-Danz-Str. 13 10243 Berlin Geschaeftsfuehrung: Christof Hellmis, Andreas Stieger Eingetragen am Amtsgericht Charlottenburg unter HRB 257764 B Sitz: Berlin Ust-ID: DE 365 538 597
