Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548// SPDX-License-Identifier: GPL-2.0/* * bus.c - bus driver management * * Copyright (c) 2002-3 Patrick Mochel * Copyright (c) 2002-3 Open Source Development Labs * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de> * Copyright (c) 2007 Novell Inc. * Copyright (c) 2023 Greg Kroah-Hartman <gregkh@linuxfoundation.org> */
#include <linux/async.h>#include <linux/device/bus.h>#include <linux/device.h>#include <linux/module.h>#include <linux/errno.h>#include <linux/slab.h>#include <linux/init.h>#include <linux/string.h>#include <linux/mutex.h>#include <linux/sysfs.h>#include <linux/panic.h>#include "base.h"#include "power/power.h"
/* /sys/devices/system */static struct kset *system_kset;
/* /sys/bus */static struct kset *bus_kset;
#define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
/* * sysfs bindings for drivers */
#define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
#define DRIVER_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \ struct driver_attribute driver_attr_##_name = \ __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
static int __must_check bus_rescan_devices_helper(struct device *dev, void *data);
/** * bus_to_subsys - Turn a struct bus_type into a struct subsys_private * * @bus: pointer to the struct bus_type to look up * * The driver core internals needs to work on the subsys_private structure, not * the external struct bus_type pointer. This function walks the list of * registered busses in the system and finds the matching one and returns the * internal struct subsys_private that relates to that bus. * * Note, the reference count of the return value is INCREMENTED if it is not * NULL. A call to subsys_put() must be done when finished with the pointer in * order for it to be properly freed. */struct subsys_private *bus_to_subsys(const struct bus_type *bus){ struct subsys_private *sp = NULL; struct kobject *kobj;
if (!bus || !bus_kset) return NULL;
spin_lock(&bus_kset->list_lock);
if (list_empty(&bus_kset->list)) goto done;
list_for_each_entry(kobj, &bus_kset->list, entry) { struct kset *kset = container_of(kobj, struct kset, kobj);
sp = container_of_const(kset, struct subsys_private, subsys); if (sp->bus == bus) goto done; } sp = NULL;done: sp = subsys_get(sp); spin_unlock(&bus_kset->list_lock); return sp;}
static const struct bus_type *bus_get(const struct bus_type *bus){ struct subsys_private *sp = bus_to_subsys(bus);
if (sp) return bus; return NULL;}
static void bus_put(const struct bus_type *bus){ struct subsys_private *sp = bus_to_subsys(bus);
/* two puts are required as the call to bus_to_subsys incremented it again */ subsys_put(sp); subsys_put(sp);}
static ssize_t drv_attr_show(struct kobject *kobj, struct attribute *attr, char *buf){ struct driver_attribute *drv_attr = to_drv_attr(attr); struct driver_private *drv_priv = to_driver(kobj); ssize_t ret = -EIO;
if (drv_attr->show) ret = drv_attr->show(drv_priv->driver, buf); return ret;}
static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count){ struct driver_attribute *drv_attr = to_drv_attr(attr); struct driver_private *drv_priv = to_driver(kobj); ssize_t ret = -EIO;
if (drv_attr->store) ret = drv_attr->store(drv_priv->driver, buf, count); return ret;}
static const struct sysfs_ops driver_sysfs_ops = { .show = drv_attr_show, .store = drv_attr_store,};
static void driver_release(struct kobject *kobj){ struct driver_private *drv_priv = to_driver(kobj);
pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__); kfree(drv_priv);}
static const struct kobj_type driver_ktype = { .sysfs_ops = &driver_sysfs_ops, .release = driver_release,};
/* * sysfs bindings for buses */static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr, char *buf){ struct bus_attribute *bus_attr = to_bus_attr(attr); struct subsys_private *subsys_priv = to_subsys_private(kobj); /* return -EIO for reading a bus attribute without show() */ ssize_t ret = -EIO;
if (bus_attr->show) ret = bus_attr->show(subsys_priv->bus, buf); return ret;}
static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count){ struct bus_attribute *bus_attr = to_bus_attr(attr); struct subsys_private *subsys_priv = to_subsys_private(kobj); /* return -EIO for writing a bus attribute without store() */ ssize_t ret = -EIO;
if (bus_attr->store) ret = bus_attr->store(subsys_priv->bus, buf, count); return ret;}
static const struct sysfs_ops bus_sysfs_ops = { .show = bus_attr_show, .store = bus_attr_store,};
int bus_create_file(const struct bus_type *bus, struct bus_attribute *attr){ struct subsys_private *sp = bus_to_subsys(bus); int error;
if (!sp) return -EINVAL;
error = sysfs_create_file(&sp->subsys.kobj, &attr->attr);
subsys_put(sp); return error;}EXPORT_SYMBOL_GPL(bus_create_file);
void bus_remove_file(const struct bus_type *bus, struct bus_attribute *attr){ struct subsys_private *sp = bus_to_subsys(bus);
if (!sp) return;
sysfs_remove_file(&sp->subsys.kobj, &attr->attr); subsys_put(sp);}EXPORT_SYMBOL_GPL(bus_remove_file);
static void bus_release(struct kobject *kobj){ struct subsys_private *priv = to_subsys_private(kobj);
lockdep_unregister_key(&priv->lock_key); kfree(priv);}
static const struct kobj_type bus_ktype = { .sysfs_ops = &bus_sysfs_ops, .release = bus_release,};
static int bus_uevent_filter(const struct kobject *kobj){ const struct kobj_type *ktype = get_ktype(kobj);
if (ktype == &bus_ktype) return 1; return 0;}
static const struct kset_uevent_ops bus_uevent_ops = { .filter = bus_uevent_filter,};
/* Manually detach a device from its associated driver. */static ssize_t unbind_store(struct device_driver *drv, const char *buf, size_t count){ const struct bus_type *bus = bus_get(drv->bus); struct device *dev; int err = -ENODEV;
dev = bus_find_device_by_name(bus, NULL, buf); if (dev && dev->driver == drv) { add_taint_module(drv->owner, TAINT_FORCED_BIND, LOCKDEP_STILL_OK); device_driver_detach(dev); err = count; } put_device(dev); bus_put(bus); return err;}static DRIVER_ATTR_IGNORE_LOCKDEP(unbind, 0200, NULL, unbind_store);
/* * Manually attach a device to a driver. * Note: the driver must want to bind to the device, * it is not possible to override the driver's id table. */static ssize_t bind_store(struct device_driver *drv, const char *buf, size_t count){ const struct bus_type *bus = bus_get(drv->bus); struct device *dev; int err = -ENODEV;
dev = bus_find_device_by_name(bus, NULL, buf); if (dev && driver_match_device(drv, dev)) { add_taint_module(drv->owner, TAINT_FORCED_BIND, LOCKDEP_STILL_OK); err = device_driver_attach(drv, dev); if (!err) { /* success */ err = count; } } put_device(dev); bus_put(bus); return err;}static DRIVER_ATTR_IGNORE_LOCKDEP(bind, 0200, NULL, bind_store);
static ssize_t drivers_autoprobe_show(const struct bus_type *bus, char *buf){ struct subsys_private *sp = bus_to_subsys(bus); int ret;
if (!sp) return -EINVAL;
ret = sysfs_emit(buf, "%d\n", sp->drivers_autoprobe); subsys_put(sp); return ret;}
static ssize_t drivers_autoprobe_store(const struct bus_type *bus, const char *buf, size_t count){ struct subsys_private *sp = bus_to_subsys(bus);
if (!sp) return -EINVAL;
if (buf[0] == '0') sp->drivers_autoprobe = 0; else sp->drivers_autoprobe = 1;
subsys_put(sp); return count;}
static ssize_t drivers_probe_store(const struct bus_type *bus, const char *buf, size_t count){ struct device *dev; int err = -EINVAL;
dev = bus_find_device_by_name(bus, NULL, buf); if (!dev) return -ENODEV; if (bus_rescan_devices_helper(dev, NULL) == 0) err = count; put_device(dev); return err;}
static struct device *next_device(struct klist_iter *i){ struct klist_node *n = klist_next(i); struct device *dev = NULL; struct device_private *dev_prv;
if (n) { dev_prv = to_device_private_bus(n); dev = dev_prv->device; } return dev;}
static struct device *prev_device(struct klist_iter *i){ struct klist_node *n = klist_prev(i); struct device *dev = NULL; struct device_private *dev_prv;
if (n) { dev_prv = to_device_private_bus(n); dev = dev_prv->device; } return dev;}
/** * bus_for_each_dev - device iterator. * @bus: bus type. * @start: device to start iterating from. * @data: data for the callback. * @fn: function to be called for each device. * * Iterate over @bus's list of devices, and call @fn for each, * passing it @data. If @start is not NULL, we use that device to * begin iterating from. * * We check the return of @fn each time. If it returns anything * other than 0, we break out and return that value. * * NOTE: The device that returns a non-zero value is not retained * in any way, nor is its refcount incremented. If the caller needs * to retain this data, it should do so, and increment the reference * count in the supplied callback. */int bus_for_each_dev(const struct bus_type *bus, struct device *start, void *data, device_iter_t fn){ struct subsys_private *sp = bus_to_subsys(bus); struct klist_iter i; struct device *dev; int error = 0;
if (!sp) return -EINVAL;
klist_iter_init_node(&sp->klist_devices, &i, (start ? &start->p->knode_bus : NULL)); while (!error && (dev = next_device(&i))) error = fn(dev, data); klist_iter_exit(&i); subsys_put(sp); return error;}EXPORT_SYMBOL_GPL(bus_for_each_dev);
/** * bus_find_device - device iterator for locating a particular device. * @bus: bus type * @start: Device to begin with * @data: Data to pass to match function * @match: Callback function to check device * * This is similar to the bus_for_each_dev() function above, but it * returns a reference to a device that is 'found' for later use, as * determined by the @match callback. * * The callback should return 0 if the device doesn't match and non-zero * if it does. If the callback returns non-zero, this function will * return to the caller and not iterate over any more devices. */struct device *bus_find_device(const struct bus_type *bus, struct device *start, const void *data, device_match_t match){ struct subsys_private *sp = bus_to_subsys(bus); struct klist_iter i; struct device *dev;
if (!sp) return NULL;
klist_iter_init_node(&sp->klist_devices, &i, (start ? &start->p->knode_bus : NULL)); while ((dev = next_device(&i))) { if (match(dev, data)) { get_device(dev); break; } } klist_iter_exit(&i); subsys_put(sp); return dev;}EXPORT_SYMBOL_GPL(bus_find_device);
struct device *bus_find_device_reverse(const struct bus_type *bus, struct device *start, const void *data, device_match_t match){ struct subsys_private *sp = bus_to_subsys(bus); struct klist_iter i; struct device *dev;
if (!sp) return NULL;
klist_iter_init_node(&sp->klist_devices, &i, (start ? &start->p->knode_bus : NULL)); while ((dev = prev_device(&i))) { if (match(dev, data)) { get_device(dev); break; } } klist_iter_exit(&i); subsys_put(sp); return dev;}EXPORT_SYMBOL_GPL(bus_find_device_reverse);
static struct device_driver *next_driver(struct klist_iter *i){ struct klist_node *n = klist_next(i); struct driver_private *drv_priv;
if (n) { drv_priv = container_of(n, struct driver_private, knode_bus); return drv_priv->driver; } return NULL;}
/** * bus_for_each_drv - driver iterator * @bus: bus we're dealing with. * @start: driver to start iterating on. * @data: data to pass to the callback. * @fn: function to call for each driver. * * This is nearly identical to the device iterator above. * We iterate over each driver that belongs to @bus, and call * @fn for each. If @fn returns anything but 0, we break out * and return it. If @start is not NULL, we use it as the head * of the list. * * NOTE: we don't return the driver that returns a non-zero * value, nor do we leave the reference count incremented for that * driver. If the caller needs to know that info, it must set it * in the callback. It must also be sure to increment the refcount * so it doesn't disappear before returning to the caller. */int bus_for_each_drv(const struct bus_type *bus, struct device_driver *start, void *data, int (*fn)(struct device_driver *, void *)){ struct subsys_private *sp = bus_to_subsys(bus); struct klist_iter i; struct device_driver *drv; int error = 0;
if (!sp) return -EINVAL;
klist_iter_init_node(&sp->klist_drivers, &i, start ? &start->p->knode_bus : NULL); while ((drv = next_driver(&i)) && !error) error = fn(drv, data); klist_iter_exit(&i); subsys_put(sp); return error;}EXPORT_SYMBOL_GPL(bus_for_each_drv);
static ssize_t driver_override_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ int ret;
ret = __device_set_driver_override(dev, buf, count); if (ret) return ret;
return count;}
static ssize_t driver_override_show(struct device *dev, struct device_attribute *attr, char *buf){ guard(spinlock)(&dev->driver_override.lock); return sysfs_emit(buf, "%s\n", dev->driver_override.name);}static DEVICE_ATTR_RW(driver_override);
static struct attribute *driver_override_dev_attrs[] = { &dev_attr_driver_override.attr, NULL,};
static const struct attribute_group driver_override_dev_group = { .attrs = driver_override_dev_attrs,};
/** * bus_add_device - add device to bus * @dev: device being added * * - Add device's bus attributes. * - Create links to device's bus. * - Add the device to its bus's list of devices. */int bus_add_device(struct device *dev){ struct subsys_private *sp; int error;
if (!dev->bus) { /* * This is a normal operation for many devices that do not * have a bus assigned to them, just say that all went * well. */ return 0; }
sp = bus_to_subsys(dev->bus); if (!sp) { pr_err("%s: cannot add device '%s' to unregistered bus '%s'\n", __func__, dev_name(dev), dev->bus->name); return -EINVAL; }
/* * Reference in sp is now incremented and will be dropped when * the device is removed from the bus */
pr_debug("bus: '%s': add device %s\n", sp->bus->name, dev_name(dev));
error = device_add_groups(dev, sp->bus->dev_groups); if (error) goto out_put;
if (dev->bus->driver_override) { error = device_add_group(dev, &driver_override_dev_group); if (error) goto out_groups; }
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;
klist_add_tail(&dev->p->knode_bus, &sp->klist_devices); return 0;
out_subsys: 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;}
static void __bus_probe_device(struct device *dev){ struct subsys_private *sp = bus_to_subsys(dev->bus); struct subsys_interface *sif;
if (!sp) return;
device_initial_probe(dev);
mutex_lock(&sp->mutex); list_for_each_entry(sif, &sp->interfaces, node) if (sif->add_dev) sif->add_dev(dev, sif); mutex_unlock(&sp->mutex); subsys_put(sp);}
/** * bus_probe_device - probe drivers for a new device * @dev: device to probe * * - Automatically probe for a driver if the bus allows it. */void bus_probe_device(struct device *dev){ __bus_probe_device(dev);}
void bus_probe_device_deferred(struct device *dev){ if (dev->type && dev->type->need_parent_lock) device_lock(dev->parent); __bus_probe_device(dev); if (dev->type && dev->type->need_parent_lock) device_unlock(dev->parent);}
/** * bus_remove_device - remove device from bus * @dev: device to be removed * * - Remove device from all interfaces. * - Remove symlink from bus' directory. * - Delete device from bus's list. * - Detach from its driver. * - Drop reference taken in bus_add_device(). */void bus_remove_device(struct device *dev){ struct subsys_private *sp = bus_to_subsys(dev->bus); struct subsys_interface *sif;
if (!sp) return;
mutex_lock(&sp->mutex); list_for_each_entry(sif, &sp->interfaces, node) if (sif->remove_dev) sif->remove_dev(dev, sif); mutex_unlock(&sp->mutex);
sysfs_remove_link(&dev->kobj, "subsystem"); 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);
pr_debug("bus: '%s': remove device %s\n", dev->bus->name, dev_name(dev)); device_release_driver(dev);
/* * Decrement the reference count twice, once for the bus_to_subsys() * call in the start of this function, and the second one from the * reference increment in bus_add_device() */ subsys_put(sp); subsys_put(sp);}
static int __must_check add_bind_files(struct device_driver *drv){ int ret;
ret = driver_create_file(drv, &driver_attr_unbind); if (ret == 0) { ret = driver_create_file(drv, &driver_attr_bind); if (ret) driver_remove_file(drv, &driver_attr_unbind); } return ret;}
static void remove_bind_files(struct device_driver *drv){ driver_remove_file(drv, &driver_attr_bind); driver_remove_file(drv, &driver_attr_unbind);}
static BUS_ATTR_WO(drivers_probe);static BUS_ATTR_RW(drivers_autoprobe);
static int add_probe_files(const struct bus_type *bus){ int retval;
retval = bus_create_file(bus, &bus_attr_drivers_probe); if (retval) goto out;
retval = bus_create_file(bus, &bus_attr_drivers_autoprobe); if (retval) bus_remove_file(bus, &bus_attr_drivers_probe);out: return retval;}
static void remove_probe_files(const struct bus_type *bus){ bus_remove_file(bus, &bus_attr_drivers_autoprobe); bus_remove_file(bus, &bus_attr_drivers_probe);}
static ssize_t uevent_store(struct device_driver *drv, const char *buf, size_t count){ int rc;
rc = kobject_synth_uevent(&drv->p->kobj, buf, count); return rc ? rc : count;}static DRIVER_ATTR_WO(uevent);
/** * bus_add_driver - Add a driver to the bus. * @drv: driver. */int bus_add_driver(struct device_driver *drv){ struct subsys_private *sp = bus_to_subsys(drv->bus); struct driver_private *priv; int error = 0;
if (!sp) return -EINVAL;
if (sp->no_drivers) { error = -ENXIO; goto out_put_bus; }
/* * Reference in sp is now incremented and will be dropped when * the driver is removed from the bus */ pr_debug("bus: '%s': add driver %s\n", sp->bus->name, drv->name);
priv = kzalloc_obj(*priv); if (!priv) { error = -ENOMEM; goto out_put_bus; } klist_init(&priv->klist_devices, NULL, NULL); priv->driver = drv; drv->p = priv; priv->kobj.kset = sp->drivers_kset; error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL, "%s", drv->name); if (error) goto out_unregister;
klist_add_tail(&priv->knode_bus, &sp->klist_drivers); if (sp->drivers_autoprobe) { error = driver_attach(drv); if (error) goto out_del_list; } error = module_add_driver(drv->owner, drv); if (error) { printk(KERN_ERR "%s: failed to create module links for %s\n", __func__, drv->name); goto out_detach; }
error = driver_create_file(drv, &driver_attr_uevent); if (error) { printk(KERN_ERR "%s: uevent attr (%s) failed\n", __func__, drv->name); } error = driver_add_groups(drv, sp->bus->drv_groups); if (error) { /* How the hell do we get out of this pickle? Give up */ printk(KERN_ERR "%s: driver_add_groups(%s) failed\n", __func__, drv->name); }
if (!drv->suppress_bind_attrs) { error = add_bind_files(drv); if (error) { /* Ditto */ printk(KERN_ERR "%s: add_bind_files(%s) failed\n", __func__, drv->name); } }
return 0;
out_detach: driver_detach(drv);out_del_list: klist_del(&priv->knode_bus);out_unregister: kobject_put(&priv->kobj); /* drv->p is freed in driver_release() */ drv->p = NULL;out_put_bus: subsys_put(sp); return error;}
/** * bus_remove_driver - delete driver from bus's knowledge. * @drv: driver. * * Detach the driver from the devices it controls, and remove * it from its bus's list of drivers. Finally, we drop the reference * to the bus we took in bus_add_driver(). */void bus_remove_driver(struct device_driver *drv){ struct subsys_private *sp = bus_to_subsys(drv->bus);
if (!sp) return;
pr_debug("bus: '%s': remove driver %s\n", sp->bus->name, drv->name);
if (!drv->suppress_bind_attrs) remove_bind_files(drv); driver_remove_groups(drv, sp->bus->drv_groups); driver_remove_file(drv, &driver_attr_uevent); klist_remove(&drv->p->knode_bus); driver_detach(drv); module_remove_driver(drv); kobject_put(&drv->p->kobj);
/* * Decrement the reference count twice, once for the bus_to_subsys() * call in the start of this function, and the second one from the * reference increment in bus_add_driver() */ subsys_put(sp); subsys_put(sp);}
/* Helper for bus_rescan_devices's iter */static int __must_check bus_rescan_devices_helper(struct device *dev, void *data){ int ret = 0;
if (!dev->driver) { if (dev->type && dev->type->need_parent_lock) device_lock(dev->parent); ret = device_attach(dev); if (dev->type && dev->type->need_parent_lock) device_unlock(dev->parent); } return ret < 0 ? ret : 0;}
/** * bus_rescan_devices - rescan devices on the bus for possible drivers * @bus: the bus to scan. * * This function will look for devices on the bus with no driver * attached and rescan it against existing drivers to see if it matches * any by calling device_attach() for the unbound devices. */int bus_rescan_devices(const struct bus_type *bus){ return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);}EXPORT_SYMBOL_GPL(bus_rescan_devices);
/** * device_reprobe - remove driver for a device and probe for a new driver * @dev: the device to reprobe * * This function detaches the attached driver (if any) for the given * device and restarts the driver probing process. It is intended * to use if probing criteria changed during a devices lifetime and * driver attachment should change accordingly. */int device_reprobe(struct device *dev){ if (dev->driver) device_driver_detach(dev); return bus_rescan_devices_helper(dev, NULL);}EXPORT_SYMBOL_GPL(device_reprobe);
static void klist_devices_get(struct klist_node *n){ struct device_private *dev_prv = to_device_private_bus(n); struct device *dev = dev_prv->device;
get_device(dev);}
static void klist_devices_put(struct klist_node *n){ struct device_private *dev_prv = to_device_private_bus(n); struct device *dev = dev_prv->device;
put_device(dev);}
static ssize_t bus_uevent_store(const struct bus_type *bus, const char *buf, size_t count){ struct subsys_private *sp = bus_to_subsys(bus); int ret;
if (!sp) return -EINVAL;
ret = kobject_synth_uevent(&sp->subsys.kobj, buf, count); subsys_put(sp);
if (ret) return ret; return count;}/* * "open code" the old BUS_ATTR() macro here. We want to use BUS_ATTR_WO() * here, but can not use it as earlier in the file we have * DEVICE_ATTR_WO(uevent), which would cause a clash with the with the store * function name. */static struct bus_attribute bus_attr_uevent = __ATTR(uevent, 0200, NULL, bus_uevent_store);
static int bus_register_internal(const struct bus_type *bus, bool use_drivers){ int retval; struct subsys_private *priv; struct kobject *bus_kobj; struct lock_class_key *key;
priv = kzalloc_obj(struct subsys_private); if (!priv) return -ENOMEM;
priv->bus = bus;
BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
bus_kobj = &priv->subsys.kobj; retval = kobject_set_name(bus_kobj, "%s", bus->name); if (retval) goto out;
bus_kobj->kset = bus_kset; bus_kobj->ktype = &bus_ktype; priv->drivers_autoprobe = use_drivers; priv->no_drivers = !use_drivers;
retval = kset_register(&priv->subsys); if (retval) goto out;
retval = bus_create_file(bus, &bus_attr_uevent); if (retval) goto bus_uevent_fail;
priv->devices_kset = kset_create_and_add("devices", NULL, bus_kobj); if (!priv->devices_kset) { retval = -ENOMEM; goto bus_devices_fail; }
/* * Create the drivers kset even if use_drivers is unset to prevent some * older versions of systemd from failing. */ priv->drivers_kset = kset_create_and_add("drivers", NULL, bus_kobj); if (!priv->drivers_kset) { retval = -ENOMEM; goto bus_drivers_fail; }
INIT_LIST_HEAD(&priv->interfaces); key = &priv->lock_key; lockdep_register_key(key); __mutex_init(&priv->mutex, "subsys mutex", key); klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put); klist_init(&priv->klist_drivers, NULL, NULL);
if (use_drivers) { retval = add_probe_files(bus); if (retval) goto bus_probe_files_fail; }
retval = sysfs_create_groups(bus_kobj, bus->bus_groups); if (retval) goto bus_groups_fail;
pr_debug("bus: '%s': registered\n", bus->name); return 0;
bus_groups_fail: remove_probe_files(bus);bus_probe_files_fail: kset_unregister(priv->drivers_kset);bus_drivers_fail: kset_unregister(priv->devices_kset);bus_devices_fail: bus_remove_file(bus, &bus_attr_uevent);bus_uevent_fail: kset_unregister(&priv->subsys); /* Above kset_unregister() will kfree @priv */ priv = NULL;out: kfree(priv); return retval;}
/** * bus_register - register a driver-core subsystem * @bus: bus to register * * Once we have that, we register the bus with the kobject * infrastructure, then register the children subsystems it has: * the devices and drivers that belong to the subsystem. */int bus_register(const struct bus_type *bus){ return bus_register_internal(bus, true);}EXPORT_SYMBOL_GPL(bus_register);
/** * companion_bus_register - register a companion bus type * @bus: companion bus to register * * A companion bus is a bus without drivers. Devices that belong to it can be * bound to other devices as their "companions" and represent interfaces that * can be used by the drivers of those other devices. They may also be used for * the enumeration of those other devices. * * The ACPI bus is a specific example of a companion bus. * * Registering a companion bus is like registering a regular bus except that it * skips the creation of sysfs interfaces related to drivers for @bus. */int companion_bus_register(const struct bus_type *bus){ return bus_register_internal(bus, false);}
/** * bus_unregister - remove a bus from the system * @bus: bus. * * Unregister the child subsystems and the bus itself. * Finally, we call bus_put() to release the refcount */void bus_unregister(const struct bus_type *bus){ struct subsys_private *sp = bus_to_subsys(bus); struct kobject *bus_kobj;
if (!sp) return;
pr_debug("bus: '%s': unregistering\n", bus->name); if (sp->dev_root) device_unregister(sp->dev_root);
bus_kobj = &sp->subsys.kobj; sysfs_remove_groups(bus_kobj, bus->bus_groups); remove_probe_files(bus); bus_remove_file(bus, &bus_attr_uevent);
kset_unregister(sp->drivers_kset); kset_unregister(sp->devices_kset); kset_unregister(&sp->subsys); subsys_put(sp);}EXPORT_SYMBOL_GPL(bus_unregister);
int bus_register_notifier(const struct bus_type *bus, struct notifier_block *nb){ struct subsys_private *sp = bus_to_subsys(bus); int retval;
if (!sp) return -EINVAL;
retval = blocking_notifier_chain_register(&sp->bus_notifier, nb); subsys_put(sp); return retval;}EXPORT_SYMBOL_GPL(bus_register_notifier);
int bus_unregister_notifier(const struct bus_type *bus, struct notifier_block *nb){ struct subsys_private *sp = bus_to_subsys(bus); int retval;
if (!sp) return -EINVAL; retval = blocking_notifier_chain_unregister(&sp->bus_notifier, nb); subsys_put(sp); return retval;}EXPORT_SYMBOL_GPL(bus_unregister_notifier);
void bus_notify(struct device *dev, enum bus_notifier_event value){ struct subsys_private *sp = bus_to_subsys(dev->bus);
if (!sp) return;
blocking_notifier_call_chain(&sp->bus_notifier, value, dev); subsys_put(sp);}
struct kset *bus_get_kset(const struct bus_type *bus){ struct subsys_private *sp = bus_to_subsys(bus); struct kset *kset;
if (!sp) return NULL;
kset = &sp->subsys; subsys_put(sp);
return kset;}EXPORT_SYMBOL_GPL(bus_get_kset);
/* * Yes, this forcibly breaks the klist abstraction temporarily. It * just wants to sort the klist, not change reference counts and * take/drop locks rapidly in the process. It does all this while * holding the lock for the list, so objects can't otherwise be * added/removed while we're swizzling. */static void device_insertion_sort_klist(struct device *a, struct list_head *list, int (*compare)(const struct device *a, const struct device *b)){ struct klist_node *n; struct device_private *dev_prv; struct device *b;
list_for_each_entry(n, list, n_node) { dev_prv = to_device_private_bus(n); b = dev_prv->device; if (compare(a, b) <= 0) { list_move_tail(&a->p->knode_bus.n_node, &b->p->knode_bus.n_node); return; } } list_move_tail(&a->p->knode_bus.n_node, list);}
void bus_sort_breadthfirst(const struct bus_type *bus, int (*compare)(const struct device *a, const struct device *b)){ struct subsys_private *sp = bus_to_subsys(bus); LIST_HEAD(sorted_devices); struct klist_node *n, *tmp; struct device_private *dev_prv; struct device *dev; struct klist *device_klist;
if (!sp) return; device_klist = &sp->klist_devices;
spin_lock(&device_klist->k_lock); list_for_each_entry_safe(n, tmp, &device_klist->k_list, n_node) { dev_prv = to_device_private_bus(n); dev = dev_prv->device; device_insertion_sort_klist(dev, &sorted_devices, compare); } list_splice(&sorted_devices, &device_klist->k_list); spin_unlock(&device_klist->k_lock); subsys_put(sp);}EXPORT_SYMBOL_GPL(bus_sort_breadthfirst);
struct subsys_dev_iter { struct klist_iter ki; const struct device_type *type;};
/** * subsys_dev_iter_init - initialize subsys device iterator * @iter: subsys iterator to initialize * @sp: the subsys private (i.e. bus) we wanna iterate over * @start: the device to start iterating from, if any * @type: device_type of the devices to iterate over, NULL for all * * Initialize subsys iterator @iter such that it iterates over devices * of @subsys. If @start is set, the list iteration will start there, * otherwise if it is NULL, the iteration starts at the beginning of * the list. */static void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct subsys_private *sp, struct device *start, const struct device_type *type){ struct klist_node *start_knode = NULL;
if (start) start_knode = &start->p->knode_bus; klist_iter_init_node(&sp->klist_devices, &iter->ki, start_knode); iter->type = type;}
/** * subsys_dev_iter_next - iterate to the next device * @iter: subsys iterator to proceed * * Proceed @iter to the next device and return it. Returns NULL if * iteration is complete. * * The returned device is referenced and won't be released till * iterator is proceed to the next device or exited. The caller is * free to do whatever it wants to do with the device including * calling back into subsys code. */static struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter){ struct klist_node *knode; struct device *dev;
for (;;) { knode = klist_next(&iter->ki); if (!knode) return NULL; dev = to_device_private_bus(knode)->device; if (!iter->type || iter->type == dev->type) return dev; }}
/** * subsys_dev_iter_exit - finish iteration * @iter: subsys iterator to finish * * Finish an iteration. Always call this function after iteration is * complete whether the iteration ran till the end or not. */static void subsys_dev_iter_exit(struct subsys_dev_iter *iter){ klist_iter_exit(&iter->ki);}
int subsys_interface_register(struct subsys_interface *sif){ struct subsys_private *sp; struct subsys_dev_iter iter; struct device *dev;
if (!sif || !sif->subsys) return -ENODEV;
sp = bus_to_subsys(sif->subsys); if (!sp) return -EINVAL;
/* * Reference in sp is now incremented and will be dropped when * the interface is removed from the bus */
mutex_lock(&sp->mutex); list_add_tail(&sif->node, &sp->interfaces); if (sif->add_dev) { subsys_dev_iter_init(&iter, sp, NULL, NULL); while ((dev = subsys_dev_iter_next(&iter))) sif->add_dev(dev, sif); subsys_dev_iter_exit(&iter); } mutex_unlock(&sp->mutex);
return 0;}EXPORT_SYMBOL_GPL(subsys_interface_register);
void subsys_interface_unregister(struct subsys_interface *sif){ struct subsys_private *sp; struct subsys_dev_iter iter; struct device *dev;
if (!sif || !sif->subsys) return;
sp = bus_to_subsys(sif->subsys); if (!sp) return;
mutex_lock(&sp->mutex); list_del_init(&sif->node); if (sif->remove_dev) { subsys_dev_iter_init(&iter, sp, NULL, NULL); while ((dev = subsys_dev_iter_next(&iter))) sif->remove_dev(dev, sif); subsys_dev_iter_exit(&iter); } mutex_unlock(&sp->mutex);
/* * Decrement the reference count twice, once for the bus_to_subsys() * call in the start of this function, and the second one from the * reference increment in subsys_interface_register() */ subsys_put(sp); subsys_put(sp);}EXPORT_SYMBOL_GPL(subsys_interface_unregister);
static void system_root_device_release(struct device *dev){ kfree(dev);}
static int subsys_register(const struct bus_type *subsys, const struct attribute_group **groups, struct kobject *parent_of_root){ struct subsys_private *sp; struct device *dev; int err;
err = bus_register(subsys); if (err < 0) return err;
sp = bus_to_subsys(subsys); if (!sp) { err = -EINVAL; goto err_sp; }
dev = kzalloc_obj(struct device); if (!dev) { err = -ENOMEM; goto err_dev; }
err = dev_set_name(dev, "%s", subsys->name); if (err < 0) goto err_name;
dev->kobj.parent = parent_of_root; dev->groups = groups; dev->release = system_root_device_release;
err = device_register(dev); if (err < 0) goto err_dev_reg;
sp->dev_root = dev; subsys_put(sp); return 0;
err_dev_reg: put_device(dev); dev = NULL;err_name: kfree(dev);err_dev: subsys_put(sp);err_sp: bus_unregister(subsys); return err;}
/** * subsys_system_register - register a subsystem at /sys/devices/system/ * @subsys: system subsystem * @groups: default attributes for the root device * * All 'system' subsystems have a /sys/devices/system/<name> root device * with the name of the subsystem. The root device can carry subsystem- * wide attributes. All registered devices are below this single root * device and are named after the subsystem with a simple enumeration * number appended. The registered devices are not explicitly named; * only 'id' in the device needs to be set. * * Do not use this interface for anything new, it exists for compatibility * with bad ideas only. New subsystems should use plain subsystems; and * add the subsystem-wide attributes should be added to the subsystem * directory itself and not some create fake root-device placed in * /sys/devices/system/<name>. */int subsys_system_register(const struct bus_type *subsys, const struct attribute_group **groups){ return subsys_register(subsys, groups, &system_kset->kobj);}EXPORT_SYMBOL_GPL(subsys_system_register);
/** * subsys_virtual_register - register a subsystem at /sys/devices/virtual/ * @subsys: virtual subsystem * @groups: default attributes for the root device * * All 'virtual' subsystems have a /sys/devices/system/<name> root device * with the name of the subsystem. The root device can carry subsystem-wide * attributes. All registered devices are below this single root device. * There's no restriction on device naming. This is for kernel software * constructs which need sysfs interface. */int subsys_virtual_register(const struct bus_type *subsys, const struct attribute_group **groups){ struct kobject *virtual_dir;
virtual_dir = virtual_device_parent(); if (!virtual_dir) return -ENOMEM;
return subsys_register(subsys, groups, virtual_dir);}EXPORT_SYMBOL_GPL(subsys_virtual_register);
/** * driver_find - locate driver on a bus by its name. * @name: name of the driver. * @bus: bus to scan for the driver. * * Call kset_find_obj() to iterate over list of drivers on * a bus to find driver by name. Return driver if found. * * This routine provides no locking to prevent the driver it returns * from being unregistered or unloaded while the caller is using it. * The caller is responsible for preventing this. */struct device_driver *driver_find(const char *name, const struct bus_type *bus){ struct subsys_private *sp = bus_to_subsys(bus); struct kobject *k; struct driver_private *priv;
if (!sp) return NULL;
if (sp->no_drivers) { subsys_put(sp); return NULL; }
k = kset_find_obj(sp->drivers_kset, name); subsys_put(sp); if (!k) return NULL;
priv = to_driver(k);
/* Drop reference added by kset_find_obj() */ kobject_put(k); return priv->driver;}EXPORT_SYMBOL_GPL(driver_find);
/* * Warning, the value could go to "removed" instantly after calling this function, so be very * careful when calling it... */bool bus_is_registered(const struct bus_type *bus){ struct subsys_private *sp = bus_to_subsys(bus); bool is_initialized = false;
if (sp) { is_initialized = true; subsys_put(sp); } return is_initialized;}
/** * bus_get_dev_root - return a pointer to the "device root" of a bus * @bus: bus to return the device root of. * * If a bus has a "device root" structure, return it, WITH THE REFERENCE * COUNT INCREMENTED. * * Note, when finished with the device, a call to put_device() is required. * * If the device root is not present (or bus is not a valid pointer), NULL * will be returned. */struct device *bus_get_dev_root(const struct bus_type *bus){ struct subsys_private *sp = bus_to_subsys(bus); struct device *dev_root;
if (!sp) return NULL;
dev_root = get_device(sp->dev_root); subsys_put(sp); return dev_root;}EXPORT_SYMBOL_GPL(bus_get_dev_root);
int __init buses_init(void){ bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL); if (!bus_kset) return -ENOMEM;
system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj); if (!system_kset) { /* Do error handling here as devices_init() do */ kset_unregister(bus_kset); bus_kset = NULL; pr_err("%s: failed to create and add kset 'bus'\n", __func__); return -ENOMEM; }
return 0;}