Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * bus.c - bus driver management
4 : : *
5 : : * Copyright (c) 2002-3 Patrick Mochel
6 : : * Copyright (c) 2002-3 Open Source Development Labs
7 : : * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de>
8 : : * Copyright (c) 2007 Novell Inc.
9 : : */
10 : :
11 : : #include <linux/async.h>
12 : : #include <linux/device.h>
13 : : #include <linux/module.h>
14 : : #include <linux/errno.h>
15 : : #include <linux/slab.h>
16 : : #include <linux/init.h>
17 : : #include <linux/string.h>
18 : : #include <linux/mutex.h>
19 : : #include <linux/sysfs.h>
20 : : #include "base.h"
21 : : #include "power/power.h"
22 : :
23 : : /* /sys/devices/system */
24 : : static struct kset *system_kset;
25 : :
26 : : #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
27 : :
28 : : /*
29 : : * sysfs bindings for drivers
30 : : */
31 : :
32 : : #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
33 : :
34 : : #define DRIVER_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
35 : : struct driver_attribute driver_attr_##_name = \
36 : : __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
37 : :
38 : : static int __must_check bus_rescan_devices_helper(struct device *dev,
39 : : void *data);
40 : :
41 : : static struct bus_type *bus_get(struct bus_type *bus)
42 : : {
43 [ # # + - : 178166 : if (bus) {
+ + # # #
# # # +
- ]
44 : 81608 : kset_get(&bus->p->subsys);
45 : : return bus;
46 : : }
47 : : return NULL;
48 : : }
49 : :
50 : : static void bus_put(struct bus_type *bus)
51 : : {
52 [ # # # # : 28280 : if (bus)
# # + - #
# # # # #
# # + - ]
53 : 28280 : kset_put(&bus->p->subsys);
54 : : }
55 : :
56 : 0 : static ssize_t drv_attr_show(struct kobject *kobj, struct attribute *attr,
57 : : char *buf)
58 : : {
59 : : struct driver_attribute *drv_attr = to_drv_attr(attr);
60 : : struct driver_private *drv_priv = to_driver(kobj);
61 : : ssize_t ret = -EIO;
62 : :
63 [ # # ]: 0 : if (drv_attr->show)
64 : 0 : ret = drv_attr->show(drv_priv->driver, buf);
65 : 0 : return ret;
66 : : }
67 : :
68 : 25048 : static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr,
69 : : const char *buf, size_t count)
70 : : {
71 : : struct driver_attribute *drv_attr = to_drv_attr(attr);
72 : : struct driver_private *drv_priv = to_driver(kobj);
73 : : ssize_t ret = -EIO;
74 : :
75 [ + - ]: 25048 : if (drv_attr->store)
76 : 25048 : ret = drv_attr->store(drv_priv->driver, buf, count);
77 : 25048 : return ret;
78 : : }
79 : :
80 : : static const struct sysfs_ops driver_sysfs_ops = {
81 : : .show = drv_attr_show,
82 : : .store = drv_attr_store,
83 : : };
84 : :
85 : 0 : static void driver_release(struct kobject *kobj)
86 : : {
87 : : struct driver_private *drv_priv = to_driver(kobj);
88 : :
89 : : pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__);
90 : 0 : kfree(drv_priv);
91 : 0 : }
92 : :
93 : : static struct kobj_type driver_ktype = {
94 : : .sysfs_ops = &driver_sysfs_ops,
95 : : .release = driver_release,
96 : : };
97 : :
98 : : /*
99 : : * sysfs bindings for buses
100 : : */
101 : 0 : static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr,
102 : : char *buf)
103 : : {
104 : : struct bus_attribute *bus_attr = to_bus_attr(attr);
105 : : struct subsys_private *subsys_priv = to_subsys_private(kobj);
106 : : ssize_t ret = 0;
107 : :
108 [ # # ]: 0 : if (bus_attr->show)
109 : 0 : ret = bus_attr->show(subsys_priv->bus, buf);
110 : 0 : return ret;
111 : : }
112 : :
113 : 9292 : static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,
114 : : const char *buf, size_t count)
115 : : {
116 : : struct bus_attribute *bus_attr = to_bus_attr(attr);
117 : : struct subsys_private *subsys_priv = to_subsys_private(kobj);
118 : : ssize_t ret = 0;
119 : :
120 [ + - ]: 9292 : if (bus_attr->store)
121 : 9292 : ret = bus_attr->store(subsys_priv->bus, buf, count);
122 : 9292 : return ret;
123 : : }
124 : :
125 : : static const struct sysfs_ops bus_sysfs_ops = {
126 : : .show = bus_attr_show,
127 : : .store = bus_attr_store,
128 : : };
129 : :
130 : 27876 : int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
131 : : {
132 : : int error;
133 [ + - ]: 27876 : if (bus_get(bus)) {
134 : 27876 : error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
135 : : bus_put(bus);
136 : : } else
137 : : error = -EINVAL;
138 : 27876 : return error;
139 : : }
140 : : EXPORT_SYMBOL_GPL(bus_create_file);
141 : :
142 : 0 : void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
143 : : {
144 [ # # ]: 0 : if (bus_get(bus)) {
145 : 0 : sysfs_remove_file(&bus->p->subsys.kobj, &attr->attr);
146 : : bus_put(bus);
147 : : }
148 : 0 : }
149 : : EXPORT_SYMBOL_GPL(bus_remove_file);
150 : :
151 : 0 : static void bus_release(struct kobject *kobj)
152 : : {
153 : 0 : struct subsys_private *priv = to_subsys_private(kobj);
154 : 0 : struct bus_type *bus = priv->bus;
155 : :
156 : 0 : kfree(priv);
157 : 0 : bus->p = NULL;
158 : 0 : }
159 : :
160 : : static struct kobj_type bus_ktype = {
161 : : .sysfs_ops = &bus_sysfs_ops,
162 : : .release = bus_release,
163 : : };
164 : :
165 : 37168 : static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
166 : : {
167 : : struct kobj_type *ktype = get_ktype(kobj);
168 : :
169 [ + + ]: 37168 : if (ktype == &bus_ktype)
170 : : return 1;
171 : 18584 : return 0;
172 : : }
173 : :
174 : : static const struct kset_uevent_ops bus_uevent_ops = {
175 : : .filter = bus_uevent_filter,
176 : : };
177 : :
178 : : static struct kset *bus_kset;
179 : :
180 : : /* Manually detach a device from its associated driver. */
181 : 0 : static ssize_t unbind_store(struct device_driver *drv, const char *buf,
182 : : size_t count)
183 : : {
184 : 0 : struct bus_type *bus = bus_get(drv->bus);
185 : : struct device *dev;
186 : : int err = -ENODEV;
187 : :
188 : : dev = bus_find_device_by_name(bus, NULL, buf);
189 [ # # # # ]: 0 : if (dev && dev->driver == drv) {
190 : 0 : device_driver_detach(dev);
191 : 0 : err = count;
192 : : }
193 : 0 : put_device(dev);
194 : : bus_put(bus);
195 : 0 : return err;
196 : : }
197 : : static DRIVER_ATTR_IGNORE_LOCKDEP(unbind, S_IWUSR, NULL, unbind_store);
198 : :
199 : : /*
200 : : * Manually attach a device to a driver.
201 : : * Note: the driver must want to bind to the device,
202 : : * it is not possible to override the driver's id table.
203 : : */
204 : 0 : static ssize_t bind_store(struct device_driver *drv, const char *buf,
205 : : size_t count)
206 : : {
207 : 0 : struct bus_type *bus = bus_get(drv->bus);
208 : : struct device *dev;
209 : : int err = -ENODEV;
210 : :
211 : : dev = bus_find_device_by_name(bus, NULL, buf);
212 [ # # # # : 0 : if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
# # ]
213 : 0 : err = device_driver_attach(drv, dev);
214 : :
215 [ # # ]: 0 : if (err > 0) {
216 : : /* success */
217 : 0 : err = count;
218 [ # # ]: 0 : } else if (err == 0) {
219 : : /* driver didn't accept device */
220 : : err = -ENODEV;
221 : : }
222 : : }
223 : 0 : put_device(dev);
224 : : bus_put(bus);
225 : 0 : return err;
226 : : }
227 : : static DRIVER_ATTR_IGNORE_LOCKDEP(bind, S_IWUSR, NULL, bind_store);
228 : :
229 : 0 : static ssize_t drivers_autoprobe_show(struct bus_type *bus, char *buf)
230 : : {
231 : 0 : return sprintf(buf, "%d\n", bus->p->drivers_autoprobe);
232 : : }
233 : :
234 : 0 : static ssize_t drivers_autoprobe_store(struct bus_type *bus,
235 : : const char *buf, size_t count)
236 : : {
237 [ # # ]: 0 : if (buf[0] == '0')
238 : 0 : bus->p->drivers_autoprobe = 0;
239 : : else
240 : 0 : bus->p->drivers_autoprobe = 1;
241 : 0 : return count;
242 : : }
243 : :
244 : 0 : static ssize_t drivers_probe_store(struct bus_type *bus,
245 : : const char *buf, size_t count)
246 : : {
247 : : struct device *dev;
248 : : int err = -EINVAL;
249 : :
250 : : dev = bus_find_device_by_name(bus, NULL, buf);
251 [ # # ]: 0 : if (!dev)
252 : : return -ENODEV;
253 [ # # ]: 0 : if (bus_rescan_devices_helper(dev, NULL) == 0)
254 : 0 : err = count;
255 : 0 : put_device(dev);
256 : 0 : return err;
257 : : }
258 : :
259 : : static struct device *next_device(struct klist_iter *i)
260 : : {
261 : 522776 : struct klist_node *n = klist_next(i);
262 : : struct device *dev = NULL;
263 : : struct device_private *dev_prv;
264 : :
265 [ # # # # : 522776 : if (n) {
# # + + ]
266 : : dev_prv = to_device_private_bus(n);
267 : 494092 : dev = dev_prv->device;
268 : : }
269 : : return dev;
270 : : }
271 : :
272 : : /**
273 : : * bus_for_each_dev - device iterator.
274 : : * @bus: bus type.
275 : : * @start: device to start iterating from.
276 : : * @data: data for the callback.
277 : : * @fn: function to be called for each device.
278 : : *
279 : : * Iterate over @bus's list of devices, and call @fn for each,
280 : : * passing it @data. If @start is not NULL, we use that device to
281 : : * begin iterating from.
282 : : *
283 : : * We check the return of @fn each time. If it returns anything
284 : : * other than 0, we break out and return that value.
285 : : *
286 : : * NOTE: The device that returns a non-zero value is not retained
287 : : * in any way, nor is its refcount incremented. If the caller needs
288 : : * to retain this data, it should do so, and increment the reference
289 : : * count in the supplied callback.
290 : : */
291 : 28684 : int bus_for_each_dev(struct bus_type *bus, struct device *start,
292 : : void *data, int (*fn)(struct device *, void *))
293 : : {
294 : : struct klist_iter i;
295 : : struct device *dev;
296 : : int error = 0;
297 : :
298 [ + - + - ]: 28684 : if (!bus || !bus->p)
299 : : return -EINVAL;
300 : :
301 [ - + ]: 28684 : klist_iter_init_node(&bus->p->klist_devices, &i,
302 : 0 : (start ? &start->p->knode_bus : NULL));
303 [ + - + + ]: 1074236 : while (!error && (dev = next_device(&i)))
304 : 494092 : error = fn(dev, data);
305 : 28684 : klist_iter_exit(&i);
306 : 28684 : return error;
307 : : }
308 : : EXPORT_SYMBOL_GPL(bus_for_each_dev);
309 : :
310 : : /**
311 : : * bus_find_device - device iterator for locating a particular device.
312 : : * @bus: bus type
313 : : * @start: Device to begin with
314 : : * @data: Data to pass to match function
315 : : * @match: Callback function to check device
316 : : *
317 : : * This is similar to the bus_for_each_dev() function above, but it
318 : : * returns a reference to a device that is 'found' for later use, as
319 : : * determined by the @match callback.
320 : : *
321 : : * The callback should return 0 if the device doesn't match and non-zero
322 : : * if it does. If the callback returns non-zero, this function will
323 : : * return to the caller and not iterate over any more devices.
324 : : */
325 : 0 : struct device *bus_find_device(struct bus_type *bus,
326 : : struct device *start, const void *data,
327 : : int (*match)(struct device *dev, const void *data))
328 : : {
329 : : struct klist_iter i;
330 : : struct device *dev;
331 : :
332 [ # # # # ]: 0 : if (!bus || !bus->p)
333 : : return NULL;
334 : :
335 [ # # ]: 0 : klist_iter_init_node(&bus->p->klist_devices, &i,
336 : 0 : (start ? &start->p->knode_bus : NULL));
337 [ # # ]: 0 : while ((dev = next_device(&i)))
338 [ # # # # ]: 0 : if (match(dev, data) && get_device(dev))
339 : : break;
340 : 0 : klist_iter_exit(&i);
341 : 0 : return dev;
342 : : }
343 : : EXPORT_SYMBOL_GPL(bus_find_device);
344 : :
345 : : /**
346 : : * subsys_find_device_by_id - find a device with a specific enumeration number
347 : : * @subsys: subsystem
348 : : * @id: index 'id' in struct device
349 : : * @hint: device to check first
350 : : *
351 : : * Check the hint's next object and if it is a match return it directly,
352 : : * otherwise, fall back to a full list search. Either way a reference for
353 : : * the returned object is taken.
354 : : */
355 : 0 : struct device *subsys_find_device_by_id(struct bus_type *subsys, unsigned int id,
356 : : struct device *hint)
357 : : {
358 : : struct klist_iter i;
359 : : struct device *dev;
360 : :
361 [ # # ]: 0 : if (!subsys)
362 : : return NULL;
363 : :
364 [ # # ]: 0 : if (hint) {
365 : 0 : klist_iter_init_node(&subsys->p->klist_devices, &i, &hint->p->knode_bus);
366 : : dev = next_device(&i);
367 [ # # # # : 0 : if (dev && dev->id == id && get_device(dev)) {
# # ]
368 : 0 : klist_iter_exit(&i);
369 : 0 : return dev;
370 : : }
371 : 0 : klist_iter_exit(&i);
372 : : }
373 : :
374 : 0 : klist_iter_init_node(&subsys->p->klist_devices, &i, NULL);
375 [ # # ]: 0 : while ((dev = next_device(&i))) {
376 [ # # # # ]: 0 : if (dev->id == id && get_device(dev)) {
377 : 0 : klist_iter_exit(&i);
378 : 0 : return dev;
379 : : }
380 : : }
381 : 0 : klist_iter_exit(&i);
382 : 0 : return NULL;
383 : : }
384 : : EXPORT_SYMBOL_GPL(subsys_find_device_by_id);
385 : :
386 : : static struct device_driver *next_driver(struct klist_iter *i)
387 : : {
388 : 233512 : struct klist_node *n = klist_next(i);
389 : : struct driver_private *drv_priv;
390 : :
391 [ + + ]: 233512 : if (n) {
392 : : drv_priv = container_of(n, struct driver_private, knode_bus);
393 : 208060 : return drv_priv->driver;
394 : : }
395 : : return NULL;
396 : : }
397 : :
398 : : /**
399 : : * bus_for_each_drv - driver iterator
400 : : * @bus: bus we're dealing with.
401 : : * @start: driver to start iterating on.
402 : : * @data: data to pass to the callback.
403 : : * @fn: function to call for each driver.
404 : : *
405 : : * This is nearly identical to the device iterator above.
406 : : * We iterate over each driver that belongs to @bus, and call
407 : : * @fn for each. If @fn returns anything but 0, we break out
408 : : * and return it. If @start is not NULL, we use it as the head
409 : : * of the list.
410 : : *
411 : : * NOTE: we don't return the driver that returns a non-zero
412 : : * value, nor do we leave the reference count incremented for that
413 : : * driver. If the caller needs to know that info, it must set it
414 : : * in the callback. It must also be sure to increment the refcount
415 : : * so it doesn't disappear before returning to the caller.
416 : : */
417 : 29896 : int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
418 : : void *data, int (*fn)(struct device_driver *, void *))
419 : : {
420 : : struct klist_iter i;
421 : : struct device_driver *drv;
422 : : int error = 0;
423 : :
424 [ + - ]: 29896 : if (!bus)
425 : : return -EINVAL;
426 : :
427 [ - + ]: 29896 : klist_iter_init_node(&bus->p->klist_drivers, &i,
428 : 0 : start ? &start->p->knode_bus : NULL);
429 [ + + + + ]: 263408 : while ((drv = next_driver(&i)) && !error)
430 : 203616 : error = fn(drv, data);
431 : 29896 : klist_iter_exit(&i);
432 : 29896 : return error;
433 : : }
434 : : EXPORT_SYMBOL_GPL(bus_for_each_drv);
435 : :
436 : : /**
437 : : * bus_add_device - add device to bus
438 : : * @dev: device being added
439 : : *
440 : : * - Add device's bus attributes.
441 : : * - Create links to device's bus.
442 : : * - Add the device to its bus's list of devices.
443 : : */
444 : 123222 : int bus_add_device(struct device *dev)
445 : : {
446 : 123222 : struct bus_type *bus = bus_get(dev->bus);
447 : : int error = 0;
448 : :
449 [ + + ]: 123222 : if (bus) {
450 : : pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));
451 : 26664 : error = device_add_groups(dev, bus->dev_groups);
452 [ + - ]: 26664 : if (error)
453 : : goto out_put;
454 : 53328 : error = sysfs_create_link(&bus->p->devices_kset->kobj,
455 : : &dev->kobj, dev_name(dev));
456 [ + - ]: 26664 : if (error)
457 : : goto out_groups;
458 : 26664 : error = sysfs_create_link(&dev->kobj,
459 : 26664 : &dev->bus->p->subsys.kobj, "subsystem");
460 [ + - ]: 26664 : if (error)
461 : : goto out_subsys;
462 : 26664 : klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);
463 : : }
464 : : return 0;
465 : :
466 : : out_subsys:
467 : 0 : sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
468 : : out_groups:
469 : 0 : device_remove_groups(dev, bus->dev_groups);
470 : : out_put:
471 : 0 : bus_put(dev->bus);
472 : 0 : return error;
473 : : }
474 : :
475 : : /**
476 : : * bus_probe_device - probe drivers for a new device
477 : : * @dev: device to probe
478 : : *
479 : : * - Automatically probe for a driver if the bus allows it.
480 : : */
481 : 125242 : void bus_probe_device(struct device *dev)
482 : : {
483 : 125242 : struct bus_type *bus = dev->bus;
484 : : struct subsys_interface *sif;
485 : :
486 [ + + ]: 125242 : if (!bus)
487 : 125242 : return;
488 : :
489 [ + - ]: 28684 : if (bus->p->drivers_autoprobe)
490 : 28684 : device_initial_probe(dev);
491 : :
492 : 28684 : mutex_lock(&bus->p->mutex);
493 [ - + ]: 28684 : list_for_each_entry(sif, &bus->p->interfaces, node)
494 [ # # ]: 0 : if (sif->add_dev)
495 : 0 : sif->add_dev(dev, sif);
496 : 28684 : mutex_unlock(&bus->p->mutex);
497 : : }
498 : :
499 : : /**
500 : : * bus_remove_device - remove device from bus
501 : : * @dev: device to be removed
502 : : *
503 : : * - Remove device from all interfaces.
504 : : * - Remove symlink from bus' directory.
505 : : * - Delete device from bus's list.
506 : : * - Detach from its driver.
507 : : * - Drop reference taken in bus_add_device().
508 : : */
509 : 406 : void bus_remove_device(struct device *dev)
510 : : {
511 : 406 : struct bus_type *bus = dev->bus;
512 : : struct subsys_interface *sif;
513 : :
514 [ + + ]: 406 : if (!bus)
515 : 406 : return;
516 : :
517 : 404 : mutex_lock(&bus->p->mutex);
518 [ - + ]: 404 : list_for_each_entry(sif, &bus->p->interfaces, node)
519 [ # # ]: 0 : if (sif->remove_dev)
520 : 0 : sif->remove_dev(dev, sif);
521 : 404 : mutex_unlock(&bus->p->mutex);
522 : :
523 : 404 : sysfs_remove_link(&dev->kobj, "subsystem");
524 : 808 : sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
525 : : dev_name(dev));
526 : 404 : device_remove_groups(dev, dev->bus->dev_groups);
527 [ + - ]: 404 : if (klist_node_attached(&dev->p->knode_bus))
528 : 404 : klist_del(&dev->p->knode_bus);
529 : :
530 : : pr_debug("bus: '%s': remove device %s\n",
531 : : dev->bus->name, dev_name(dev));
532 : 404 : device_release_driver(dev);
533 : 404 : bus_put(dev->bus);
534 : : }
535 : :
536 : 24644 : static int __must_check add_bind_files(struct device_driver *drv)
537 : : {
538 : : int ret;
539 : :
540 : 24644 : ret = driver_create_file(drv, &driver_attr_unbind);
541 [ + - ]: 24644 : if (ret == 0) {
542 : 24644 : ret = driver_create_file(drv, &driver_attr_bind);
543 [ - + ]: 24644 : if (ret)
544 : 0 : driver_remove_file(drv, &driver_attr_unbind);
545 : : }
546 : 24644 : return ret;
547 : : }
548 : :
549 : 0 : static void remove_bind_files(struct device_driver *drv)
550 : : {
551 : 0 : driver_remove_file(drv, &driver_attr_bind);
552 : 0 : driver_remove_file(drv, &driver_attr_unbind);
553 : 0 : }
554 : :
555 : : static BUS_ATTR_WO(drivers_probe);
556 : : static BUS_ATTR_RW(drivers_autoprobe);
557 : :
558 : 9292 : static int add_probe_files(struct bus_type *bus)
559 : : {
560 : : int retval;
561 : :
562 : 9292 : retval = bus_create_file(bus, &bus_attr_drivers_probe);
563 [ + - ]: 9292 : if (retval)
564 : : goto out;
565 : :
566 : 9292 : retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
567 [ - + ]: 9292 : if (retval)
568 : 0 : bus_remove_file(bus, &bus_attr_drivers_probe);
569 : : out:
570 : 9292 : return retval;
571 : : }
572 : :
573 : 0 : static void remove_probe_files(struct bus_type *bus)
574 : : {
575 : 0 : bus_remove_file(bus, &bus_attr_drivers_autoprobe);
576 : 0 : bus_remove_file(bus, &bus_attr_drivers_probe);
577 : 0 : }
578 : :
579 : 25048 : static ssize_t uevent_store(struct device_driver *drv, const char *buf,
580 : : size_t count)
581 : : {
582 : : int rc;
583 : :
584 : 25048 : rc = kobject_synth_uevent(&drv->p->kobj, buf, count);
585 [ + - ]: 25048 : return rc ? rc : count;
586 : : }
587 : : static DRIVER_ATTR_WO(uevent);
588 : :
589 : : /**
590 : : * bus_add_driver - Add a driver to the bus.
591 : : * @drv: driver.
592 : : */
593 : 27068 : int bus_add_driver(struct device_driver *drv)
594 : : {
595 : : struct bus_type *bus;
596 : : struct driver_private *priv;
597 : : int error = 0;
598 : :
599 : 27068 : bus = bus_get(drv->bus);
600 [ + - ]: 27068 : if (!bus)
601 : : return -EINVAL;
602 : :
603 : : pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
604 : :
605 : 27068 : priv = kzalloc(sizeof(*priv), GFP_KERNEL);
606 [ + - ]: 27068 : if (!priv) {
607 : : error = -ENOMEM;
608 : : goto out_put_bus;
609 : : }
610 : 27068 : klist_init(&priv->klist_devices, NULL, NULL);
611 : 27068 : priv->driver = drv;
612 : 27068 : drv->p = priv;
613 : 27068 : priv->kobj.kset = bus->p->drivers_kset;
614 : 27068 : error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
615 : : "%s", drv->name);
616 [ + - ]: 27068 : if (error)
617 : : goto out_unregister;
618 : :
619 : 27068 : klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
620 [ + - ]: 27068 : if (drv->bus->p->drivers_autoprobe) {
621 : 27068 : error = driver_attach(drv);
622 [ + - ]: 27068 : if (error)
623 : : goto out_unregister;
624 : : }
625 : 27068 : module_add_driver(drv->owner, drv);
626 : :
627 : 27068 : error = driver_create_file(drv, &driver_attr_uevent);
628 [ - + ]: 27068 : if (error) {
629 : 0 : printk(KERN_ERR "%s: uevent attr (%s) failed\n",
630 : : __func__, drv->name);
631 : : }
632 : 27068 : error = driver_add_groups(drv, bus->drv_groups);
633 [ - + ]: 27068 : if (error) {
634 : : /* How the hell do we get out of this pickle? Give up */
635 : 0 : printk(KERN_ERR "%s: driver_create_groups(%s) failed\n",
636 : : __func__, drv->name);
637 : : }
638 : :
639 [ + + ]: 27068 : if (!drv->suppress_bind_attrs) {
640 : 24644 : error = add_bind_files(drv);
641 [ - + ]: 24644 : if (error) {
642 : : /* Ditto */
643 : 0 : printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
644 : : __func__, drv->name);
645 : : }
646 : : }
647 : :
648 : : return 0;
649 : :
650 : : out_unregister:
651 : 0 : kobject_put(&priv->kobj);
652 : : /* drv->p is freed in driver_release() */
653 : 0 : drv->p = NULL;
654 : : out_put_bus:
655 : : bus_put(bus);
656 : 0 : return error;
657 : : }
658 : :
659 : : /**
660 : : * bus_remove_driver - delete driver from bus's knowledge.
661 : : * @drv: driver.
662 : : *
663 : : * Detach the driver from the devices it controls, and remove
664 : : * it from its bus's list of drivers. Finally, we drop the reference
665 : : * to the bus we took in bus_add_driver().
666 : : */
667 : 0 : void bus_remove_driver(struct device_driver *drv)
668 : : {
669 [ # # ]: 0 : if (!drv->bus)
670 : 0 : return;
671 : :
672 [ # # ]: 0 : if (!drv->suppress_bind_attrs)
673 : 0 : remove_bind_files(drv);
674 : 0 : driver_remove_groups(drv, drv->bus->drv_groups);
675 : 0 : driver_remove_file(drv, &driver_attr_uevent);
676 : 0 : klist_remove(&drv->p->knode_bus);
677 : : pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name);
678 : 0 : driver_detach(drv);
679 : 0 : module_remove_driver(drv);
680 : 0 : kobject_put(&drv->p->kobj);
681 : 0 : bus_put(drv->bus);
682 : : }
683 : :
684 : : /* Helper for bus_rescan_devices's iter */
685 : 0 : static int __must_check bus_rescan_devices_helper(struct device *dev,
686 : : void *data)
687 : : {
688 : : int ret = 0;
689 : :
690 [ # # ]: 0 : if (!dev->driver) {
691 [ # # # # ]: 0 : if (dev->parent && dev->bus->need_parent_lock)
692 : : device_lock(dev->parent);
693 : 0 : ret = device_attach(dev);
694 [ # # # # ]: 0 : if (dev->parent && dev->bus->need_parent_lock)
695 : : device_unlock(dev->parent);
696 : : }
697 : 0 : return ret < 0 ? ret : 0;
698 : : }
699 : :
700 : : /**
701 : : * bus_rescan_devices - rescan devices on the bus for possible drivers
702 : : * @bus: the bus to scan.
703 : : *
704 : : * This function will look for devices on the bus with no driver
705 : : * attached and rescan it against existing drivers to see if it matches
706 : : * any by calling device_attach() for the unbound devices.
707 : : */
708 : 0 : int bus_rescan_devices(struct bus_type *bus)
709 : : {
710 : 0 : return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
711 : : }
712 : : EXPORT_SYMBOL_GPL(bus_rescan_devices);
713 : :
714 : : /**
715 : : * device_reprobe - remove driver for a device and probe for a new driver
716 : : * @dev: the device to reprobe
717 : : *
718 : : * This function detaches the attached driver (if any) for the given
719 : : * device and restarts the driver probing process. It is intended
720 : : * to use if probing criteria changed during a devices lifetime and
721 : : * driver attachment should change accordingly.
722 : : */
723 : 0 : int device_reprobe(struct device *dev)
724 : : {
725 [ # # ]: 0 : if (dev->driver)
726 : 0 : device_driver_detach(dev);
727 : 0 : return bus_rescan_devices_helper(dev, NULL);
728 : : }
729 : : EXPORT_SYMBOL_GPL(device_reprobe);
730 : :
731 : : /**
732 : : * find_bus - locate bus by name.
733 : : * @name: name of bus.
734 : : *
735 : : * Call kset_find_obj() to iterate over list of buses to
736 : : * find a bus by name. Return bus if found.
737 : : *
738 : : * Note that kset_find_obj increments bus' reference count.
739 : : */
740 : : #if 0
741 : : struct bus_type *find_bus(char *name)
742 : : {
743 : : struct kobject *k = kset_find_obj(bus_kset, name);
744 : : return k ? to_bus(k) : NULL;
745 : : }
746 : : #endif /* 0 */
747 : :
748 : : static int bus_add_groups(struct bus_type *bus,
749 : : const struct attribute_group **groups)
750 : : {
751 : 9292 : return sysfs_create_groups(&bus->p->subsys.kobj, groups);
752 : : }
753 : :
754 : : static void bus_remove_groups(struct bus_type *bus,
755 : : const struct attribute_group **groups)
756 : : {
757 : 0 : sysfs_remove_groups(&bus->p->subsys.kobj, groups);
758 : : }
759 : :
760 : 26664 : static void klist_devices_get(struct klist_node *n)
761 : : {
762 : : struct device_private *dev_prv = to_device_private_bus(n);
763 : 26664 : struct device *dev = dev_prv->device;
764 : :
765 : 26664 : get_device(dev);
766 : 26664 : }
767 : :
768 : 404 : static void klist_devices_put(struct klist_node *n)
769 : : {
770 : : struct device_private *dev_prv = to_device_private_bus(n);
771 : 404 : struct device *dev = dev_prv->device;
772 : :
773 : 404 : put_device(dev);
774 : 404 : }
775 : :
776 : 9292 : static ssize_t bus_uevent_store(struct bus_type *bus,
777 : : const char *buf, size_t count)
778 : : {
779 : : int rc;
780 : :
781 : 9292 : rc = kobject_synth_uevent(&bus->p->subsys.kobj, buf, count);
782 [ + - ]: 9292 : return rc ? rc : count;
783 : : }
784 : : /*
785 : : * "open code" the old BUS_ATTR() macro here. We want to use BUS_ATTR_WO()
786 : : * here, but can not use it as earlier in the file we have
787 : : * DEVICE_ATTR_WO(uevent), which would cause a clash with the with the store
788 : : * function name.
789 : : */
790 : : static struct bus_attribute bus_attr_uevent = __ATTR(uevent, S_IWUSR, NULL,
791 : : bus_uevent_store);
792 : :
793 : : /**
794 : : * bus_register - register a driver-core subsystem
795 : : * @bus: bus to register
796 : : *
797 : : * Once we have that, we register the bus with the kobject
798 : : * infrastructure, then register the children subsystems it has:
799 : : * the devices and drivers that belong to the subsystem.
800 : : */
801 : 9292 : int bus_register(struct bus_type *bus)
802 : : {
803 : : int retval;
804 : : struct subsys_private *priv;
805 : 9292 : struct lock_class_key *key = &bus->lock_key;
806 : :
807 : 9292 : priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
808 [ + - ]: 9292 : if (!priv)
809 : : return -ENOMEM;
810 : :
811 : 9292 : priv->bus = bus;
812 : 9292 : bus->p = priv;
813 : :
814 : 9292 : BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
815 : :
816 : 9292 : retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
817 [ + - ]: 9292 : if (retval)
818 : : goto out;
819 : :
820 : 9292 : priv->subsys.kobj.kset = bus_kset;
821 : 9292 : priv->subsys.kobj.ktype = &bus_ktype;
822 : 9292 : priv->drivers_autoprobe = 1;
823 : :
824 : 9292 : retval = kset_register(&priv->subsys);
825 [ + - ]: 9292 : if (retval)
826 : : goto out;
827 : :
828 : 9292 : retval = bus_create_file(bus, &bus_attr_uevent);
829 [ + - ]: 9292 : if (retval)
830 : : goto bus_uevent_fail;
831 : :
832 : 9292 : priv->devices_kset = kset_create_and_add("devices", NULL,
833 : : &priv->subsys.kobj);
834 [ + - ]: 9292 : if (!priv->devices_kset) {
835 : : retval = -ENOMEM;
836 : : goto bus_devices_fail;
837 : : }
838 : :
839 : 9292 : priv->drivers_kset = kset_create_and_add("drivers", NULL,
840 : : &priv->subsys.kobj);
841 [ + - ]: 9292 : if (!priv->drivers_kset) {
842 : : retval = -ENOMEM;
843 : : goto bus_drivers_fail;
844 : : }
845 : :
846 : 9292 : INIT_LIST_HEAD(&priv->interfaces);
847 : 9292 : __mutex_init(&priv->mutex, "subsys mutex", key);
848 : 9292 : klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
849 : 9292 : klist_init(&priv->klist_drivers, NULL, NULL);
850 : :
851 : 9292 : retval = add_probe_files(bus);
852 [ + - ]: 9292 : if (retval)
853 : : goto bus_probe_files_fail;
854 : :
855 : 9292 : retval = bus_add_groups(bus, bus->bus_groups);
856 [ - + ]: 9292 : if (retval)
857 : : goto bus_groups_fail;
858 : :
859 : : pr_debug("bus: '%s': registered\n", bus->name);
860 : : return 0;
861 : :
862 : : bus_groups_fail:
863 : 0 : remove_probe_files(bus);
864 : : bus_probe_files_fail:
865 : 0 : kset_unregister(bus->p->drivers_kset);
866 : : bus_drivers_fail:
867 : 0 : kset_unregister(bus->p->devices_kset);
868 : : bus_devices_fail:
869 : 0 : bus_remove_file(bus, &bus_attr_uevent);
870 : : bus_uevent_fail:
871 : 0 : kset_unregister(&bus->p->subsys);
872 : : out:
873 : 0 : kfree(bus->p);
874 : 0 : bus->p = NULL;
875 : 0 : return retval;
876 : : }
877 : : EXPORT_SYMBOL_GPL(bus_register);
878 : :
879 : : /**
880 : : * bus_unregister - remove a bus from the system
881 : : * @bus: bus.
882 : : *
883 : : * Unregister the child subsystems and the bus itself.
884 : : * Finally, we call bus_put() to release the refcount
885 : : */
886 : 0 : void bus_unregister(struct bus_type *bus)
887 : : {
888 : : pr_debug("bus: '%s': unregistering\n", bus->name);
889 [ # # ]: 0 : if (bus->dev_root)
890 : 0 : device_unregister(bus->dev_root);
891 : 0 : bus_remove_groups(bus, bus->bus_groups);
892 : 0 : remove_probe_files(bus);
893 : 0 : kset_unregister(bus->p->drivers_kset);
894 : 0 : kset_unregister(bus->p->devices_kset);
895 : 0 : bus_remove_file(bus, &bus_attr_uevent);
896 : 0 : kset_unregister(&bus->p->subsys);
897 : 0 : }
898 : : EXPORT_SYMBOL_GPL(bus_unregister);
899 : :
900 : 808 : int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb)
901 : : {
902 : 808 : return blocking_notifier_chain_register(&bus->p->bus_notifier, nb);
903 : : }
904 : : EXPORT_SYMBOL_GPL(bus_register_notifier);
905 : :
906 : 0 : int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb)
907 : : {
908 : 0 : return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb);
909 : : }
910 : : EXPORT_SYMBOL_GPL(bus_unregister_notifier);
911 : :
912 : 0 : struct kset *bus_get_kset(struct bus_type *bus)
913 : : {
914 : 0 : return &bus->p->subsys;
915 : : }
916 : : EXPORT_SYMBOL_GPL(bus_get_kset);
917 : :
918 : 0 : struct klist *bus_get_device_klist(struct bus_type *bus)
919 : : {
920 : 0 : return &bus->p->klist_devices;
921 : : }
922 : : EXPORT_SYMBOL_GPL(bus_get_device_klist);
923 : :
924 : : /*
925 : : * Yes, this forcibly breaks the klist abstraction temporarily. It
926 : : * just wants to sort the klist, not change reference counts and
927 : : * take/drop locks rapidly in the process. It does all this while
928 : : * holding the lock for the list, so objects can't otherwise be
929 : : * added/removed while we're swizzling.
930 : : */
931 : 0 : static void device_insertion_sort_klist(struct device *a, struct list_head *list,
932 : : int (*compare)(const struct device *a,
933 : : const struct device *b))
934 : : {
935 : : struct klist_node *n;
936 : : struct device_private *dev_prv;
937 : : struct device *b;
938 : :
939 [ # # ]: 0 : list_for_each_entry(n, list, n_node) {
940 : : dev_prv = to_device_private_bus(n);
941 : 0 : b = dev_prv->device;
942 [ # # ]: 0 : if (compare(a, b) <= 0) {
943 : 0 : list_move_tail(&a->p->knode_bus.n_node,
944 : 0 : &b->p->knode_bus.n_node);
945 : 0 : return;
946 : : }
947 : : }
948 : 0 : list_move_tail(&a->p->knode_bus.n_node, list);
949 : : }
950 : :
951 : 0 : void bus_sort_breadthfirst(struct bus_type *bus,
952 : : int (*compare)(const struct device *a,
953 : : const struct device *b))
954 : : {
955 : 0 : LIST_HEAD(sorted_devices);
956 : : struct klist_node *n, *tmp;
957 : : struct device_private *dev_prv;
958 : : struct device *dev;
959 : : struct klist *device_klist;
960 : :
961 : : device_klist = bus_get_device_klist(bus);
962 : :
963 : : spin_lock(&device_klist->k_lock);
964 [ # # ]: 0 : list_for_each_entry_safe(n, tmp, &device_klist->k_list, n_node) {
965 : : dev_prv = to_device_private_bus(n);
966 : 0 : dev = dev_prv->device;
967 : 0 : device_insertion_sort_klist(dev, &sorted_devices, compare);
968 : : }
969 : 0 : list_splice(&sorted_devices, &device_klist->k_list);
970 : : spin_unlock(&device_klist->k_lock);
971 : 0 : }
972 : : EXPORT_SYMBOL_GPL(bus_sort_breadthfirst);
973 : :
974 : : /**
975 : : * subsys_dev_iter_init - initialize subsys device iterator
976 : : * @iter: subsys iterator to initialize
977 : : * @subsys: the subsys we wanna iterate over
978 : : * @start: the device to start iterating from, if any
979 : : * @type: device_type of the devices to iterate over, NULL for all
980 : : *
981 : : * Initialize subsys iterator @iter such that it iterates over devices
982 : : * of @subsys. If @start is set, the list iteration will start there,
983 : : * otherwise if it is NULL, the iteration starts at the beginning of
984 : : * the list.
985 : : */
986 : 0 : void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct bus_type *subsys,
987 : : struct device *start, const struct device_type *type)
988 : : {
989 : : struct klist_node *start_knode = NULL;
990 : :
991 [ # # ]: 0 : if (start)
992 : 0 : start_knode = &start->p->knode_bus;
993 : 0 : klist_iter_init_node(&subsys->p->klist_devices, &iter->ki, start_knode);
994 : 0 : iter->type = type;
995 : 0 : }
996 : : EXPORT_SYMBOL_GPL(subsys_dev_iter_init);
997 : :
998 : : /**
999 : : * subsys_dev_iter_next - iterate to the next device
1000 : : * @iter: subsys iterator to proceed
1001 : : *
1002 : : * Proceed @iter to the next device and return it. Returns NULL if
1003 : : * iteration is complete.
1004 : : *
1005 : : * The returned device is referenced and won't be released till
1006 : : * iterator is proceed to the next device or exited. The caller is
1007 : : * free to do whatever it wants to do with the device including
1008 : : * calling back into subsys code.
1009 : : */
1010 : 0 : struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter)
1011 : : {
1012 : : struct klist_node *knode;
1013 : : struct device *dev;
1014 : :
1015 : : for (;;) {
1016 : 0 : knode = klist_next(&iter->ki);
1017 [ # # ]: 0 : if (!knode)
1018 : : return NULL;
1019 : 0 : dev = to_device_private_bus(knode)->device;
1020 [ # # # # ]: 0 : if (!iter->type || iter->type == dev->type)
1021 : 0 : return dev;
1022 : : }
1023 : : }
1024 : : EXPORT_SYMBOL_GPL(subsys_dev_iter_next);
1025 : :
1026 : : /**
1027 : : * subsys_dev_iter_exit - finish iteration
1028 : : * @iter: subsys iterator to finish
1029 : : *
1030 : : * Finish an iteration. Always call this function after iteration is
1031 : : * complete whether the iteration ran till the end or not.
1032 : : */
1033 : 0 : void subsys_dev_iter_exit(struct subsys_dev_iter *iter)
1034 : : {
1035 : 0 : klist_iter_exit(&iter->ki);
1036 : 0 : }
1037 : : EXPORT_SYMBOL_GPL(subsys_dev_iter_exit);
1038 : :
1039 : 0 : int subsys_interface_register(struct subsys_interface *sif)
1040 : : {
1041 : : struct bus_type *subsys;
1042 : : struct subsys_dev_iter iter;
1043 : : struct device *dev;
1044 : :
1045 [ # # # # ]: 0 : if (!sif || !sif->subsys)
1046 : : return -ENODEV;
1047 : :
1048 : : subsys = bus_get(sif->subsys);
1049 [ # # ]: 0 : if (!subsys)
1050 : : return -EINVAL;
1051 : :
1052 : 0 : mutex_lock(&subsys->p->mutex);
1053 : 0 : list_add_tail(&sif->node, &subsys->p->interfaces);
1054 [ # # ]: 0 : if (sif->add_dev) {
1055 : : subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1056 [ # # ]: 0 : while ((dev = subsys_dev_iter_next(&iter)))
1057 : 0 : sif->add_dev(dev, sif);
1058 : : subsys_dev_iter_exit(&iter);
1059 : : }
1060 : 0 : mutex_unlock(&subsys->p->mutex);
1061 : :
1062 : 0 : return 0;
1063 : : }
1064 : : EXPORT_SYMBOL_GPL(subsys_interface_register);
1065 : :
1066 : 0 : void subsys_interface_unregister(struct subsys_interface *sif)
1067 : : {
1068 : : struct bus_type *subsys;
1069 : : struct subsys_dev_iter iter;
1070 : : struct device *dev;
1071 : :
1072 [ # # # # ]: 0 : if (!sif || !sif->subsys)
1073 : 0 : return;
1074 : :
1075 : : subsys = sif->subsys;
1076 : :
1077 : 0 : mutex_lock(&subsys->p->mutex);
1078 : 0 : list_del_init(&sif->node);
1079 [ # # ]: 0 : if (sif->remove_dev) {
1080 : : subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1081 [ # # ]: 0 : while ((dev = subsys_dev_iter_next(&iter)))
1082 : 0 : sif->remove_dev(dev, sif);
1083 : : subsys_dev_iter_exit(&iter);
1084 : : }
1085 : 0 : mutex_unlock(&subsys->p->mutex);
1086 : :
1087 : : bus_put(subsys);
1088 : : }
1089 : : EXPORT_SYMBOL_GPL(subsys_interface_unregister);
1090 : :
1091 : 0 : static void system_root_device_release(struct device *dev)
1092 : : {
1093 : 0 : kfree(dev);
1094 : 0 : }
1095 : :
1096 : 2020 : static int subsys_register(struct bus_type *subsys,
1097 : : const struct attribute_group **groups,
1098 : : struct kobject *parent_of_root)
1099 : : {
1100 : : struct device *dev;
1101 : : int err;
1102 : :
1103 : 2020 : err = bus_register(subsys);
1104 [ + - ]: 2020 : if (err < 0)
1105 : : return err;
1106 : :
1107 : 2020 : dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1108 [ + - ]: 2020 : if (!dev) {
1109 : : err = -ENOMEM;
1110 : : goto err_dev;
1111 : : }
1112 : :
1113 : 2020 : err = dev_set_name(dev, "%s", subsys->name);
1114 [ + - ]: 2020 : if (err < 0)
1115 : : goto err_name;
1116 : :
1117 : 2020 : dev->kobj.parent = parent_of_root;
1118 : 2020 : dev->groups = groups;
1119 : 2020 : dev->release = system_root_device_release;
1120 : :
1121 : 2020 : err = device_register(dev);
1122 [ + - ]: 2020 : if (err < 0)
1123 : : goto err_dev_reg;
1124 : :
1125 : 2020 : subsys->dev_root = dev;
1126 : 2020 : return 0;
1127 : :
1128 : : err_dev_reg:
1129 : 0 : put_device(dev);
1130 : : dev = NULL;
1131 : : err_name:
1132 : 0 : kfree(dev);
1133 : : err_dev:
1134 : 0 : bus_unregister(subsys);
1135 : 0 : return err;
1136 : : }
1137 : :
1138 : : /**
1139 : : * subsys_system_register - register a subsystem at /sys/devices/system/
1140 : : * @subsys: system subsystem
1141 : : * @groups: default attributes for the root device
1142 : : *
1143 : : * All 'system' subsystems have a /sys/devices/system/<name> root device
1144 : : * with the name of the subsystem. The root device can carry subsystem-
1145 : : * wide attributes. All registered devices are below this single root
1146 : : * device and are named after the subsystem with a simple enumeration
1147 : : * number appended. The registered devices are not explicitly named;
1148 : : * only 'id' in the device needs to be set.
1149 : : *
1150 : : * Do not use this interface for anything new, it exists for compatibility
1151 : : * with bad ideas only. New subsystems should use plain subsystems; and
1152 : : * add the subsystem-wide attributes should be added to the subsystem
1153 : : * directory itself and not some create fake root-device placed in
1154 : : * /sys/devices/system/<name>.
1155 : : */
1156 : 1616 : int subsys_system_register(struct bus_type *subsys,
1157 : : const struct attribute_group **groups)
1158 : : {
1159 : 1616 : return subsys_register(subsys, groups, &system_kset->kobj);
1160 : : }
1161 : : EXPORT_SYMBOL_GPL(subsys_system_register);
1162 : :
1163 : : /**
1164 : : * subsys_virtual_register - register a subsystem at /sys/devices/virtual/
1165 : : * @subsys: virtual subsystem
1166 : : * @groups: default attributes for the root device
1167 : : *
1168 : : * All 'virtual' subsystems have a /sys/devices/system/<name> root device
1169 : : * with the name of the subystem. The root device can carry subsystem-wide
1170 : : * attributes. All registered devices are below this single root device.
1171 : : * There's no restriction on device naming. This is for kernel software
1172 : : * constructs which need sysfs interface.
1173 : : */
1174 : 404 : int subsys_virtual_register(struct bus_type *subsys,
1175 : : const struct attribute_group **groups)
1176 : : {
1177 : : struct kobject *virtual_dir;
1178 : :
1179 : 404 : virtual_dir = virtual_device_parent(NULL);
1180 [ + - ]: 404 : if (!virtual_dir)
1181 : : return -ENOMEM;
1182 : :
1183 : 404 : return subsys_register(subsys, groups, virtual_dir);
1184 : : }
1185 : : EXPORT_SYMBOL_GPL(subsys_virtual_register);
1186 : :
1187 : 404 : int __init buses_init(void)
1188 : : {
1189 : 404 : bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
1190 [ + - ]: 404 : if (!bus_kset)
1191 : : return -ENOMEM;
1192 : :
1193 : 404 : system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
1194 [ + - ]: 404 : if (!system_kset)
1195 : : return -ENOMEM;
1196 : :
1197 : 404 : return 0;
1198 : : }
|
