Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * drivers/base/core.c - core driver model code (device registration, etc)
4 : : *
5 : : * Copyright (c) 2002-3 Patrick Mochel
6 : : * Copyright (c) 2002-3 Open Source Development Labs
7 : : * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
8 : : * Copyright (c) 2006 Novell, Inc.
9 : : */
10 : :
11 : : #include <linux/acpi.h>
12 : : #include <linux/cpufreq.h>
13 : : #include <linux/device.h>
14 : : #include <linux/err.h>
15 : : #include <linux/fwnode.h>
16 : : #include <linux/init.h>
17 : : #include <linux/module.h>
18 : : #include <linux/slab.h>
19 : : #include <linux/string.h>
20 : : #include <linux/kdev_t.h>
21 : : #include <linux/notifier.h>
22 : : #include <linux/of.h>
23 : : #include <linux/of_device.h>
24 : : #include <linux/genhd.h>
25 : : #include <linux/mutex.h>
26 : : #include <linux/pm_runtime.h>
27 : : #include <linux/netdevice.h>
28 : : #include <linux/sched/signal.h>
29 : : #include <linux/sysfs.h>
30 : :
31 : : #include "base.h"
32 : : #include "power/power.h"
33 : :
34 : : #ifdef CONFIG_SYSFS_DEPRECATED
35 : : #ifdef CONFIG_SYSFS_DEPRECATED_V2
36 : : long sysfs_deprecated = 1;
37 : : #else
38 : : long sysfs_deprecated = 0;
39 : : #endif
40 : : static int __init sysfs_deprecated_setup(char *arg)
41 : : {
42 : : return kstrtol(arg, 10, &sysfs_deprecated);
43 : : }
44 : : early_param("sysfs.deprecated", sysfs_deprecated_setup);
45 : : #endif
46 : :
47 : : /* Device links support. */
48 : : static LIST_HEAD(wait_for_suppliers);
49 : : static DEFINE_MUTEX(wfs_lock);
50 : : static LIST_HEAD(deferred_sync);
51 : : static unsigned int defer_sync_state_count = 1;
52 : :
53 : : #ifdef CONFIG_SRCU
54 : : static DEFINE_MUTEX(device_links_lock);
55 : : DEFINE_STATIC_SRCU(device_links_srcu);
56 : :
57 : 1344 : static inline void device_links_write_lock(void)
58 : : {
59 : 1344 : mutex_lock(&device_links_lock);
60 : : }
61 : :
62 : 1344 : static inline void device_links_write_unlock(void)
63 : : {
64 : 1344 : mutex_unlock(&device_links_lock);
65 : 0 : }
66 : :
67 : 1764 : int device_links_read_lock(void)
68 : : {
69 : 1764 : return srcu_read_lock(&device_links_srcu);
70 : : }
71 : :
72 : 1764 : void device_links_read_unlock(int idx)
73 : : {
74 : 1764 : srcu_read_unlock(&device_links_srcu, idx);
75 : 1764 : }
76 : :
77 : 0 : int device_links_read_lock_held(void)
78 : : {
79 : 0 : return srcu_read_lock_held(&device_links_srcu);
80 : : }
81 : : #else /* !CONFIG_SRCU */
82 : : static DECLARE_RWSEM(device_links_lock);
83 : :
84 : : static inline void device_links_write_lock(void)
85 : : {
86 : : down_write(&device_links_lock);
87 : : }
88 : :
89 : : static inline void device_links_write_unlock(void)
90 : : {
91 : : up_write(&device_links_lock);
92 : : }
93 : :
94 : : int device_links_read_lock(void)
95 : : {
96 : : down_read(&device_links_lock);
97 : : return 0;
98 : : }
99 : :
100 : : void device_links_read_unlock(int not_used)
101 : : {
102 : : up_read(&device_links_lock);
103 : : }
104 : :
105 : : #ifdef CONFIG_DEBUG_LOCK_ALLOC
106 : : int device_links_read_lock_held(void)
107 : : {
108 : : return lockdep_is_held(&device_links_lock);
109 : : }
110 : : #endif
111 : : #endif /* !CONFIG_SRCU */
112 : :
113 : : /**
114 : : * device_is_dependent - Check if one device depends on another one
115 : : * @dev: Device to check dependencies for.
116 : : * @target: Device to check against.
117 : : *
118 : : * Check if @target depends on @dev or any device dependent on it (its child or
119 : : * its consumer etc). Return 1 if that is the case or 0 otherwise.
120 : : */
121 : 0 : static int device_is_dependent(struct device *dev, void *target)
122 : : {
123 : 0 : struct device_link *link;
124 : 0 : int ret;
125 : :
126 [ # # ]: 0 : if (dev == target)
127 : : return 1;
128 : :
129 : 0 : ret = device_for_each_child(dev, target, device_is_dependent);
130 [ # # ]: 0 : if (ret)
131 : : return ret;
132 : :
133 [ # # ]: 0 : list_for_each_entry(link, &dev->links.consumers, s_node) {
134 [ # # ]: 0 : if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED))
135 : 0 : continue;
136 : :
137 [ # # ]: 0 : if (link->consumer == target)
138 : : return 1;
139 : :
140 : 0 : ret = device_is_dependent(link->consumer, target);
141 [ # # ]: 0 : if (ret)
142 : : break;
143 : : }
144 : : return ret;
145 : : }
146 : :
147 : : static void device_link_init_status(struct device_link *link,
148 : : struct device *consumer,
149 : : struct device *supplier)
150 : : {
151 : : switch (supplier->links.status) {
152 : : case DL_DEV_PROBING:
153 : : switch (consumer->links.status) {
154 : : case DL_DEV_PROBING:
155 : : /*
156 : : * A consumer driver can create a link to a supplier
157 : : * that has not completed its probing yet as long as it
158 : : * knows that the supplier is already functional (for
159 : : * example, it has just acquired some resources from the
160 : : * supplier).
161 : : */
162 : : link->status = DL_STATE_CONSUMER_PROBE;
163 : : break;
164 : : default:
165 : : link->status = DL_STATE_DORMANT;
166 : : break;
167 : : }
168 : : break;
169 : : case DL_DEV_DRIVER_BOUND:
170 : : switch (consumer->links.status) {
171 : : case DL_DEV_PROBING:
172 : : link->status = DL_STATE_CONSUMER_PROBE;
173 : : break;
174 : : case DL_DEV_DRIVER_BOUND:
175 : : link->status = DL_STATE_ACTIVE;
176 : : break;
177 : : default:
178 : : link->status = DL_STATE_AVAILABLE;
179 : : break;
180 : : }
181 : : break;
182 : : case DL_DEV_UNBINDING:
183 : : link->status = DL_STATE_SUPPLIER_UNBIND;
184 : : break;
185 : : default:
186 : : link->status = DL_STATE_DORMANT;
187 : : break;
188 : : }
189 : : }
190 : :
191 : 0 : static int device_reorder_to_tail(struct device *dev, void *not_used)
192 : : {
193 : 0 : struct device_link *link;
194 : :
195 : : /*
196 : : * Devices that have not been registered yet will be put to the ends
197 : : * of the lists during the registration, so skip them here.
198 : : */
199 [ # # ]: 0 : if (device_is_registered(dev))
200 : 0 : devices_kset_move_last(dev);
201 : :
202 [ # # ]: 0 : if (device_pm_initialized(dev))
203 : 0 : device_pm_move_last(dev);
204 : :
205 : 0 : device_for_each_child(dev, NULL, device_reorder_to_tail);
206 [ # # ]: 0 : list_for_each_entry(link, &dev->links.consumers, s_node) {
207 [ # # ]: 0 : if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED))
208 : 0 : continue;
209 : 0 : device_reorder_to_tail(link->consumer, NULL);
210 : : }
211 : :
212 : 0 : return 0;
213 : : }
214 : :
215 : : /**
216 : : * device_pm_move_to_tail - Move set of devices to the end of device lists
217 : : * @dev: Device to move
218 : : *
219 : : * This is a device_reorder_to_tail() wrapper taking the requisite locks.
220 : : *
221 : : * It moves the @dev along with all of its children and all of its consumers
222 : : * to the ends of the device_kset and dpm_list, recursively.
223 : : */
224 : 0 : void device_pm_move_to_tail(struct device *dev)
225 : : {
226 : 0 : int idx;
227 : :
228 : 0 : idx = device_links_read_lock();
229 : 0 : device_pm_lock();
230 : 0 : device_reorder_to_tail(dev, NULL);
231 : 0 : device_pm_unlock();
232 : 0 : device_links_read_unlock(idx);
233 : 0 : }
234 : :
235 : : #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \
236 : : DL_FLAG_AUTOREMOVE_SUPPLIER | \
237 : : DL_FLAG_AUTOPROBE_CONSUMER | \
238 : : DL_FLAG_SYNC_STATE_ONLY)
239 : :
240 : : #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \
241 : : DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE)
242 : :
243 : : /**
244 : : * device_link_add - Create a link between two devices.
245 : : * @consumer: Consumer end of the link.
246 : : * @supplier: Supplier end of the link.
247 : : * @flags: Link flags.
248 : : *
249 : : * The caller is responsible for the proper synchronization of the link creation
250 : : * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the
251 : : * runtime PM framework to take the link into account. Second, if the
252 : : * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will
253 : : * be forced into the active metastate and reference-counted upon the creation
254 : : * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be
255 : : * ignored.
256 : : *
257 : : * If DL_FLAG_STATELESS is set in @flags, the caller of this function is
258 : : * expected to release the link returned by it directly with the help of either
259 : : * device_link_del() or device_link_remove().
260 : : *
261 : : * If that flag is not set, however, the caller of this function is handing the
262 : : * management of the link over to the driver core entirely and its return value
263 : : * can only be used to check whether or not the link is present. In that case,
264 : : * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link
265 : : * flags can be used to indicate to the driver core when the link can be safely
266 : : * deleted. Namely, setting one of them in @flags indicates to the driver core
267 : : * that the link is not going to be used (by the given caller of this function)
268 : : * after unbinding the consumer or supplier driver, respectively, from its
269 : : * device, so the link can be deleted at that point. If none of them is set,
270 : : * the link will be maintained until one of the devices pointed to by it (either
271 : : * the consumer or the supplier) is unregistered.
272 : : *
273 : : * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and
274 : : * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent
275 : : * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can
276 : : * be used to request the driver core to automaticall probe for a consmer
277 : : * driver after successfully binding a driver to the supplier device.
278 : : *
279 : : * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER,
280 : : * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at
281 : : * the same time is invalid and will cause NULL to be returned upfront.
282 : : * However, if a device link between the given @consumer and @supplier pair
283 : : * exists already when this function is called for them, the existing link will
284 : : * be returned regardless of its current type and status (the link's flags may
285 : : * be modified then). The caller of this function is then expected to treat
286 : : * the link as though it has just been created, so (in particular) if
287 : : * DL_FLAG_STATELESS was passed in @flags, the link needs to be released
288 : : * explicitly when not needed any more (as stated above).
289 : : *
290 : : * A side effect of the link creation is re-ordering of dpm_list and the
291 : : * devices_kset list by moving the consumer device and all devices depending
292 : : * on it to the ends of these lists (that does not happen to devices that have
293 : : * not been registered when this function is called).
294 : : *
295 : : * The supplier device is required to be registered when this function is called
296 : : * and NULL will be returned if that is not the case. The consumer device need
297 : : * not be registered, however.
298 : : */
299 : 0 : struct device_link *device_link_add(struct device *consumer,
300 : : struct device *supplier, u32 flags)
301 : : {
302 : 0 : struct device_link *link;
303 : :
304 [ # # # # : 0 : if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS ||
# # ]
305 [ # # # # ]: 0 : (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) ||
306 [ # # ]: 0 : (flags & DL_FLAG_SYNC_STATE_ONLY &&
307 [ # # ]: 0 : flags != DL_FLAG_SYNC_STATE_ONLY) ||
308 [ # # ]: 0 : (flags & DL_FLAG_AUTOPROBE_CONSUMER &&
309 : : flags & (DL_FLAG_AUTOREMOVE_CONSUMER |
310 : : DL_FLAG_AUTOREMOVE_SUPPLIER)))
311 : : return NULL;
312 : :
313 [ # # ]: 0 : if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) {
314 [ # # ]: 0 : if (pm_runtime_get_sync(supplier) < 0) {
315 : 0 : pm_runtime_put_noidle(supplier);
316 : 0 : return NULL;
317 : : }
318 : : }
319 : :
320 [ # # ]: 0 : if (!(flags & DL_FLAG_STATELESS))
321 : 0 : flags |= DL_FLAG_MANAGED;
322 : :
323 : 0 : device_links_write_lock();
324 : 0 : device_pm_lock();
325 : :
326 : : /*
327 : : * If the supplier has not been fully registered yet or there is a
328 : : * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and
329 : : * the supplier already in the graph, return NULL. If the link is a
330 : : * SYNC_STATE_ONLY link, we don't check for reverse dependencies
331 : : * because it only affects sync_state() callbacks.
332 : : */
333 [ # # ]: 0 : if (!device_pm_initialized(supplier)
334 [ # # # # ]: 0 : || (!(flags & DL_FLAG_SYNC_STATE_ONLY) &&
335 : 0 : device_is_dependent(consumer, supplier))) {
336 : 0 : link = NULL;
337 : 0 : goto out;
338 : : }
339 : :
340 : : /*
341 : : * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed
342 : : * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both
343 : : * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER.
344 : : */
345 [ # # ]: 0 : if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
346 : 0 : flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;
347 : :
348 [ # # ]: 0 : list_for_each_entry(link, &supplier->links.consumers, s_node) {
349 [ # # ]: 0 : if (link->consumer != consumer)
350 : 0 : continue;
351 : :
352 [ # # ]: 0 : if (flags & DL_FLAG_PM_RUNTIME) {
353 [ # # ]: 0 : if (!(link->flags & DL_FLAG_PM_RUNTIME)) {
354 : 0 : pm_runtime_new_link(consumer);
355 : 0 : link->flags |= DL_FLAG_PM_RUNTIME;
356 : : }
357 [ # # ]: 0 : if (flags & DL_FLAG_RPM_ACTIVE)
358 : 0 : refcount_inc(&link->rpm_active);
359 : : }
360 : :
361 [ # # ]: 0 : if (flags & DL_FLAG_STATELESS) {
362 : 0 : kref_get(&link->kref);
363 [ # # ]: 0 : if (link->flags & DL_FLAG_SYNC_STATE_ONLY &&
364 : : !(link->flags & DL_FLAG_STATELESS)) {
365 : 0 : link->flags |= DL_FLAG_STATELESS;
366 : 0 : goto reorder;
367 : : } else {
368 : 0 : goto out;
369 : : }
370 : : }
371 : :
372 : : /*
373 : : * If the life time of the link following from the new flags is
374 : : * longer than indicated by the flags of the existing link,
375 : : * update the existing link to stay around longer.
376 : : */
377 [ # # ]: 0 : if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) {
378 [ # # ]: 0 : if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) {
379 : 0 : link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;
380 : 0 : link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER;
381 : : }
382 [ # # ]: 0 : } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) {
383 : 0 : link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER |
384 : : DL_FLAG_AUTOREMOVE_SUPPLIER);
385 : : }
386 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED)) {
387 : 0 : kref_get(&link->kref);
388 : 0 : link->flags |= DL_FLAG_MANAGED;
389 : 0 : device_link_init_status(link, consumer, supplier);
390 : : }
391 [ # # # # ]: 0 : if (link->flags & DL_FLAG_SYNC_STATE_ONLY &&
392 : : !(flags & DL_FLAG_SYNC_STATE_ONLY)) {
393 : 0 : link->flags &= ~DL_FLAG_SYNC_STATE_ONLY;
394 : 0 : goto reorder;
395 : : }
396 : :
397 : 0 : goto out;
398 : : }
399 : :
400 : 0 : link = kzalloc(sizeof(*link), GFP_KERNEL);
401 [ # # ]: 0 : if (!link)
402 : 0 : goto out;
403 : :
404 : 0 : refcount_set(&link->rpm_active, 1);
405 : :
406 [ # # ]: 0 : if (flags & DL_FLAG_PM_RUNTIME) {
407 [ # # ]: 0 : if (flags & DL_FLAG_RPM_ACTIVE)
408 : 0 : refcount_inc(&link->rpm_active);
409 : :
410 : 0 : pm_runtime_new_link(consumer);
411 : : }
412 : :
413 : 0 : get_device(supplier);
414 : 0 : link->supplier = supplier;
415 : 0 : INIT_LIST_HEAD(&link->s_node);
416 : 0 : get_device(consumer);
417 : 0 : link->consumer = consumer;
418 : 0 : INIT_LIST_HEAD(&link->c_node);
419 : 0 : link->flags = flags;
420 : 0 : kref_init(&link->kref);
421 : :
422 : : /* Determine the initial link state. */
423 [ # # ]: 0 : if (flags & DL_FLAG_STATELESS)
424 : 0 : link->status = DL_STATE_NONE;
425 : : else
426 : 0 : device_link_init_status(link, consumer, supplier);
427 : :
428 : : /*
429 : : * Some callers expect the link creation during consumer driver probe to
430 : : * resume the supplier even without DL_FLAG_RPM_ACTIVE.
431 : : */
432 [ # # # # ]: 0 : if (link->status == DL_STATE_CONSUMER_PROBE &&
433 : : flags & DL_FLAG_PM_RUNTIME)
434 : 0 : pm_runtime_resume(supplier);
435 : :
436 [ # # ]: 0 : if (flags & DL_FLAG_SYNC_STATE_ONLY) {
437 : 0 : dev_dbg(consumer,
438 : : "Linked as a sync state only consumer to %s\n",
439 : : dev_name(supplier));
440 : 0 : goto out;
441 : : }
442 : 0 : reorder:
443 : : /*
444 : : * Move the consumer and all of the devices depending on it to the end
445 : : * of dpm_list and the devices_kset list.
446 : : *
447 : : * It is necessary to hold dpm_list locked throughout all that or else
448 : : * we may end up suspending with a wrong ordering of it.
449 : : */
450 : 0 : device_reorder_to_tail(consumer, NULL);
451 : :
452 : 0 : list_add_tail_rcu(&link->s_node, &supplier->links.consumers);
453 : 0 : list_add_tail_rcu(&link->c_node, &consumer->links.suppliers);
454 : :
455 : : dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier));
456 : :
457 : 0 : out:
458 : 0 : device_pm_unlock();
459 : 0 : device_links_write_unlock();
460 : :
461 [ # # # # ]: 0 : if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link)
462 : 0 : pm_runtime_put(supplier);
463 : :
464 : : return link;
465 : : }
466 : : EXPORT_SYMBOL_GPL(device_link_add);
467 : :
468 : : /**
469 : : * device_link_wait_for_supplier - Add device to wait_for_suppliers list
470 : : * @consumer: Consumer device
471 : : *
472 : : * Marks the @consumer device as waiting for suppliers to become available by
473 : : * adding it to the wait_for_suppliers list. The consumer device will never be
474 : : * probed until it's removed from the wait_for_suppliers list.
475 : : *
476 : : * The caller is responsible for adding the links to the supplier devices once
477 : : * they are available and removing the @consumer device from the
478 : : * wait_for_suppliers list once links to all the suppliers have been created.
479 : : *
480 : : * This function is NOT meant to be called from the probe function of the
481 : : * consumer but rather from code that creates/adds the consumer device.
482 : : */
483 : 0 : static void device_link_wait_for_supplier(struct device *consumer,
484 : : bool need_for_probe)
485 : : {
486 : 0 : mutex_lock(&wfs_lock);
487 : 0 : list_add_tail(&consumer->links.needs_suppliers, &wait_for_suppliers);
488 : 0 : consumer->links.need_for_probe = need_for_probe;
489 : 0 : mutex_unlock(&wfs_lock);
490 : 0 : }
491 : :
492 : 0 : static void device_link_wait_for_mandatory_supplier(struct device *consumer)
493 : : {
494 : 0 : device_link_wait_for_supplier(consumer, true);
495 : 0 : }
496 : :
497 : 0 : static void device_link_wait_for_optional_supplier(struct device *consumer)
498 : : {
499 : 0 : device_link_wait_for_supplier(consumer, false);
500 : 0 : }
501 : :
502 : : /**
503 : : * device_link_add_missing_supplier_links - Add links from consumer devices to
504 : : * supplier devices, leaving any
505 : : * consumer with inactive suppliers on
506 : : * the wait_for_suppliers list
507 : : *
508 : : * Loops through all consumers waiting on suppliers and tries to add all their
509 : : * supplier links. If that succeeds, the consumer device is removed from
510 : : * wait_for_suppliers list. Otherwise, they are left in the wait_for_suppliers
511 : : * list. Devices left on the wait_for_suppliers list will not be probed.
512 : : *
513 : : * The fwnode add_links callback is expected to return 0 if it has found and
514 : : * added all the supplier links for the consumer device. It should return an
515 : : * error if it isn't able to do so.
516 : : *
517 : : * The caller of device_link_wait_for_supplier() is expected to call this once
518 : : * it's aware of potential suppliers becoming available.
519 : : */
520 : 8572 : static void device_link_add_missing_supplier_links(void)
521 : : {
522 : 8572 : struct device *dev, *tmp;
523 : :
524 : 8572 : mutex_lock(&wfs_lock);
525 [ - + ]: 8572 : list_for_each_entry_safe(dev, tmp, &wait_for_suppliers,
526 : : links.needs_suppliers)
527 [ # # # # : 0 : if (!fwnode_call_int_op(dev->fwnode, add_links, dev))
# # # # ]
528 : 0 : list_del_init(&dev->links.needs_suppliers);
529 : 8572 : mutex_unlock(&wfs_lock);
530 : 8572 : }
531 : :
532 : 0 : static void device_link_free(struct device_link *link)
533 : : {
534 [ # # ]: 0 : while (refcount_dec_not_one(&link->rpm_active))
535 : 0 : pm_runtime_put(link->supplier);
536 : :
537 : 0 : put_device(link->consumer);
538 : 0 : put_device(link->supplier);
539 : 0 : kfree(link);
540 : 0 : }
541 : :
542 : : #ifdef CONFIG_SRCU
543 : 0 : static void __device_link_free_srcu(struct rcu_head *rhead)
544 : : {
545 : 0 : device_link_free(container_of(rhead, struct device_link, rcu_head));
546 : 0 : }
547 : :
548 : 0 : static void __device_link_del(struct kref *kref)
549 : : {
550 : 0 : struct device_link *link = container_of(kref, struct device_link, kref);
551 : :
552 : 0 : dev_dbg(link->consumer, "Dropping the link to %s\n",
553 : : dev_name(link->supplier));
554 : :
555 [ # # ]: 0 : if (link->flags & DL_FLAG_PM_RUNTIME)
556 : 0 : pm_runtime_drop_link(link->consumer);
557 : :
558 : 0 : list_del_rcu(&link->s_node);
559 : 0 : list_del_rcu(&link->c_node);
560 : 0 : call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu);
561 : 0 : }
562 : : #else /* !CONFIG_SRCU */
563 : : static void __device_link_del(struct kref *kref)
564 : : {
565 : : struct device_link *link = container_of(kref, struct device_link, kref);
566 : :
567 : : dev_info(link->consumer, "Dropping the link to %s\n",
568 : : dev_name(link->supplier));
569 : :
570 : : if (link->flags & DL_FLAG_PM_RUNTIME)
571 : : pm_runtime_drop_link(link->consumer);
572 : :
573 : : list_del(&link->s_node);
574 : : list_del(&link->c_node);
575 : : device_link_free(link);
576 : : }
577 : : #endif /* !CONFIG_SRCU */
578 : :
579 : 0 : static void device_link_put_kref(struct device_link *link)
580 : : {
581 [ # # ]: 0 : if (link->flags & DL_FLAG_STATELESS)
582 : 0 : kref_put(&link->kref, __device_link_del);
583 : : else
584 : 0 : WARN(1, "Unable to drop a managed device link reference\n");
585 : 0 : }
586 : :
587 : : /**
588 : : * device_link_del - Delete a stateless link between two devices.
589 : : * @link: Device link to delete.
590 : : *
591 : : * The caller must ensure proper synchronization of this function with runtime
592 : : * PM. If the link was added multiple times, it needs to be deleted as often.
593 : : * Care is required for hotplugged devices: Their links are purged on removal
594 : : * and calling device_link_del() is then no longer allowed.
595 : : */
596 : 0 : void device_link_del(struct device_link *link)
597 : : {
598 : 0 : device_links_write_lock();
599 : 0 : device_pm_lock();
600 : 0 : device_link_put_kref(link);
601 : 0 : device_pm_unlock();
602 : 0 : device_links_write_unlock();
603 : 0 : }
604 : : EXPORT_SYMBOL_GPL(device_link_del);
605 : :
606 : : /**
607 : : * device_link_remove - Delete a stateless link between two devices.
608 : : * @consumer: Consumer end of the link.
609 : : * @supplier: Supplier end of the link.
610 : : *
611 : : * The caller must ensure proper synchronization of this function with runtime
612 : : * PM.
613 : : */
614 : 0 : void device_link_remove(void *consumer, struct device *supplier)
615 : : {
616 : 0 : struct device_link *link;
617 : :
618 [ # # # # ]: 0 : if (WARN_ON(consumer == supplier))
619 : : return;
620 : :
621 : 0 : device_links_write_lock();
622 : 0 : device_pm_lock();
623 : :
624 [ # # ]: 0 : list_for_each_entry(link, &supplier->links.consumers, s_node) {
625 [ # # ]: 0 : if (link->consumer == consumer) {
626 : 0 : device_link_put_kref(link);
627 : 0 : break;
628 : : }
629 : : }
630 : :
631 : 0 : device_pm_unlock();
632 : 0 : device_links_write_unlock();
633 : : }
634 : : EXPORT_SYMBOL_GPL(device_link_remove);
635 : :
636 : 0 : static void device_links_missing_supplier(struct device *dev)
637 : : {
638 : 0 : struct device_link *link;
639 : :
640 [ # # ]: 0 : list_for_each_entry(link, &dev->links.suppliers, c_node)
641 [ # # ]: 0 : if (link->status == DL_STATE_CONSUMER_PROBE)
642 : 0 : WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
643 : : }
644 : :
645 : : /**
646 : : * device_links_check_suppliers - Check presence of supplier drivers.
647 : : * @dev: Consumer device.
648 : : *
649 : : * Check links from this device to any suppliers. Walk the list of the device's
650 : : * links to suppliers and see if all of them are available. If not, simply
651 : : * return -EPROBE_DEFER.
652 : : *
653 : : * We need to guarantee that the supplier will not go away after the check has
654 : : * been positive here. It only can go away in __device_release_driver() and
655 : : * that function checks the device's links to consumers. This means we need to
656 : : * mark the link as "consumer probe in progress" to make the supplier removal
657 : : * wait for us to complete (or bad things may happen).
658 : : *
659 : : * Links without the DL_FLAG_MANAGED flag set are ignored.
660 : : */
661 : 644 : int device_links_check_suppliers(struct device *dev)
662 : : {
663 : 644 : struct device_link *link;
664 : 644 : int ret = 0;
665 : :
666 : : /*
667 : : * Device waiting for supplier to become available is not allowed to
668 : : * probe.
669 : : */
670 : 644 : mutex_lock(&wfs_lock);
671 [ - + ]: 644 : if (!list_empty(&dev->links.needs_suppliers) &&
672 [ # # ]: 0 : dev->links.need_for_probe) {
673 : 0 : mutex_unlock(&wfs_lock);
674 : 0 : return -EPROBE_DEFER;
675 : : }
676 : 644 : mutex_unlock(&wfs_lock);
677 : :
678 : 644 : device_links_write_lock();
679 : :
680 [ - + ]: 644 : list_for_each_entry(link, &dev->links.suppliers, c_node) {
681 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED) ||
682 : : link->flags & DL_FLAG_SYNC_STATE_ONLY)
683 : 0 : continue;
684 : :
685 [ # # ]: 0 : if (link->status != DL_STATE_AVAILABLE) {
686 : 0 : device_links_missing_supplier(dev);
687 : : ret = -EPROBE_DEFER;
688 : : break;
689 : : }
690 : 0 : WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE);
691 : : }
692 : 644 : dev->links.status = DL_DEV_PROBING;
693 : :
694 : 644 : device_links_write_unlock();
695 : 644 : return ret;
696 : : }
697 : :
698 : : /**
699 : : * __device_links_queue_sync_state - Queue a device for sync_state() callback
700 : : * @dev: Device to call sync_state() on
701 : : * @list: List head to queue the @dev on
702 : : *
703 : : * Queues a device for a sync_state() callback when the device links write lock
704 : : * isn't held. This allows the sync_state() execution flow to use device links
705 : : * APIs. The caller must ensure this function is called with
706 : : * device_links_write_lock() held.
707 : : *
708 : : * This function does a get_device() to make sure the device is not freed while
709 : : * on this list.
710 : : *
711 : : * So the caller must also ensure that device_links_flush_sync_list() is called
712 : : * as soon as the caller releases device_links_write_lock(). This is necessary
713 : : * to make sure the sync_state() is called in a timely fashion and the
714 : : * put_device() is called on this device.
715 : : */
716 : 138 : static void __device_links_queue_sync_state(struct device *dev,
717 : : struct list_head *list)
718 : : {
719 : 138 : struct device_link *link;
720 : :
721 [ + - ]: 138 : if (!dev_has_sync_state(dev))
722 : : return;
723 [ # # ]: 0 : if (dev->state_synced)
724 : : return;
725 : :
726 [ # # ]: 0 : list_for_each_entry(link, &dev->links.consumers, s_node) {
727 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED))
728 : 0 : continue;
729 [ # # ]: 0 : if (link->status != DL_STATE_ACTIVE)
730 : : return;
731 : : }
732 : :
733 : : /*
734 : : * Set the flag here to avoid adding the same device to a list more
735 : : * than once. This can happen if new consumers get added to the device
736 : : * and probed before the list is flushed.
737 : : */
738 : 0 : dev->state_synced = true;
739 : :
740 [ # # # # ]: 0 : if (WARN_ON(!list_empty(&dev->links.defer_sync)))
741 : : return;
742 : :
743 : 0 : get_device(dev);
744 : 0 : list_add_tail(&dev->links.defer_sync, list);
745 : : }
746 : :
747 : : /**
748 : : * device_links_flush_sync_list - Call sync_state() on a list of devices
749 : : * @list: List of devices to call sync_state() on
750 : : * @dont_lock_dev: Device for which lock is already held by the caller
751 : : *
752 : : * Calls sync_state() on all the devices that have been queued for it. This
753 : : * function is used in conjunction with __device_links_queue_sync_state(). The
754 : : * @dont_lock_dev parameter is useful when this function is called from a
755 : : * context where a device lock is already held.
756 : : */
757 : 502 : static void device_links_flush_sync_list(struct list_head *list,
758 : : struct device *dont_lock_dev)
759 : : {
760 : 502 : struct device *dev, *tmp;
761 : :
762 [ - + ]: 502 : list_for_each_entry_safe(dev, tmp, list, links.defer_sync) {
763 [ # # ]: 0 : list_del_init(&dev->links.defer_sync);
764 : :
765 [ # # ]: 0 : if (dev != dont_lock_dev)
766 : 0 : device_lock(dev);
767 : :
768 [ # # ]: 0 : if (dev->bus->sync_state)
769 : 0 : dev->bus->sync_state(dev);
770 [ # # # # ]: 0 : else if (dev->driver && dev->driver->sync_state)
771 : 0 : dev->driver->sync_state(dev);
772 : :
773 [ # # ]: 0 : if (dev != dont_lock_dev)
774 : 0 : device_unlock(dev);
775 : :
776 : 0 : put_device(dev);
777 : : }
778 : 502 : }
779 : :
780 : 0 : void device_links_supplier_sync_state_pause(void)
781 : : {
782 : 0 : device_links_write_lock();
783 : 0 : defer_sync_state_count++;
784 : 0 : device_links_write_unlock();
785 : 0 : }
786 : :
787 : 28 : void device_links_supplier_sync_state_resume(void)
788 : : {
789 : 28 : struct device *dev, *tmp;
790 : 28 : LIST_HEAD(sync_list);
791 : :
792 : 28 : device_links_write_lock();
793 [ - + ]: 28 : if (!defer_sync_state_count) {
794 : 0 : WARN(true, "Unmatched sync_state pause/resume!");
795 : 0 : goto out;
796 : : }
797 : 28 : defer_sync_state_count--;
798 [ - + ]: 28 : if (defer_sync_state_count)
799 : 0 : goto out;
800 : :
801 [ - + ]: 28 : list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) {
802 : : /*
803 : : * Delete from deferred_sync list before queuing it to
804 : : * sync_list because defer_sync is used for both lists.
805 : : */
806 : 0 : list_del_init(&dev->links.defer_sync);
807 : 0 : __device_links_queue_sync_state(dev, &sync_list);
808 : : }
809 : 28 : out:
810 : 28 : device_links_write_unlock();
811 : :
812 : 28 : device_links_flush_sync_list(&sync_list, NULL);
813 : 28 : }
814 : :
815 : 28 : static int sync_state_resume_initcall(void)
816 : : {
817 : 28 : device_links_supplier_sync_state_resume();
818 : 28 : return 0;
819 : : }
820 : : late_initcall(sync_state_resume_initcall);
821 : :
822 : 336 : static void __device_links_supplier_defer_sync(struct device *sup)
823 : : {
824 [ + - ]: 336 : if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup))
825 : 0 : list_add_tail(&sup->links.defer_sync, &deferred_sync);
826 : 336 : }
827 : :
828 : : /**
829 : : * device_links_driver_bound - Update device links after probing its driver.
830 : : * @dev: Device to update the links for.
831 : : *
832 : : * The probe has been successful, so update links from this device to any
833 : : * consumers by changing their status to "available".
834 : : *
835 : : * Also change the status of @dev's links to suppliers to "active".
836 : : *
837 : : * Links without the DL_FLAG_MANAGED flag set are ignored.
838 : : */
839 : 474 : void device_links_driver_bound(struct device *dev)
840 : : {
841 : 474 : struct device_link *link;
842 : 474 : LIST_HEAD(sync_list);
843 : :
844 : : /*
845 : : * If a device probes successfully, it's expected to have created all
846 : : * the device links it needs to or make new device links as it needs
847 : : * them. So, it no longer needs to wait on any suppliers.
848 : : */
849 : 474 : mutex_lock(&wfs_lock);
850 : 474 : list_del_init(&dev->links.needs_suppliers);
851 : 474 : mutex_unlock(&wfs_lock);
852 : :
853 : 474 : device_links_write_lock();
854 : :
855 [ - + ]: 474 : list_for_each_entry(link, &dev->links.consumers, s_node) {
856 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED))
857 : 0 : continue;
858 : :
859 : : /*
860 : : * Links created during consumer probe may be in the "consumer
861 : : * probe" state to start with if the supplier is still probing
862 : : * when they are created and they may become "active" if the
863 : : * consumer probe returns first. Skip them here.
864 : : */
865 [ # # ]: 0 : if (link->status == DL_STATE_CONSUMER_PROBE ||
866 : : link->status == DL_STATE_ACTIVE)
867 : 0 : continue;
868 : :
869 [ # # ]: 0 : WARN_ON(link->status != DL_STATE_DORMANT);
870 [ # # ]: 0 : WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
871 : :
872 [ # # ]: 0 : if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER)
873 : 0 : driver_deferred_probe_add(link->consumer);
874 : : }
875 : :
876 [ + + ]: 474 : if (defer_sync_state_count)
877 : 336 : __device_links_supplier_defer_sync(dev);
878 : : else
879 : 138 : __device_links_queue_sync_state(dev, &sync_list);
880 : :
881 [ - + ]: 474 : list_for_each_entry(link, &dev->links.suppliers, c_node) {
882 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED))
883 : 0 : continue;
884 : :
885 [ # # ]: 0 : WARN_ON(link->status != DL_STATE_CONSUMER_PROBE);
886 [ # # ]: 0 : WRITE_ONCE(link->status, DL_STATE_ACTIVE);
887 : :
888 [ # # ]: 0 : if (defer_sync_state_count)
889 : 0 : __device_links_supplier_defer_sync(link->supplier);
890 : : else
891 : 0 : __device_links_queue_sync_state(link->supplier,
892 : : &sync_list);
893 : : }
894 : :
895 : 474 : dev->links.status = DL_DEV_DRIVER_BOUND;
896 : :
897 : 474 : device_links_write_unlock();
898 : :
899 : 474 : device_links_flush_sync_list(&sync_list, dev);
900 : 474 : }
901 : :
902 : 0 : static void device_link_drop_managed(struct device_link *link)
903 : : {
904 : 0 : link->flags &= ~DL_FLAG_MANAGED;
905 : 0 : WRITE_ONCE(link->status, DL_STATE_NONE);
906 : 0 : kref_put(&link->kref, __device_link_del);
907 : 0 : }
908 : :
909 : : /**
910 : : * __device_links_no_driver - Update links of a device without a driver.
911 : : * @dev: Device without a drvier.
912 : : *
913 : : * Delete all non-persistent links from this device to any suppliers.
914 : : *
915 : : * Persistent links stay around, but their status is changed to "available",
916 : : * unless they already are in the "supplier unbind in progress" state in which
917 : : * case they need not be updated.
918 : : *
919 : : * Links without the DL_FLAG_MANAGED flag set are ignored.
920 : : */
921 : 170 : static void __device_links_no_driver(struct device *dev)
922 : : {
923 : 170 : struct device_link *link, *ln;
924 : :
925 [ - + ]: 170 : list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
926 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED))
927 : 0 : continue;
928 : :
929 [ # # ]: 0 : if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER)
930 : 0 : device_link_drop_managed(link);
931 [ # # ]: 0 : else if (link->status == DL_STATE_CONSUMER_PROBE ||
932 : : link->status == DL_STATE_ACTIVE)
933 : 0 : WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
934 : : }
935 : :
936 : 170 : dev->links.status = DL_DEV_NO_DRIVER;
937 : 170 : }
938 : :
939 : : /**
940 : : * device_links_no_driver - Update links after failing driver probe.
941 : : * @dev: Device whose driver has just failed to probe.
942 : : *
943 : : * Clean up leftover links to consumers for @dev and invoke
944 : : * %__device_links_no_driver() to update links to suppliers for it as
945 : : * appropriate.
946 : : *
947 : : * Links without the DL_FLAG_MANAGED flag set are ignored.
948 : : */
949 : 170 : void device_links_no_driver(struct device *dev)
950 : : {
951 : 170 : struct device_link *link;
952 : :
953 : 170 : device_links_write_lock();
954 : :
955 [ - + ]: 170 : list_for_each_entry(link, &dev->links.consumers, s_node) {
956 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED))
957 : 0 : continue;
958 : :
959 : : /*
960 : : * The probe has failed, so if the status of the link is
961 : : * "consumer probe" or "active", it must have been added by
962 : : * a probing consumer while this device was still probing.
963 : : * Change its state to "dormant", as it represents a valid
964 : : * relationship, but it is not functionally meaningful.
965 : : */
966 [ # # ]: 0 : if (link->status == DL_STATE_CONSUMER_PROBE ||
967 : : link->status == DL_STATE_ACTIVE)
968 : 0 : WRITE_ONCE(link->status, DL_STATE_DORMANT);
969 : : }
970 : :
971 : 170 : __device_links_no_driver(dev);
972 : :
973 : 170 : device_links_write_unlock();
974 : 170 : }
975 : :
976 : : /**
977 : : * device_links_driver_cleanup - Update links after driver removal.
978 : : * @dev: Device whose driver has just gone away.
979 : : *
980 : : * Update links to consumers for @dev by changing their status to "dormant" and
981 : : * invoke %__device_links_no_driver() to update links to suppliers for it as
982 : : * appropriate.
983 : : *
984 : : * Links without the DL_FLAG_MANAGED flag set are ignored.
985 : : */
986 : 0 : void device_links_driver_cleanup(struct device *dev)
987 : : {
988 : 0 : struct device_link *link, *ln;
989 : :
990 : 0 : device_links_write_lock();
991 : :
992 [ # # ]: 0 : list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) {
993 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED))
994 : 0 : continue;
995 : :
996 [ # # ]: 0 : WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER);
997 [ # # ]: 0 : WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND);
998 : :
999 : : /*
1000 : : * autoremove the links between this @dev and its consumer
1001 : : * devices that are not active, i.e. where the link state
1002 : : * has moved to DL_STATE_SUPPLIER_UNBIND.
1003 : : */
1004 [ # # # # ]: 0 : if (link->status == DL_STATE_SUPPLIER_UNBIND &&
1005 : : link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
1006 : 0 : device_link_drop_managed(link);
1007 : :
1008 : 0 : WRITE_ONCE(link->status, DL_STATE_DORMANT);
1009 : : }
1010 : :
1011 : 0 : list_del_init(&dev->links.defer_sync);
1012 : 0 : __device_links_no_driver(dev);
1013 : :
1014 : 0 : device_links_write_unlock();
1015 : 0 : }
1016 : :
1017 : : /**
1018 : : * device_links_busy - Check if there are any busy links to consumers.
1019 : : * @dev: Device to check.
1020 : : *
1021 : : * Check each consumer of the device and return 'true' if its link's status
1022 : : * is one of "consumer probe" or "active" (meaning that the given consumer is
1023 : : * probing right now or its driver is present). Otherwise, change the link
1024 : : * state to "supplier unbind" to prevent the consumer from being probed
1025 : : * successfully going forward.
1026 : : *
1027 : : * Return 'false' if there are no probing or active consumers.
1028 : : *
1029 : : * Links without the DL_FLAG_MANAGED flag set are ignored.
1030 : : */
1031 : 0 : bool device_links_busy(struct device *dev)
1032 : : {
1033 : 0 : struct device_link *link;
1034 : 0 : bool ret = false;
1035 : :
1036 : 0 : device_links_write_lock();
1037 : :
1038 [ # # ]: 0 : list_for_each_entry(link, &dev->links.consumers, s_node) {
1039 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED))
1040 : 0 : continue;
1041 : :
1042 : 0 : if (link->status == DL_STATE_CONSUMER_PROBE
1043 [ # # ]: 0 : || link->status == DL_STATE_ACTIVE) {
1044 : : ret = true;
1045 : : break;
1046 : : }
1047 : 0 : WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
1048 : : }
1049 : :
1050 : 0 : dev->links.status = DL_DEV_UNBINDING;
1051 : :
1052 : 0 : device_links_write_unlock();
1053 : 0 : return ret;
1054 : : }
1055 : :
1056 : : /**
1057 : : * device_links_unbind_consumers - Force unbind consumers of the given device.
1058 : : * @dev: Device to unbind the consumers of.
1059 : : *
1060 : : * Walk the list of links to consumers for @dev and if any of them is in the
1061 : : * "consumer probe" state, wait for all device probes in progress to complete
1062 : : * and start over.
1063 : : *
1064 : : * If that's not the case, change the status of the link to "supplier unbind"
1065 : : * and check if the link was in the "active" state. If so, force the consumer
1066 : : * driver to unbind and start over (the consumer will not re-probe as we have
1067 : : * changed the state of the link already).
1068 : : *
1069 : : * Links without the DL_FLAG_MANAGED flag set are ignored.
1070 : : */
1071 : 0 : void device_links_unbind_consumers(struct device *dev)
1072 : : {
1073 : 0 : struct device_link *link;
1074 : :
1075 : : start:
1076 : 0 : device_links_write_lock();
1077 : :
1078 [ # # ]: 0 : list_for_each_entry(link, &dev->links.consumers, s_node) {
1079 : 0 : enum device_link_state status;
1080 : :
1081 [ # # ]: 0 : if (!(link->flags & DL_FLAG_MANAGED) ||
1082 : : link->flags & DL_FLAG_SYNC_STATE_ONLY)
1083 : 0 : continue;
1084 : :
1085 : 0 : status = link->status;
1086 [ # # ]: 0 : if (status == DL_STATE_CONSUMER_PROBE) {
1087 : 0 : device_links_write_unlock();
1088 : :
1089 : 0 : wait_for_device_probe();
1090 : 0 : goto start;
1091 : : }
1092 [ # # ]: 0 : WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
1093 [ # # ]: 0 : if (status == DL_STATE_ACTIVE) {
1094 : 0 : struct device *consumer = link->consumer;
1095 : :
1096 : 0 : get_device(consumer);
1097 : :
1098 : 0 : device_links_write_unlock();
1099 : :
1100 : 0 : device_release_driver_internal(consumer, NULL,
1101 : : consumer->parent);
1102 : 0 : put_device(consumer);
1103 : 0 : goto start;
1104 : : }
1105 : : }
1106 : :
1107 : 0 : device_links_write_unlock();
1108 : 0 : }
1109 : :
1110 : : /**
1111 : : * device_links_purge - Delete existing links to other devices.
1112 : : * @dev: Target device.
1113 : : */
1114 : 28 : static void device_links_purge(struct device *dev)
1115 : : {
1116 : 28 : struct device_link *link, *ln;
1117 : :
1118 : 28 : mutex_lock(&wfs_lock);
1119 : 28 : list_del(&dev->links.needs_suppliers);
1120 : 28 : mutex_unlock(&wfs_lock);
1121 : :
1122 : : /*
1123 : : * Delete all of the remaining links from this device to any other
1124 : : * devices (either consumers or suppliers).
1125 : : */
1126 : 28 : device_links_write_lock();
1127 : :
1128 [ - + ]: 28 : list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
1129 [ # # ]: 0 : WARN_ON(link->status == DL_STATE_ACTIVE);
1130 : 0 : __device_link_del(&link->kref);
1131 : : }
1132 : :
1133 [ - + ]: 28 : list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) {
1134 [ # # ]: 0 : WARN_ON(link->status != DL_STATE_DORMANT &&
1135 : : link->status != DL_STATE_NONE);
1136 : 0 : __device_link_del(&link->kref);
1137 : : }
1138 : :
1139 : 28 : device_links_write_unlock();
1140 : 28 : }
1141 : :
1142 : : /* Device links support end. */
1143 : :
1144 : : int (*platform_notify)(struct device *dev) = NULL;
1145 : : int (*platform_notify_remove)(struct device *dev) = NULL;
1146 : : static struct kobject *dev_kobj;
1147 : : struct kobject *sysfs_dev_char_kobj;
1148 : : struct kobject *sysfs_dev_block_kobj;
1149 : :
1150 : : static DEFINE_MUTEX(device_hotplug_lock);
1151 : :
1152 : 0 : void lock_device_hotplug(void)
1153 : : {
1154 : 0 : mutex_lock(&device_hotplug_lock);
1155 : 0 : }
1156 : :
1157 : 0 : void unlock_device_hotplug(void)
1158 : : {
1159 : 0 : mutex_unlock(&device_hotplug_lock);
1160 : 0 : }
1161 : :
1162 : 0 : int lock_device_hotplug_sysfs(void)
1163 : : {
1164 [ # # ]: 0 : if (mutex_trylock(&device_hotplug_lock))
1165 : : return 0;
1166 : :
1167 : : /* Avoid busy looping (5 ms of sleep should do). */
1168 : 0 : msleep(5);
1169 : 0 : return restart_syscall();
1170 : : }
1171 : :
1172 : : #ifdef CONFIG_BLOCK
1173 : 1428 : static inline int device_is_not_partition(struct device *dev)
1174 : : {
1175 : 1428 : return !(dev->type == &part_type);
1176 : : }
1177 : : #else
1178 : : static inline int device_is_not_partition(struct device *dev)
1179 : : {
1180 : : return 1;
1181 : : }
1182 : : #endif
1183 : :
1184 : : static int
1185 : 8600 : device_platform_notify(struct device *dev, enum kobject_action action)
1186 : : {
1187 : 8600 : int ret;
1188 : :
1189 : 8600 : ret = acpi_platform_notify(dev, action);
1190 [ + - ]: 8600 : if (ret)
1191 : : return ret;
1192 : :
1193 : 8600 : ret = software_node_notify(dev, action);
1194 [ + - ]: 8600 : if (ret)
1195 : : return ret;
1196 : :
1197 [ - + - - ]: 8600 : if (platform_notify && action == KOBJ_ADD)
1198 : 0 : platform_notify(dev);
1199 [ - + - - ]: 8600 : else if (platform_notify_remove && action == KOBJ_REMOVE)
1200 : 0 : platform_notify_remove(dev);
1201 : : return 0;
1202 : : }
1203 : :
1204 : : /**
1205 : : * dev_driver_string - Return a device's driver name, if at all possible
1206 : : * @dev: struct device to get the name of
1207 : : *
1208 : : * Will return the device's driver's name if it is bound to a device. If
1209 : : * the device is not bound to a driver, it will return the name of the bus
1210 : : * it is attached to. If it is not attached to a bus either, an empty
1211 : : * string will be returned.
1212 : : */
1213 : 2292 : const char *dev_driver_string(const struct device *dev)
1214 : : {
1215 : 2292 : struct device_driver *drv;
1216 : :
1217 : : /* dev->driver can change to NULL underneath us because of unbinding,
1218 : : * so be careful about accessing it. dev->bus and dev->class should
1219 : : * never change once they are set, so they don't need special care.
1220 : : */
1221 [ + + - - : 2292 : drv = READ_ONCE(dev->driver);
+ - ]
1222 [ + + - - : 2292 : return drv ? drv->name :
+ - ]
1223 [ + + - - : 1456 : (dev->bus ? dev->bus->name :
- - ]
1224 [ + - - - : 252 : (dev->class ? dev->class->name : ""));
- - ]
1225 : : }
1226 : : EXPORT_SYMBOL(dev_driver_string);
1227 : :
1228 : : #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
1229 : :
1230 : 25921 : static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
1231 : : char *buf)
1232 : : {
1233 : 25921 : struct device_attribute *dev_attr = to_dev_attr(attr);
1234 [ + - ]: 25921 : struct device *dev = kobj_to_dev(kobj);
1235 : 25921 : ssize_t ret = -EIO;
1236 : :
1237 [ + - ]: 25921 : if (dev_attr->show)
1238 : 25921 : ret = dev_attr->show(dev, dev_attr, buf);
1239 [ - + ]: 25921 : if (ret >= (ssize_t)PAGE_SIZE) {
1240 : 0 : printk("dev_attr_show: %pS returned bad count\n",
1241 : : dev_attr->show);
1242 : : }
1243 : 25921 : return ret;
1244 : : }
1245 : :
1246 : 7868 : static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
1247 : : const char *buf, size_t count)
1248 : : {
1249 : 7868 : struct device_attribute *dev_attr = to_dev_attr(attr);
1250 [ + - ]: 7868 : struct device *dev = kobj_to_dev(kobj);
1251 : 7868 : ssize_t ret = -EIO;
1252 : :
1253 [ + - ]: 7868 : if (dev_attr->store)
1254 : 7868 : ret = dev_attr->store(dev, dev_attr, buf, count);
1255 : 7868 : return ret;
1256 : : }
1257 : :
1258 : : static const struct sysfs_ops dev_sysfs_ops = {
1259 : : .show = dev_attr_show,
1260 : : .store = dev_attr_store,
1261 : : };
1262 : :
1263 : : #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)
1264 : :
1265 : 0 : ssize_t device_store_ulong(struct device *dev,
1266 : : struct device_attribute *attr,
1267 : : const char *buf, size_t size)
1268 : : {
1269 : 0 : struct dev_ext_attribute *ea = to_ext_attr(attr);
1270 : 0 : int ret;
1271 : 0 : unsigned long new;
1272 : :
1273 : 0 : ret = kstrtoul(buf, 0, &new);
1274 [ # # ]: 0 : if (ret)
1275 : 0 : return ret;
1276 : 0 : *(unsigned long *)(ea->var) = new;
1277 : : /* Always return full write size even if we didn't consume all */
1278 : 0 : return size;
1279 : : }
1280 : : EXPORT_SYMBOL_GPL(device_store_ulong);
1281 : :
1282 : 0 : ssize_t device_show_ulong(struct device *dev,
1283 : : struct device_attribute *attr,
1284 : : char *buf)
1285 : : {
1286 : 0 : struct dev_ext_attribute *ea = to_ext_attr(attr);
1287 : 0 : return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
1288 : : }
1289 : : EXPORT_SYMBOL_GPL(device_show_ulong);
1290 : :
1291 : 0 : ssize_t device_store_int(struct device *dev,
1292 : : struct device_attribute *attr,
1293 : : const char *buf, size_t size)
1294 : : {
1295 : 0 : struct dev_ext_attribute *ea = to_ext_attr(attr);
1296 : 0 : int ret;
1297 : 0 : long new;
1298 : :
1299 : 0 : ret = kstrtol(buf, 0, &new);
1300 [ # # ]: 0 : if (ret)
1301 : 0 : return ret;
1302 : :
1303 [ # # ]: 0 : if (new > INT_MAX || new < INT_MIN)
1304 : : return -EINVAL;
1305 : 0 : *(int *)(ea->var) = new;
1306 : : /* Always return full write size even if we didn't consume all */
1307 : 0 : return size;
1308 : : }
1309 : : EXPORT_SYMBOL_GPL(device_store_int);
1310 : :
1311 : 0 : ssize_t device_show_int(struct device *dev,
1312 : : struct device_attribute *attr,
1313 : : char *buf)
1314 : : {
1315 : 0 : struct dev_ext_attribute *ea = to_ext_attr(attr);
1316 : :
1317 : 0 : return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
1318 : : }
1319 : : EXPORT_SYMBOL_GPL(device_show_int);
1320 : :
1321 : 0 : ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
1322 : : const char *buf, size_t size)
1323 : : {
1324 : 0 : struct dev_ext_attribute *ea = to_ext_attr(attr);
1325 : :
1326 [ # # ]: 0 : if (strtobool(buf, ea->var) < 0)
1327 : : return -EINVAL;
1328 : :
1329 : 0 : return size;
1330 : : }
1331 : : EXPORT_SYMBOL_GPL(device_store_bool);
1332 : :
1333 : 0 : ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
1334 : : char *buf)
1335 : : {
1336 : 0 : struct dev_ext_attribute *ea = to_ext_attr(attr);
1337 : :
1338 : 0 : return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var));
1339 : : }
1340 : : EXPORT_SYMBOL_GPL(device_show_bool);
1341 : :
1342 : : /**
1343 : : * device_release - free device structure.
1344 : : * @kobj: device's kobject.
1345 : : *
1346 : : * This is called once the reference count for the object
1347 : : * reaches 0. We forward the call to the device's release
1348 : : * method, which should handle actually freeing the structure.
1349 : : */
1350 : 62 : static void device_release(struct kobject *kobj)
1351 : : {
1352 : 62 : struct device *dev = kobj_to_dev(kobj);
1353 : 62 : struct device_private *p = dev->p;
1354 : :
1355 : : /*
1356 : : * Some platform devices are driven without driver attached
1357 : : * and managed resources may have been acquired. Make sure
1358 : : * all resources are released.
1359 : : *
1360 : : * Drivers still can add resources into device after device
1361 : : * is deleted but alive, so release devres here to avoid
1362 : : * possible memory leak.
1363 : : */
1364 : 62 : devres_release_all(dev);
1365 : :
1366 [ + + ]: 62 : if (dev->release)
1367 : 28 : dev->release(dev);
1368 [ + + + - ]: 34 : else if (dev->type && dev->type->release)
1369 : 28 : dev->type->release(dev);
1370 [ + - + - ]: 6 : else if (dev->class && dev->class->dev_release)
1371 : 6 : dev->class->dev_release(dev);
1372 : : else
1373 [ # # ]: 0 : WARN(1, KERN_ERR "Device '%s' does not have a release() function, it is broken and must be fixed. See Documentation/kobject.txt.\n",
1374 : : dev_name(dev));
1375 : 62 : kfree(p);
1376 : 62 : }
1377 : :
1378 : 168 : static const void *device_namespace(struct kobject *kobj)
1379 : : {
1380 [ + - ]: 168 : struct device *dev = kobj_to_dev(kobj);
1381 : 168 : const void *ns = NULL;
1382 : :
1383 [ + - + - ]: 168 : if (dev->class && dev->class->ns_type)
1384 : 168 : ns = dev->class->namespace(dev);
1385 : :
1386 : 168 : return ns;
1387 : : }
1388 : :
1389 : 53248 : static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
1390 : : {
1391 [ + + ]: 53248 : struct device *dev = kobj_to_dev(kobj);
1392 : :
1393 [ + + + + ]: 53248 : if (dev->class && dev->class->get_ownership)
1394 : 392 : dev->class->get_ownership(dev, uid, gid);
1395 : 53248 : }
1396 : :
1397 : : static struct kobj_type device_ktype = {
1398 : : .release = device_release,
1399 : : .sysfs_ops = &dev_sysfs_ops,
1400 : : .namespace = device_namespace,
1401 : : .get_ownership = device_get_ownership,
1402 : : };
1403 : :
1404 : :
1405 : 41381 : static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
1406 : : {
1407 [ + + ]: 41381 : struct kobj_type *ktype = get_ktype(kobj);
1408 : :
1409 [ + + ]: 41381 : if (ktype == &device_ktype) {
1410 [ + + ]: 40345 : struct device *dev = kobj_to_dev(kobj);
1411 [ + + ]: 40345 : if (dev->bus)
1412 : : return 1;
1413 [ + + ]: 22097 : if (dev->class)
1414 : 20195 : return 1;
1415 : : }
1416 : : return 0;
1417 : : }
1418 : :
1419 : 16522 : static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
1420 : : {
1421 [ + + ]: 16522 : struct device *dev = kobj_to_dev(kobj);
1422 : :
1423 [ + + ]: 16522 : if (dev->bus)
1424 : 6662 : return dev->bus->name;
1425 [ + - ]: 9860 : if (dev->class)
1426 : 9860 : return dev->class->name;
1427 : : return NULL;
1428 : : }
1429 : :
1430 : 38443 : static int dev_uevent(struct kset *kset, struct kobject *kobj,
1431 : : struct kobj_uevent_env *env)
1432 : : {
1433 [ + + ]: 38443 : struct device *dev = kobj_to_dev(kobj);
1434 : 38443 : int retval = 0;
1435 : :
1436 : : /* add device node properties if present */
1437 [ + + ]: 38443 : if (MAJOR(dev->devt)) {
1438 : 14027 : const char *tmp;
1439 : 14027 : const char *name;
1440 : 14027 : umode_t mode = 0;
1441 : 14027 : kuid_t uid = GLOBAL_ROOT_UID;
1442 : 14027 : kgid_t gid = GLOBAL_ROOT_GID;
1443 : :
1444 : 14027 : add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
1445 : 14027 : add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
1446 : 14027 : name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
1447 [ + - ]: 14027 : if (name) {
1448 : 14027 : add_uevent_var(env, "DEVNAME=%s", name);
1449 [ + + ]: 14027 : if (mode)
1450 : 1008 : add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
1451 [ - + ]: 14027 : if (!uid_eq(uid, GLOBAL_ROOT_UID))
1452 : 0 : add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid));
1453 [ - + ]: 14027 : if (!gid_eq(gid, GLOBAL_ROOT_GID))
1454 : 0 : add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid));
1455 : 14027 : kfree(tmp);
1456 : : }
1457 : : }
1458 : :
1459 [ + + + + ]: 38443 : if (dev->type && dev->type->name)
1460 : 4059 : add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
1461 : :
1462 [ + + ]: 38443 : if (dev->driver)
1463 : 3828 : add_uevent_var(env, "DRIVER=%s", dev->driver->name);
1464 : :
1465 : : /* Add common DT information about the device */
1466 [ + + ]: 38443 : of_device_uevent(dev, env);
1467 : :
1468 : : /* have the bus specific function add its stuff */
1469 [ + + + + ]: 38443 : if (dev->bus && dev->bus->uevent) {
1470 : 14972 : retval = dev->bus->uevent(dev, env);
1471 : 14972 : if (retval)
1472 : : pr_debug("device: '%s': %s: bus uevent() returned %d\n",
1473 : : dev_name(dev), __func__, retval);
1474 : : }
1475 : :
1476 : : /* have the class specific function add its stuff */
1477 [ + + + + ]: 38443 : if (dev->class && dev->class->dev_uevent) {
1478 : 336 : retval = dev->class->dev_uevent(dev, env);
1479 : 336 : if (retval)
1480 : : pr_debug("device: '%s': %s: class uevent() "
1481 : : "returned %d\n", dev_name(dev),
1482 : : __func__, retval);
1483 : : }
1484 : :
1485 : : /* have the device type specific function add its stuff */
1486 [ + + + + ]: 38443 : if (dev->type && dev->type->uevent) {
1487 : 504 : retval = dev->type->uevent(dev, env);
1488 : 504 : if (retval)
1489 : : pr_debug("device: '%s': %s: dev_type uevent() "
1490 : : "returned %d\n", dev_name(dev),
1491 : : __func__, retval);
1492 : : }
1493 : :
1494 : 38443 : return retval;
1495 : : }
1496 : :
1497 : : static const struct kset_uevent_ops device_uevent_ops = {
1498 : : .filter = dev_uevent_filter,
1499 : : .name = dev_uevent_name,
1500 : : .uevent = dev_uevent,
1501 : : };
1502 : :
1503 : 23151 : static ssize_t uevent_show(struct device *dev, struct device_attribute *attr,
1504 : : char *buf)
1505 : : {
1506 : 23151 : struct kobject *top_kobj;
1507 : 23151 : struct kset *kset;
1508 : 23151 : struct kobj_uevent_env *env = NULL;
1509 : 23151 : int i;
1510 : 23151 : size_t count = 0;
1511 : 23151 : int retval;
1512 : :
1513 : : /* search the kset, the device belongs to */
1514 : 23151 : top_kobj = &dev->kobj;
1515 [ - + - - ]: 23151 : while (!top_kobj->kset && top_kobj->parent)
1516 : : top_kobj = top_kobj->parent;
1517 [ - + ]: 23151 : if (!top_kobj->kset)
1518 : 0 : goto out;
1519 : :
1520 : 23151 : kset = top_kobj->kset;
1521 [ + - - + ]: 23151 : if (!kset->uevent_ops || !kset->uevent_ops->uevent)
1522 : 0 : goto out;
1523 : :
1524 : : /* respect filter */
1525 [ + - ]: 23151 : if (kset->uevent_ops && kset->uevent_ops->filter)
1526 [ + + ]: 23151 : if (!kset->uevent_ops->filter(kset, &dev->kobj))
1527 : 1230 : goto out;
1528 : :
1529 : 21921 : env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
1530 [ + - ]: 21921 : if (!env)
1531 : : return -ENOMEM;
1532 : :
1533 : : /* let the kset specific function add its keys */
1534 : 21921 : retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
1535 [ - + ]: 21921 : if (retval)
1536 : 0 : goto out;
1537 : :
1538 : : /* copy keys to file */
1539 [ + + ]: 65785 : for (i = 0; i < env->envp_idx; i++)
1540 : 43864 : count += sprintf(&buf[count], "%s\n", env->envp[i]);
1541 : 21921 : out:
1542 : 23151 : kfree(env);
1543 : 23151 : return count;
1544 : : }
1545 : :
1546 : 7868 : static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,
1547 : : const char *buf, size_t count)
1548 : : {
1549 : 7868 : int rc;
1550 : :
1551 : 7868 : rc = kobject_synth_uevent(&dev->kobj, buf, count);
1552 : :
1553 [ - + ]: 7868 : if (rc) {
1554 : 0 : dev_err(dev, "uevent: failed to send synthetic uevent\n");
1555 : 0 : return rc;
1556 : : }
1557 : :
1558 : 7868 : return count;
1559 : : }
1560 : : static DEVICE_ATTR_RW(uevent);
1561 : :
1562 : 0 : static ssize_t online_show(struct device *dev, struct device_attribute *attr,
1563 : : char *buf)
1564 : : {
1565 : 0 : bool val;
1566 : :
1567 : 0 : device_lock(dev);
1568 : 0 : val = !dev->offline;
1569 : 0 : device_unlock(dev);
1570 : 0 : return sprintf(buf, "%u\n", val);
1571 : : }
1572 : :
1573 : 0 : static ssize_t online_store(struct device *dev, struct device_attribute *attr,
1574 : : const char *buf, size_t count)
1575 : : {
1576 : 0 : bool val;
1577 : 0 : int ret;
1578 : :
1579 : 0 : ret = strtobool(buf, &val);
1580 [ # # ]: 0 : if (ret < 0)
1581 : 0 : return ret;
1582 : :
1583 : 0 : ret = lock_device_hotplug_sysfs();
1584 [ # # ]: 0 : if (ret)
1585 : 0 : return ret;
1586 : :
1587 [ # # ]: 0 : ret = val ? device_online(dev) : device_offline(dev);
1588 : 0 : unlock_device_hotplug();
1589 [ # # ]: 0 : return ret < 0 ? ret : count;
1590 : : }
1591 : : static DEVICE_ATTR_RW(online);
1592 : :
1593 : 17982 : int device_add_groups(struct device *dev, const struct attribute_group **groups)
1594 : : {
1595 : 3582 : return sysfs_create_groups(&dev->kobj, groups);
1596 : : }
1597 : : EXPORT_SYMBOL_GPL(device_add_groups);
1598 : :
1599 : 56 : void device_remove_groups(struct device *dev,
1600 : : const struct attribute_group **groups)
1601 : : {
1602 : 0 : sysfs_remove_groups(&dev->kobj, groups);
1603 : 28 : }
1604 : : EXPORT_SYMBOL_GPL(device_remove_groups);
1605 : :
1606 : : union device_attr_group_devres {
1607 : : const struct attribute_group *group;
1608 : : const struct attribute_group **groups;
1609 : : };
1610 : :
1611 : 0 : static int devm_attr_group_match(struct device *dev, void *res, void *data)
1612 : : {
1613 : 0 : return ((union device_attr_group_devres *)res)->group == data;
1614 : : }
1615 : :
1616 : 0 : static void devm_attr_group_remove(struct device *dev, void *res)
1617 : : {
1618 : 0 : union device_attr_group_devres *devres = res;
1619 : 0 : const struct attribute_group *group = devres->group;
1620 : :
1621 : 0 : dev_dbg(dev, "%s: removing group %p\n", __func__, group);
1622 : 0 : sysfs_remove_group(&dev->kobj, group);
1623 : 0 : }
1624 : :
1625 : 0 : static void devm_attr_groups_remove(struct device *dev, void *res)
1626 : : {
1627 : 0 : union device_attr_group_devres *devres = res;
1628 : 0 : const struct attribute_group **groups = devres->groups;
1629 : :
1630 : 0 : dev_dbg(dev, "%s: removing groups %p\n", __func__, groups);
1631 : 0 : sysfs_remove_groups(&dev->kobj, groups);
1632 : 0 : }
1633 : :
1634 : : /**
1635 : : * devm_device_add_group - given a device, create a managed attribute group
1636 : : * @dev: The device to create the group for
1637 : : * @grp: The attribute group to create
1638 : : *
1639 : : * This function creates a group for the first time. It will explicitly
1640 : : * warn and error if any of the attribute files being created already exist.
1641 : : *
1642 : : * Returns 0 on success or error code on failure.
1643 : : */
1644 : 0 : int devm_device_add_group(struct device *dev, const struct attribute_group *grp)
1645 : : {
1646 : 0 : union device_attr_group_devres *devres;
1647 : 0 : int error;
1648 : :
1649 : 0 : devres = devres_alloc(devm_attr_group_remove,
1650 : : sizeof(*devres), GFP_KERNEL);
1651 [ # # ]: 0 : if (!devres)
1652 : : return -ENOMEM;
1653 : :
1654 : 0 : error = sysfs_create_group(&dev->kobj, grp);
1655 [ # # ]: 0 : if (error) {
1656 : 0 : devres_free(devres);
1657 : 0 : return error;
1658 : : }
1659 : :
1660 : 0 : devres->group = grp;
1661 : 0 : devres_add(dev, devres);
1662 : 0 : return 0;
1663 : : }
1664 : : EXPORT_SYMBOL_GPL(devm_device_add_group);
1665 : :
1666 : : /**
1667 : : * devm_device_remove_group: remove a managed group from a device
1668 : : * @dev: device to remove the group from
1669 : : * @grp: group to remove
1670 : : *
1671 : : * This function removes a group of attributes from a device. The attributes
1672 : : * previously have to have been created for this group, otherwise it will fail.
1673 : : */
1674 : 0 : void devm_device_remove_group(struct device *dev,
1675 : : const struct attribute_group *grp)
1676 : : {
1677 [ # # ]: 0 : WARN_ON(devres_release(dev, devm_attr_group_remove,
1678 : : devm_attr_group_match,
1679 : : /* cast away const */ (void *)grp));
1680 : 0 : }
1681 : : EXPORT_SYMBOL_GPL(devm_device_remove_group);
1682 : :
1683 : : /**
1684 : : * devm_device_add_groups - create a bunch of managed attribute groups
1685 : : * @dev: The device to create the group for
1686 : : * @groups: The attribute groups to create, NULL terminated
1687 : : *
1688 : : * This function creates a bunch of managed attribute groups. If an error
1689 : : * occurs when creating a group, all previously created groups will be
1690 : : * removed, unwinding everything back to the original state when this
1691 : : * function was called. It will explicitly warn and error if any of the
1692 : : * attribute files being created already exist.
1693 : : *
1694 : : * Returns 0 on success or error code from sysfs_create_group on failure.
1695 : : */
1696 : 0 : int devm_device_add_groups(struct device *dev,
1697 : : const struct attribute_group **groups)
1698 : : {
1699 : 0 : union device_attr_group_devres *devres;
1700 : 0 : int error;
1701 : :
1702 : 0 : devres = devres_alloc(devm_attr_groups_remove,
1703 : : sizeof(*devres), GFP_KERNEL);
1704 [ # # ]: 0 : if (!devres)
1705 : : return -ENOMEM;
1706 : :
1707 : 0 : error = sysfs_create_groups(&dev->kobj, groups);
1708 [ # # ]: 0 : if (error) {
1709 : 0 : devres_free(devres);
1710 : 0 : return error;
1711 : : }
1712 : :
1713 : 0 : devres->groups = groups;
1714 : 0 : devres_add(dev, devres);
1715 : 0 : return 0;
1716 : : }
1717 : : EXPORT_SYMBOL_GPL(devm_device_add_groups);
1718 : :
1719 : : /**
1720 : : * devm_device_remove_groups - remove a list of managed groups
1721 : : *
1722 : : * @dev: The device for the groups to be removed from
1723 : : * @groups: NULL terminated list of groups to be removed
1724 : : *
1725 : : * If groups is not NULL, remove the specified groups from the device.
1726 : : */
1727 : 0 : void devm_device_remove_groups(struct device *dev,
1728 : : const struct attribute_group **groups)
1729 : : {
1730 [ # # ]: 0 : WARN_ON(devres_release(dev, devm_attr_groups_remove,
1731 : : devm_attr_group_match,
1732 : : /* cast away const */ (void *)groups));
1733 : 0 : }
1734 : : EXPORT_SYMBOL_GPL(devm_device_remove_groups);
1735 : :
1736 : 8572 : static int device_add_attrs(struct device *dev)
1737 : : {
1738 : 8572 : struct class *class = dev->class;
1739 : 8572 : const struct device_type *type = dev->type;
1740 : 8572 : int error;
1741 : :
1742 [ + + ]: 8572 : if (class) {
1743 : 4876 : error = device_add_groups(dev, class->dev_groups);
1744 [ + - ]: 4876 : if (error)
1745 : : return error;
1746 : : }
1747 : :
1748 [ + + ]: 8572 : if (type) {
1749 : 952 : error = device_add_groups(dev, type->groups);
1750 [ - + ]: 952 : if (error)
1751 : 0 : goto err_remove_class_groups;
1752 : : }
1753 : :
1754 : 8572 : error = device_add_groups(dev, dev->groups);
1755 [ - + ]: 8572 : if (error)
1756 : 0 : goto err_remove_type_groups;
1757 : :
1758 [ + + + + : 17144 : if (device_supports_offline(dev) && !dev->offline_disabled) {
+ + ]
1759 : 84 : error = device_create_file(dev, &dev_attr_online);
1760 [ - + ]: 84 : if (error)
1761 : 0 : goto err_remove_dev_groups;
1762 : : }
1763 : :
1764 : : return 0;
1765 : :
1766 : : err_remove_dev_groups:
1767 : 0 : device_remove_groups(dev, dev->groups);
1768 : 0 : err_remove_type_groups:
1769 [ # # ]: 0 : if (type)
1770 : 0 : device_remove_groups(dev, type->groups);
1771 : 0 : err_remove_class_groups:
1772 [ # # ]: 0 : if (class)
1773 : 0 : device_remove_groups(dev, class->dev_groups);
1774 : :
1775 : : return error;
1776 : : }
1777 : :
1778 : 28 : static void device_remove_attrs(struct device *dev)
1779 : : {
1780 : 28 : struct class *class = dev->class;
1781 : 28 : const struct device_type *type = dev->type;
1782 : :
1783 : 28 : device_remove_file(dev, &dev_attr_online);
1784 : 28 : device_remove_groups(dev, dev->groups);
1785 : :
1786 [ - + ]: 28 : if (type)
1787 : 0 : device_remove_groups(dev, type->groups);
1788 : :
1789 [ + - ]: 28 : if (class)
1790 : 28 : device_remove_groups(dev, class->dev_groups);
1791 : 28 : }
1792 : :
1793 : 0 : static ssize_t dev_show(struct device *dev, struct device_attribute *attr,
1794 : : char *buf)
1795 : : {
1796 : 0 : return print_dev_t(buf, dev->devt);
1797 : : }
1798 : : static DEVICE_ATTR_RO(dev);
1799 : :
1800 : : /* /sys/devices/ */
1801 : : struct kset *devices_kset;
1802 : :
1803 : : /**
1804 : : * devices_kset_move_before - Move device in the devices_kset's list.
1805 : : * @deva: Device to move.
1806 : : * @devb: Device @deva should come before.
1807 : : */
1808 : 0 : static void devices_kset_move_before(struct device *deva, struct device *devb)
1809 : : {
1810 [ # # ]: 0 : if (!devices_kset)
1811 : : return;
1812 : 0 : pr_debug("devices_kset: Moving %s before %s\n",
1813 : : dev_name(deva), dev_name(devb));
1814 : 0 : spin_lock(&devices_kset->list_lock);
1815 : 0 : list_move_tail(&deva->kobj.entry, &devb->kobj.entry);
1816 : 0 : spin_unlock(&devices_kset->list_lock);
1817 : : }
1818 : :
1819 : : /**
1820 : : * devices_kset_move_after - Move device in the devices_kset's list.
1821 : : * @deva: Device to move
1822 : : * @devb: Device @deva should come after.
1823 : : */
1824 : 0 : static void devices_kset_move_after(struct device *deva, struct device *devb)
1825 : : {
1826 [ # # ]: 0 : if (!devices_kset)
1827 : : return;
1828 : 0 : pr_debug("devices_kset: Moving %s after %s\n",
1829 : : dev_name(deva), dev_name(devb));
1830 : 0 : spin_lock(&devices_kset->list_lock);
1831 : 0 : list_move(&deva->kobj.entry, &devb->kobj.entry);
1832 : 0 : spin_unlock(&devices_kset->list_lock);
1833 : : }
1834 : :
1835 : : /**
1836 : : * devices_kset_move_last - move the device to the end of devices_kset's list.
1837 : : * @dev: device to move
1838 : : */
1839 : 0 : void devices_kset_move_last(struct device *dev)
1840 : : {
1841 [ # # ]: 0 : if (!devices_kset)
1842 : : return;
1843 : 0 : pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev));
1844 : 0 : spin_lock(&devices_kset->list_lock);
1845 : 0 : list_move_tail(&dev->kobj.entry, &devices_kset->list);
1846 : 0 : spin_unlock(&devices_kset->list_lock);
1847 : : }
1848 : :
1849 : : /**
1850 : : * device_create_file - create sysfs attribute file for device.
1851 : : * @dev: device.
1852 : : * @attr: device attribute descriptor.
1853 : : */
1854 : 20752 : int device_create_file(struct device *dev,
1855 : : const struct device_attribute *attr)
1856 : : {
1857 : 20752 : int error = 0;
1858 : :
1859 [ + - ]: 20752 : if (dev) {
1860 [ + + + - : 41504 : WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
- + ]
1861 : : "Attribute %s: write permission without 'store'\n",
1862 : : attr->attr.name);
1863 [ + + + - : 41504 : WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
- + ]
1864 : : "Attribute %s: read permission without 'show'\n",
1865 : : attr->attr.name);
1866 : 20752 : error = sysfs_create_file(&dev->kobj, &attr->attr);
1867 : : }
1868 : :
1869 : 20752 : return error;
1870 : : }
1871 : : EXPORT_SYMBOL_GPL(device_create_file);
1872 : :
1873 : : /**
1874 : : * device_remove_file - remove sysfs attribute file.
1875 : : * @dev: device.
1876 : : * @attr: device attribute descriptor.
1877 : : */
1878 : 56 : void device_remove_file(struct device *dev,
1879 : : const struct device_attribute *attr)
1880 : : {
1881 [ - - + - ]: 28 : if (dev)
1882 : 56 : sysfs_remove_file(&dev->kobj, &attr->attr);
1883 : 0 : }
1884 : : EXPORT_SYMBOL_GPL(device_remove_file);
1885 : :
1886 : : /**
1887 : : * device_remove_file_self - remove sysfs attribute file from its own method.
1888 : : * @dev: device.
1889 : : * @attr: device attribute descriptor.
1890 : : *
1891 : : * See kernfs_remove_self() for details.
1892 : : */
1893 : 0 : bool device_remove_file_self(struct device *dev,
1894 : : const struct device_attribute *attr)
1895 : : {
1896 [ # # ]: 0 : if (dev)
1897 : 0 : return sysfs_remove_file_self(&dev->kobj, &attr->attr);
1898 : : else
1899 : : return false;
1900 : : }
1901 : : EXPORT_SYMBOL_GPL(device_remove_file_self);
1902 : :
1903 : : /**
1904 : : * device_create_bin_file - create sysfs binary attribute file for device.
1905 : : * @dev: device.
1906 : : * @attr: device binary attribute descriptor.
1907 : : */
1908 : 0 : int device_create_bin_file(struct device *dev,
1909 : : const struct bin_attribute *attr)
1910 : : {
1911 : 0 : int error = -EINVAL;
1912 [ # # ]: 0 : if (dev)
1913 : 0 : error = sysfs_create_bin_file(&dev->kobj, attr);
1914 : 0 : return error;
1915 : : }
1916 : : EXPORT_SYMBOL_GPL(device_create_bin_file);
1917 : :
1918 : : /**
1919 : : * device_remove_bin_file - remove sysfs binary attribute file
1920 : : * @dev: device.
1921 : : * @attr: device binary attribute descriptor.
1922 : : */
1923 : 0 : void device_remove_bin_file(struct device *dev,
1924 : : const struct bin_attribute *attr)
1925 : : {
1926 [ # # ]: 0 : if (dev)
1927 : 0 : sysfs_remove_bin_file(&dev->kobj, attr);
1928 : 0 : }
1929 : : EXPORT_SYMBOL_GPL(device_remove_bin_file);
1930 : :
1931 : 4256 : static void klist_children_get(struct klist_node *n)
1932 : : {
1933 : 4256 : struct device_private *p = to_device_private_parent(n);
1934 : 4256 : struct device *dev = p->device;
1935 : :
1936 : 4256 : get_device(dev);
1937 : 4256 : }
1938 : :
1939 : 28 : static void klist_children_put(struct klist_node *n)
1940 : : {
1941 : 28 : struct device_private *p = to_device_private_parent(n);
1942 : 28 : struct device *dev = p->device;
1943 : :
1944 : 28 : put_device(dev);
1945 : 28 : }
1946 : :
1947 : : /**
1948 : : * device_initialize - init device structure.
1949 : : * @dev: device.
1950 : : *
1951 : : * This prepares the device for use by other layers by initializing
1952 : : * its fields.
1953 : : * It is the first half of device_register(), if called by
1954 : : * that function, though it can also be called separately, so one
1955 : : * may use @dev's fields. In particular, get_device()/put_device()
1956 : : * may be used for reference counting of @dev after calling this
1957 : : * function.
1958 : : *
1959 : : * All fields in @dev must be initialized by the caller to 0, except
1960 : : * for those explicitly set to some other value. The simplest
1961 : : * approach is to use kzalloc() to allocate the structure containing
1962 : : * @dev.
1963 : : *
1964 : : * NOTE: Use put_device() to give up your reference instead of freeing
1965 : : * @dev directly once you have called this function.
1966 : : */
1967 : 8740 : void device_initialize(struct device *dev)
1968 : : {
1969 : 8740 : dev->kobj.kset = devices_kset;
1970 : 8740 : kobject_init(&dev->kobj, &device_ktype);
1971 : 8740 : INIT_LIST_HEAD(&dev->dma_pools);
1972 : 8740 : mutex_init(&dev->mutex);
1973 : : #ifdef CONFIG_PROVE_LOCKING
1974 : : mutex_init(&dev->lockdep_mutex);
1975 : : #endif
1976 : 8740 : lockdep_set_novalidate_class(&dev->mutex);
1977 : 8740 : spin_lock_init(&dev->devres_lock);
1978 : 8740 : INIT_LIST_HEAD(&dev->devres_head);
1979 : 8740 : device_pm_init(dev);
1980 : 8740 : set_dev_node(dev, -1);
1981 : : #ifdef CONFIG_GENERIC_MSI_IRQ
1982 : 8740 : INIT_LIST_HEAD(&dev->msi_list);
1983 : : #endif
1984 : 8740 : INIT_LIST_HEAD(&dev->links.consumers);
1985 : 8740 : INIT_LIST_HEAD(&dev->links.suppliers);
1986 : 8740 : INIT_LIST_HEAD(&dev->links.needs_suppliers);
1987 : 8740 : INIT_LIST_HEAD(&dev->links.defer_sync);
1988 : 8740 : dev->links.status = DL_DEV_NO_DRIVER;
1989 : 8740 : }
1990 : : EXPORT_SYMBOL_GPL(device_initialize);
1991 : :
1992 : 28 : struct kobject *virtual_device_parent(struct device *dev)
1993 : : {
1994 : 28 : static struct kobject *virtual_dir = NULL;
1995 : :
1996 [ + - ]: 28 : if (!virtual_dir)
1997 : 28 : virtual_dir = kobject_create_and_add("virtual",
1998 : 28 : &devices_kset->kobj);
1999 : :
2000 : 28 : return virtual_dir;
2001 : : }
2002 : :
2003 : : struct class_dir {
2004 : : struct kobject kobj;
2005 : : struct class *class;
2006 : : };
2007 : :
2008 : : #define to_class_dir(obj) container_of(obj, struct class_dir, kobj)
2009 : :
2010 : 0 : static void class_dir_release(struct kobject *kobj)
2011 : : {
2012 : 0 : struct class_dir *dir = to_class_dir(kobj);
2013 : 0 : kfree(dir);
2014 : 0 : }
2015 : :
2016 : : static const
2017 : 15860 : struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)
2018 : : {
2019 : 15860 : struct class_dir *dir = to_class_dir(kobj);
2020 : 15860 : return dir->class->ns_type;
2021 : : }
2022 : :
2023 : : static struct kobj_type class_dir_ktype = {
2024 : : .release = class_dir_release,
2025 : : .sysfs_ops = &kobj_sysfs_ops,
2026 : : .child_ns_type = class_dir_child_ns_type
2027 : : };
2028 : :
2029 : : static struct kobject *
2030 : 1600 : class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)
2031 : : {
2032 : 1600 : struct class_dir *dir;
2033 : 1600 : int retval;
2034 : :
2035 : 1600 : dir = kzalloc(sizeof(*dir), GFP_KERNEL);
2036 [ + - ]: 1600 : if (!dir)
2037 : : return ERR_PTR(-ENOMEM);
2038 : :
2039 : 1600 : dir->class = class;
2040 : 1600 : kobject_init(&dir->kobj, &class_dir_ktype);
2041 : :
2042 : 1600 : dir->kobj.kset = &class->p->glue_dirs;
2043 : :
2044 : 1600 : retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
2045 [ - + ]: 1600 : if (retval < 0) {
2046 : 0 : kobject_put(&dir->kobj);
2047 : 0 : return ERR_PTR(retval);
2048 : : }
2049 : : return &dir->kobj;
2050 : : }
2051 : :
2052 : : static DEFINE_MUTEX(gdp_mutex);
2053 : :
2054 : : static struct kobject *get_device_parent(struct device *dev,
2055 : : struct device *parent)
2056 : : {
2057 : : if (dev->class) {
2058 : : struct kobject *kobj = NULL;
2059 : : struct kobject *parent_kobj;
2060 : : struct kobject *k;
2061 : :
2062 : : #ifdef CONFIG_BLOCK
2063 : : /* block disks show up in /sys/block */
2064 : : if (sysfs_deprecated && dev->class == &block_class) {
2065 : : if (parent && parent->class == &block_class)
2066 : : return &parent->kobj;
2067 : : return &block_class.p->subsys.kobj;
2068 : : }
2069 : : #endif
2070 : :
2071 : : /*
2072 : : * If we have no parent, we live in "virtual".
2073 : : * Class-devices with a non class-device as parent, live
2074 : : * in a "glue" directory to prevent namespace collisions.
2075 : : */
2076 : : if (parent == NULL)
2077 : : parent_kobj = virtual_device_parent(dev);
2078 : : else if (parent->class && !dev->class->ns_type)
2079 : : return &parent->kobj;
2080 : : else
2081 : : parent_kobj = &parent->kobj;
2082 : :
2083 : : mutex_lock(&gdp_mutex);
2084 : :
2085 : : /* find our class-directory at the parent and reference it */
2086 : : spin_lock(&dev->class->p->glue_dirs.list_lock);
2087 : : list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
2088 : : if (k->parent == parent_kobj) {
2089 : : kobj = kobject_get(k);
2090 : : break;
2091 : : }
2092 : : spin_unlock(&dev->class->p->glue_dirs.list_lock);
2093 : : if (kobj) {
2094 : : mutex_unlock(&gdp_mutex);
2095 : : return kobj;
2096 : : }
2097 : :
2098 : : /* or create a new class-directory at the parent device */
2099 : : k = class_dir_create_and_add(dev->class, parent_kobj);
2100 : : /* do not emit an uevent for this simple "glue" directory */
2101 : : mutex_unlock(&gdp_mutex);
2102 : : return k;
2103 : : }
2104 : :
2105 : : /* subsystems can specify a default root directory for their devices */
2106 : : if (!parent && dev->bus && dev->bus->dev_root)
2107 : : return &dev->bus->dev_root->kobj;
2108 : :
2109 : : if (parent)
2110 : : return &parent->kobj;
2111 : : return NULL;
2112 : : }
2113 : :
2114 : 28 : static inline bool live_in_glue_dir(struct kobject *kobj,
2115 : : struct device *dev)
2116 : : {
2117 [ + - ]: 28 : if (!kobj || !dev->class ||
2118 [ + - ]: 28 : kobj->kset != &dev->class->p->glue_dirs)
2119 : : return false;
2120 : : return true;
2121 : : }
2122 : :
2123 : 28 : static inline struct kobject *get_glue_dir(struct device *dev)
2124 : : {
2125 : 28 : return dev->kobj.parent;
2126 : : }
2127 : :
2128 : : /*
2129 : : * make sure cleaning up dir as the last step, we need to make
2130 : : * sure .release handler of kobject is run with holding the
2131 : : * global lock
2132 : : */
2133 : 28 : static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
2134 : : {
2135 : 28 : unsigned int ref;
2136 : :
2137 : : /* see if we live in a "glue" directory */
2138 [ + - ]: 28 : if (!live_in_glue_dir(glue_dir, dev))
2139 : : return;
2140 : :
2141 : 28 : mutex_lock(&gdp_mutex);
2142 : : /**
2143 : : * There is a race condition between removing glue directory
2144 : : * and adding a new device under the glue directory.
2145 : : *
2146 : : * CPU1: CPU2:
2147 : : *
2148 : : * device_add()
2149 : : * get_device_parent()
2150 : : * class_dir_create_and_add()
2151 : : * kobject_add_internal()
2152 : : * create_dir() // create glue_dir
2153 : : *
2154 : : * device_add()
2155 : : * get_device_parent()
2156 : : * kobject_get() // get glue_dir
2157 : : *
2158 : : * device_del()
2159 : : * cleanup_glue_dir()
2160 : : * kobject_del(glue_dir)
2161 : : *
2162 : : * kobject_add()
2163 : : * kobject_add_internal()
2164 : : * create_dir() // in glue_dir
2165 : : * sysfs_create_dir_ns()
2166 : : * kernfs_create_dir_ns(sd)
2167 : : *
2168 : : * sysfs_remove_dir() // glue_dir->sd=NULL
2169 : : * sysfs_put() // free glue_dir->sd
2170 : : *
2171 : : * // sd is freed
2172 : : * kernfs_new_node(sd)
2173 : : * kernfs_get(glue_dir)
2174 : : * kernfs_add_one()
2175 : : * kernfs_put()
2176 : : *
2177 : : * Before CPU1 remove last child device under glue dir, if CPU2 add
2178 : : * a new device under glue dir, the glue_dir kobject reference count
2179 : : * will be increase to 2 in kobject_get(k). And CPU2 has been called
2180 : : * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir()
2181 : : * and sysfs_put(). This result in glue_dir->sd is freed.
2182 : : *
2183 : : * Then the CPU2 will see a stale "empty" but still potentially used
2184 : : * glue dir around in kernfs_new_node().
2185 : : *
2186 : : * In order to avoid this happening, we also should make sure that
2187 : : * kernfs_node for glue_dir is released in CPU1 only when refcount
2188 : : * for glue_dir kobj is 1.
2189 : : */
2190 : 28 : ref = kref_read(&glue_dir->kref);
2191 [ - + - - ]: 28 : if (!kobject_has_children(glue_dir) && !--ref)
2192 : 0 : kobject_del(glue_dir);
2193 : 28 : kobject_put(glue_dir);
2194 : 28 : mutex_unlock(&gdp_mutex);
2195 : : }
2196 : :
2197 : 8572 : static int device_add_class_symlinks(struct device *dev)
2198 : : {
2199 [ + + ]: 8572 : struct device_node *of_node = dev_of_node(dev);
2200 : 8572 : int error;
2201 : :
2202 : 8572 : if (of_node) {
2203 : : error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node");
2204 : : if (error)
2205 : : dev_warn(dev, "Error %d creating of_node link\n",error);
2206 : : /* An error here doesn't warrant bringing down the device */
2207 : : }
2208 : :
2209 [ + + ]: 8572 : if (!dev->class)
2210 : : return 0;
2211 : :
2212 : 4876 : error = sysfs_create_link(&dev->kobj,
2213 : 4876 : &dev->class->p->subsys.kobj,
2214 : : "subsystem");
2215 [ - + ]: 4876 : if (error)
2216 : 0 : goto out_devnode;
2217 : :
2218 [ + + + - ]: 4876 : if (dev->parent && device_is_not_partition(dev)) {
2219 : 1400 : error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
2220 : : "device");
2221 [ - + ]: 1400 : if (error)
2222 : 0 : goto out_subsys;
2223 : : }
2224 : :
2225 : : #ifdef CONFIG_BLOCK
2226 : : /* /sys/block has directories and does not need symlinks */
2227 : 4876 : if (sysfs_deprecated && dev->class == &block_class)
2228 : : return 0;
2229 : : #endif
2230 : :
2231 : : /* link in the class directory pointing to the device */
2232 [ + - ]: 9752 : error = sysfs_create_link(&dev->class->p->subsys.kobj,
2233 : : &dev->kobj, dev_name(dev));
2234 [ - + ]: 4876 : if (error)
2235 : 0 : goto out_device;
2236 : :
2237 : : return 0;
2238 : :
2239 : : out_device:
2240 : 0 : sysfs_remove_link(&dev->kobj, "device");
2241 : :
2242 : 0 : out_subsys:
2243 : 0 : sysfs_remove_link(&dev->kobj, "subsystem");
2244 : 0 : out_devnode:
2245 : 0 : sysfs_remove_link(&dev->kobj, "of_node");
2246 : 0 : return error;
2247 : : }
2248 : :
2249 : 28 : static void device_remove_class_symlinks(struct device *dev)
2250 : : {
2251 [ + - ]: 28 : if (dev_of_node(dev))
2252 : : sysfs_remove_link(&dev->kobj, "of_node");
2253 : :
2254 [ + - ]: 28 : if (!dev->class)
2255 : : return;
2256 : :
2257 [ + - + - ]: 28 : if (dev->parent && device_is_not_partition(dev))
2258 : 28 : sysfs_remove_link(&dev->kobj, "device");
2259 : 28 : sysfs_remove_link(&dev->kobj, "subsystem");
2260 : : #ifdef CONFIG_BLOCK
2261 : 28 : if (sysfs_deprecated && dev->class == &block_class)
2262 : : return;
2263 : : #endif
2264 [ + - ]: 56 : sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
2265 : : }
2266 : :
2267 : : /**
2268 : : * dev_set_name - set a device name
2269 : : * @dev: device
2270 : : * @fmt: format string for the device's name
2271 : : */
2272 : 6668 : int dev_set_name(struct device *dev, const char *fmt, ...)
2273 : : {
2274 : 6668 : va_list vargs;
2275 : 6668 : int err;
2276 : :
2277 : 6668 : va_start(vargs, fmt);
2278 : 6668 : err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
2279 : 6668 : va_end(vargs);
2280 : 6668 : return err;
2281 : : }
2282 : : EXPORT_SYMBOL_GPL(dev_set_name);
2283 : :
2284 : : /**
2285 : : * device_to_dev_kobj - select a /sys/dev/ directory for the device
2286 : : * @dev: device
2287 : : *
2288 : : * By default we select char/ for new entries. Setting class->dev_obj
2289 : : * to NULL prevents an entry from being created. class->dev_kobj must
2290 : : * be set (or cleared) before any devices are registered to the class
2291 : : * otherwise device_create_sys_dev_entry() and
2292 : : * device_remove_sys_dev_entry() will disagree about the presence of
2293 : : * the link.
2294 : : */
2295 : 3444 : static struct kobject *device_to_dev_kobj(struct device *dev)
2296 : : {
2297 : 3444 : struct kobject *kobj;
2298 : :
2299 : 3444 : if (dev->class)
2300 : 3444 : kobj = dev->class->dev_kobj;
2301 : : else
2302 : 0 : kobj = sysfs_dev_char_kobj;
2303 : :
2304 : 3444 : return kobj;
2305 : : }
2306 : :
2307 : 3444 : static int device_create_sys_dev_entry(struct device *dev)
2308 : : {
2309 [ + - ]: 3444 : struct kobject *kobj = device_to_dev_kobj(dev);
2310 : 3444 : int error = 0;
2311 : 3444 : char devt_str[15];
2312 : :
2313 [ + - ]: 3444 : if (kobj) {
2314 : 3444 : format_dev_t(devt_str, dev->devt);
2315 : 3444 : error = sysfs_create_link(kobj, &dev->kobj, devt_str);
2316 : : }
2317 : :
2318 : 3444 : return error;
2319 : : }
2320 : :
2321 : 0 : static void device_remove_sys_dev_entry(struct device *dev)
2322 : : {
2323 [ # # ]: 0 : struct kobject *kobj = device_to_dev_kobj(dev);
2324 : 0 : char devt_str[15];
2325 : :
2326 [ # # ]: 0 : if (kobj) {
2327 : 0 : format_dev_t(devt_str, dev->devt);
2328 : 0 : sysfs_remove_link(kobj, devt_str);
2329 : : }
2330 : 0 : }
2331 : :
2332 : 8572 : static int device_private_init(struct device *dev)
2333 : : {
2334 : 8572 : dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
2335 [ + - ]: 8572 : if (!dev->p)
2336 : : return -ENOMEM;
2337 : 8572 : dev->p->device = dev;
2338 : 8572 : klist_init(&dev->p->klist_children, klist_children_get,
2339 : : klist_children_put);
2340 : 8572 : INIT_LIST_HEAD(&dev->p->deferred_probe);
2341 : 8572 : return 0;
2342 : : }
2343 : :
2344 : : /**
2345 : : * device_add - add device to device hierarchy.
2346 : : * @dev: device.
2347 : : *
2348 : : * This is part 2 of device_register(), though may be called
2349 : : * separately _iff_ device_initialize() has been called separately.
2350 : : *
2351 : : * This adds @dev to the kobject hierarchy via kobject_add(), adds it
2352 : : * to the global and sibling lists for the device, then
2353 : : * adds it to the other relevant subsystems of the driver model.
2354 : : *
2355 : : * Do not call this routine or device_register() more than once for
2356 : : * any device structure. The driver model core is not designed to work
2357 : : * with devices that get unregistered and then spring back to life.
2358 : : * (Among other things, it's very hard to guarantee that all references
2359 : : * to the previous incarnation of @dev have been dropped.) Allocate
2360 : : * and register a fresh new struct device instead.
2361 : : *
2362 : : * NOTE: _Never_ directly free @dev after calling this function, even
2363 : : * if it returned an error! Always use put_device() to give up your
2364 : : * reference instead.
2365 : : *
2366 : : * Rule of thumb is: if device_add() succeeds, you should call
2367 : : * device_del() when you want to get rid of it. If device_add() has
2368 : : * *not* succeeded, use *only* put_device() to drop the reference
2369 : : * count.
2370 : : */
2371 : 8572 : int device_add(struct device *dev)
2372 : : {
2373 : 8572 : struct device *parent;
2374 : 8572 : struct kobject *kobj;
2375 : 8572 : struct class_interface *class_intf;
2376 : 8572 : int error = -EINVAL, fw_ret;
2377 : 8572 : struct kobject *glue_dir = NULL;
2378 : :
2379 : 8572 : dev = get_device(dev);
2380 [ - + ]: 8572 : if (!dev)
2381 : 0 : goto done;
2382 : :
2383 [ + - ]: 8572 : if (!dev->p) {
2384 : 8572 : error = device_private_init(dev);
2385 [ - + ]: 8572 : if (error)
2386 : 0 : goto done;
2387 : : }
2388 : :
2389 : : /*
2390 : : * for statically allocated devices, which should all be converted
2391 : : * some day, we need to initialize the name. We prevent reading back
2392 : : * the name, and force the use of dev_name()
2393 : : */
2394 [ + + ]: 8572 : if (dev->init_name) {
2395 : 56 : dev_set_name(dev, "%s", dev->init_name);
2396 : 56 : dev->init_name = NULL;
2397 : : }
2398 : :
2399 : : /* subsystems can specify simple device enumeration */
2400 [ + - + + : 17144 : if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
+ - + - ]
2401 : 140 : dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
2402 : :
2403 [ + - - + ]: 17144 : if (!dev_name(dev)) {
2404 : 0 : error = -EINVAL;
2405 : 0 : goto name_error;
2406 : : }
2407 : :
2408 : 8572 : pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
2409 : :
2410 : 8572 : parent = get_device(dev->parent);
2411 : 8572 : kobj = get_device_parent(dev, parent);
2412 [ - + ]: 8572 : if (IS_ERR(kobj)) {
2413 : 0 : error = PTR_ERR(kobj);
2414 : 0 : goto parent_error;
2415 : : }
2416 [ + + ]: 8572 : if (kobj)
2417 : 8040 : dev->kobj.parent = kobj;
2418 : :
2419 : : /* use parent numa_node */
2420 [ + + + - ]: 8572 : if (parent && (dev_to_node(dev) == NUMA_NO_NODE))
2421 : 4256 : set_dev_node(dev, dev_to_node(parent));
2422 : :
2423 : : /* first, register with generic layer. */
2424 : : /* we require the name to be set before, and pass NULL */
2425 : 8572 : error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
2426 [ - + ]: 8572 : if (error) {
2427 : 0 : glue_dir = get_glue_dir(dev);
2428 : 0 : goto Error;
2429 : : }
2430 : :
2431 : : /* notify platform of device entry */
2432 : 8572 : error = device_platform_notify(dev, KOBJ_ADD);
2433 [ - + ]: 8572 : if (error)
2434 : 0 : goto platform_error;
2435 : :
2436 : 8572 : error = device_create_file(dev, &dev_attr_uevent);
2437 [ - + ]: 8572 : if (error)
2438 : 0 : goto attrError;
2439 : :
2440 : 8572 : error = device_add_class_symlinks(dev);
2441 [ - + ]: 8572 : if (error)
2442 : 0 : goto SymlinkError;
2443 : 8572 : error = device_add_attrs(dev);
2444 [ - + ]: 8572 : if (error)
2445 : 0 : goto AttrsError;
2446 : 8572 : error = bus_add_device(dev);
2447 [ - + ]: 8572 : if (error)
2448 : 0 : goto BusError;
2449 : 8572 : error = dpm_sysfs_add(dev);
2450 [ - + ]: 8572 : if (error)
2451 : 0 : goto DPMError;
2452 : 8572 : device_pm_add(dev);
2453 : :
2454 [ + + ]: 8572 : if (MAJOR(dev->devt)) {
2455 : 3444 : error = device_create_file(dev, &dev_attr_dev);
2456 [ - + ]: 3444 : if (error)
2457 : 0 : goto DevAttrError;
2458 : :
2459 : 3444 : error = device_create_sys_dev_entry(dev);
2460 [ - + ]: 3444 : if (error)
2461 : 0 : goto SysEntryError;
2462 : :
2463 : 3444 : devtmpfs_create_node(dev);
2464 : : }
2465 : :
2466 : : /* Notify clients of device addition. This call must come
2467 : : * after dpm_sysfs_add() and before kobject_uevent().
2468 : : */
2469 [ + + ]: 8572 : if (dev->bus)
2470 : 3024 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
2471 : : BUS_NOTIFY_ADD_DEVICE, dev);
2472 : :
2473 : 8572 : kobject_uevent(&dev->kobj, KOBJ_ADD);
2474 : :
2475 [ + + + - ]: 8572 : if (dev->fwnode && !dev->fwnode->dev)
2476 : 504 : dev->fwnode->dev = dev;
2477 : :
2478 : : /*
2479 : : * Check if any of the other devices (consumers) have been waiting for
2480 : : * this device (supplier) to be added so that they can create a device
2481 : : * link to it.
2482 : : *
2483 : : * This needs to happen after device_pm_add() because device_link_add()
2484 : : * requires the supplier be registered before it's called.
2485 : : *
2486 : : * But this also needs to happe before bus_probe_device() to make sure
2487 : : * waiting consumers can link to it before the driver is bound to the
2488 : : * device and the driver sync_state callback is called for this device.
2489 : : */
2490 : 8572 : device_link_add_missing_supplier_links();
2491 : :
2492 [ + + + - : 8572 : if (fwnode_has_op(dev->fwnode, add_links)) {
- + ]
2493 : 0 : fw_ret = fwnode_call_int_op(dev->fwnode, add_links, dev);
2494 [ # # ]: 0 : if (fw_ret == -ENODEV)
2495 : 0 : device_link_wait_for_mandatory_supplier(dev);
2496 [ # # ]: 0 : else if (fw_ret)
2497 : 0 : device_link_wait_for_optional_supplier(dev);
2498 : : }
2499 : :
2500 : 8572 : bus_probe_device(dev);
2501 [ + + ]: 8572 : if (parent)
2502 : 4256 : klist_add_tail(&dev->p->knode_parent,
2503 : 4256 : &parent->p->klist_children);
2504 : :
2505 [ + + ]: 8572 : if (dev->class) {
2506 : 4876 : mutex_lock(&dev->class->p->mutex);
2507 : : /* tie the class to the device */
2508 : 4876 : klist_add_tail(&dev->p->knode_class,
2509 : 4876 : &dev->class->p->klist_devices);
2510 : :
2511 : : /* notify any interfaces that the device is here */
2512 [ + + ]: 4988 : list_for_each_entry(class_intf,
2513 : : &dev->class->p->interfaces, node)
2514 [ + - ]: 112 : if (class_intf->add_dev)
2515 : 112 : class_intf->add_dev(dev, class_intf);
2516 : 4876 : mutex_unlock(&dev->class->p->mutex);
2517 : : }
2518 : 3696 : done:
2519 : 8572 : put_device(dev);
2520 : 8572 : return error;
2521 : : SysEntryError:
2522 [ # # ]: 0 : if (MAJOR(dev->devt))
2523 : 0 : device_remove_file(dev, &dev_attr_dev);
2524 : 0 : DevAttrError:
2525 : 0 : device_pm_remove(dev);
2526 : 0 : dpm_sysfs_remove(dev);
2527 : 0 : DPMError:
2528 : 0 : bus_remove_device(dev);
2529 : 0 : BusError:
2530 : 0 : device_remove_attrs(dev);
2531 : 0 : AttrsError:
2532 : 0 : device_remove_class_symlinks(dev);
2533 : 0 : SymlinkError:
2534 : 0 : device_remove_file(dev, &dev_attr_uevent);
2535 : 0 : attrError:
2536 : 0 : device_platform_notify(dev, KOBJ_REMOVE);
2537 : 0 : platform_error:
2538 : 0 : kobject_uevent(&dev->kobj, KOBJ_REMOVE);
2539 : 0 : glue_dir = get_glue_dir(dev);
2540 : 0 : kobject_del(&dev->kobj);
2541 : 0 : Error:
2542 : 0 : cleanup_glue_dir(dev, glue_dir);
2543 : 0 : parent_error:
2544 : 0 : put_device(parent);
2545 : 0 : name_error:
2546 : 0 : kfree(dev->p);
2547 : 0 : dev->p = NULL;
2548 : 0 : goto done;
2549 : : }
2550 : : EXPORT_SYMBOL_GPL(device_add);
2551 : :
2552 : : /**
2553 : : * device_register - register a device with the system.
2554 : : * @dev: pointer to the device structure
2555 : : *
2556 : : * This happens in two clean steps - initialize the device
2557 : : * and add it to the system. The two steps can be called
2558 : : * separately, but this is the easiest and most common.
2559 : : * I.e. you should only call the two helpers separately if
2560 : : * have a clearly defined need to use and refcount the device
2561 : : * before it is added to the hierarchy.
2562 : : *
2563 : : * For more information, see the kerneldoc for device_initialize()
2564 : : * and device_add().
2565 : : *
2566 : : * NOTE: _Never_ directly free @dev after calling this function, even
2567 : : * if it returned an error! Always use put_device() to give up the
2568 : : * reference initialized in this function instead.
2569 : : */
2570 : 2716 : int device_register(struct device *dev)
2571 : : {
2572 : 2716 : device_initialize(dev);
2573 : 2716 : return device_add(dev);
2574 : : }
2575 : : EXPORT_SYMBOL_GPL(device_register);
2576 : :
2577 : : /**
2578 : : * get_device - increment reference count for device.
2579 : : * @dev: device.
2580 : : *
2581 : : * This simply forwards the call to kobject_get(), though
2582 : : * we do take care to provide for the case that we get a NULL
2583 : : * pointer passed in.
2584 : : */
2585 : 38885 : struct device *get_device(struct device *dev)
2586 : : {
2587 [ + - + - : 38885 : return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
+ + + - -
- ]
2588 : : }
2589 : : EXPORT_SYMBOL_GPL(get_device);
2590 : :
2591 : : /**
2592 : : * put_device - decrement reference count.
2593 : : * @dev: device in question.
2594 : : */
2595 : 15445 : void put_device(struct device *dev)
2596 : : {
2597 : : /* might_sleep(); */
2598 [ + + + - : 15389 : if (dev)
- - + - -
- - - - -
- - ]
2599 : 15361 : kobject_put(&dev->kobj);
2600 : 6789 : }
2601 : : EXPORT_SYMBOL_GPL(put_device);
2602 : :
2603 : 28 : bool kill_device(struct device *dev)
2604 : : {
2605 : : /*
2606 : : * Require the device lock and set the "dead" flag to guarantee that
2607 : : * the update behavior is consistent with the other bitfields near
2608 : : * it and that we cannot have an asynchronous probe routine trying
2609 : : * to run while we are tearing out the bus/class/sysfs from
2610 : : * underneath the device.
2611 : : */
2612 : 28 : lockdep_assert_held(&dev->mutex);
2613 : :
2614 [ # # ]: 0 : if (dev->p->dead)
2615 : : return false;
2616 : 28 : dev->p->dead = true;
2617 : 28 : return true;
2618 : : }
2619 : : EXPORT_SYMBOL_GPL(kill_device);
2620 : :
2621 : : /**
2622 : : * device_del - delete device from system.
2623 : : * @dev: device.
2624 : : *
2625 : : * This is the first part of the device unregistration
2626 : : * sequence. This removes the device from the lists we control
2627 : : * from here, has it removed from the other driver model
2628 : : * subsystems it was added to in device_add(), and removes it
2629 : : * from the kobject hierarchy.
2630 : : *
2631 : : * NOTE: this should be called manually _iff_ device_add() was
2632 : : * also called manually.
2633 : : */
2634 : 28 : void device_del(struct device *dev)
2635 : : {
2636 : 28 : struct device *parent = dev->parent;
2637 : 28 : struct kobject *glue_dir = NULL;
2638 : 28 : struct class_interface *class_intf;
2639 : :
2640 : 28 : device_lock(dev);
2641 [ + - ]: 28 : kill_device(dev);
2642 : 28 : device_unlock(dev);
2643 : :
2644 [ - + - - ]: 28 : if (dev->fwnode && dev->fwnode->dev == dev)
2645 : 0 : dev->fwnode->dev = NULL;
2646 : :
2647 : : /* Notify clients of device removal. This call must come
2648 : : * before dpm_sysfs_remove().
2649 : : */
2650 [ - + ]: 28 : if (dev->bus)
2651 : 0 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
2652 : : BUS_NOTIFY_DEL_DEVICE, dev);
2653 : :
2654 : 28 : dpm_sysfs_remove(dev);
2655 [ + - ]: 28 : if (parent)
2656 : 28 : klist_del(&dev->p->knode_parent);
2657 [ - + ]: 28 : if (MAJOR(dev->devt)) {
2658 : 0 : devtmpfs_delete_node(dev);
2659 : 0 : device_remove_sys_dev_entry(dev);
2660 [ # # ]: 0 : device_remove_file(dev, &dev_attr_dev);
2661 : : }
2662 [ + - ]: 28 : if (dev->class) {
2663 : 28 : device_remove_class_symlinks(dev);
2664 : :
2665 : 28 : mutex_lock(&dev->class->p->mutex);
2666 : : /* notify any interfaces that the device is now gone */
2667 [ - + ]: 28 : list_for_each_entry(class_intf,
2668 : : &dev->class->p->interfaces, node)
2669 [ # # ]: 0 : if (class_intf->remove_dev)
2670 : 0 : class_intf->remove_dev(dev, class_intf);
2671 : : /* remove the device from the class list */
2672 : 28 : klist_del(&dev->p->knode_class);
2673 : 28 : mutex_unlock(&dev->class->p->mutex);
2674 : : }
2675 [ + - ]: 28 : device_remove_file(dev, &dev_attr_uevent);
2676 : 28 : device_remove_attrs(dev);
2677 : 28 : bus_remove_device(dev);
2678 : 28 : device_pm_remove(dev);
2679 : 28 : driver_deferred_probe_del(dev);
2680 : 28 : device_platform_notify(dev, KOBJ_REMOVE);
2681 : 28 : device_remove_properties(dev);
2682 : 28 : device_links_purge(dev);
2683 : :
2684 [ - + ]: 28 : if (dev->bus)
2685 : 0 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
2686 : : BUS_NOTIFY_REMOVED_DEVICE, dev);
2687 : 28 : kobject_uevent(&dev->kobj, KOBJ_REMOVE);
2688 : 28 : glue_dir = get_glue_dir(dev);
2689 : 28 : kobject_del(&dev->kobj);
2690 : 28 : cleanup_glue_dir(dev, glue_dir);
2691 [ + - ]: 28 : put_device(parent);
2692 : 28 : }
2693 : : EXPORT_SYMBOL_GPL(device_del);
2694 : :
2695 : : /**
2696 : : * device_unregister - unregister device from system.
2697 : : * @dev: device going away.
2698 : : *
2699 : : * We do this in two parts, like we do device_register(). First,
2700 : : * we remove it from all the subsystems with device_del(), then
2701 : : * we decrement the reference count via put_device(). If that
2702 : : * is the final reference count, the device will be cleaned up
2703 : : * via device_release() above. Otherwise, the structure will
2704 : : * stick around until the final reference to the device is dropped.
2705 : : */
2706 : 28 : void device_unregister(struct device *dev)
2707 : : {
2708 : 28 : pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
2709 : 28 : device_del(dev);
2710 [ - - + - ]: 28 : put_device(dev);
2711 : 0 : }
2712 : : EXPORT_SYMBOL_GPL(device_unregister);
2713 : :
2714 : 0 : static struct device *prev_device(struct klist_iter *i)
2715 : : {
2716 : 0 : struct klist_node *n = klist_prev(i);
2717 : 0 : struct device *dev = NULL;
2718 : 0 : struct device_private *p;
2719 : :
2720 [ # # ]: 0 : if (n) {
2721 : 0 : p = to_device_private_parent(n);
2722 : 0 : dev = p->device;
2723 : : }
2724 : 0 : return dev;
2725 : : }
2726 : :
2727 : 0 : static struct device *next_device(struct klist_iter *i)
2728 : : {
2729 : 0 : struct klist_node *n = klist_next(i);
2730 : 0 : struct device *dev = NULL;
2731 : 0 : struct device_private *p;
2732 : :
2733 [ # # # # : 0 : if (n) {
# # ]
2734 : 0 : p = to_device_private_parent(n);
2735 : 0 : dev = p->device;
2736 : : }
2737 : 0 : return dev;
2738 : : }
2739 : :
2740 : : /**
2741 : : * device_get_devnode - path of device node file
2742 : : * @dev: device
2743 : : * @mode: returned file access mode
2744 : : * @uid: returned file owner
2745 : : * @gid: returned file group
2746 : : * @tmp: possibly allocated string
2747 : : *
2748 : : * Return the relative path of a possible device node.
2749 : : * Non-default names may need to allocate a memory to compose
2750 : : * a name. This memory is returned in tmp and needs to be
2751 : : * freed by the caller.
2752 : : */
2753 : 17471 : const char *device_get_devnode(struct device *dev,
2754 : : umode_t *mode, kuid_t *uid, kgid_t *gid,
2755 : : const char **tmp)
2756 : : {
2757 : 17471 : char *s;
2758 : :
2759 : 17471 : *tmp = NULL;
2760 : :
2761 : : /* the device type may provide a specific name */
2762 [ + + + - ]: 17471 : if (dev->type && dev->type->devnode)
2763 : 1903 : *tmp = dev->type->devnode(dev, mode, uid, gid);
2764 [ + - ]: 17471 : if (*tmp)
2765 : : return *tmp;
2766 : :
2767 : : /* the class may provide a specific name */
2768 [ + - + + ]: 17471 : if (dev->class && dev->class->devnode)
2769 : 13860 : *tmp = dev->class->devnode(dev, mode);
2770 [ + + ]: 17471 : if (*tmp)
2771 : : return *tmp;
2772 : :
2773 : : /* return name without allocation, tmp == NULL */
2774 [ + - - + ]: 31582 : if (strchr(dev_name(dev), '!') == NULL)
2775 : : return dev_name(dev);
2776 : :
2777 : : /* replace '!' in the name with '/' */
2778 : 0 : s = kstrdup(dev_name(dev), GFP_KERNEL);
2779 [ # # ]: 0 : if (!s)
2780 : : return NULL;
2781 : 0 : strreplace(s, '!', '/');
2782 : 0 : return *tmp = s;
2783 : : }
2784 : :
2785 : : /**
2786 : : * device_for_each_child - device child iterator.
2787 : : * @parent: parent struct device.
2788 : : * @fn: function to be called for each device.
2789 : : * @data: data for the callback.
2790 : : *
2791 : : * Iterate over @parent's child devices, and call @fn for each,
2792 : : * passing it @data.
2793 : : *
2794 : : * We check the return of @fn each time. If it returns anything
2795 : : * other than 0, we break out and return that value.
2796 : : */
2797 : 0 : int device_for_each_child(struct device *parent, void *data,
2798 : : int (*fn)(struct device *dev, void *data))
2799 : : {
2800 : 0 : struct klist_iter i;
2801 : 0 : struct device *child;
2802 : 0 : int error = 0;
2803 : :
2804 [ # # ]: 0 : if (!parent->p)
2805 : : return 0;
2806 : :
2807 : 0 : klist_iter_init(&parent->p->klist_children, &i);
2808 [ # # # # ]: 0 : while (!error && (child = next_device(&i)))
2809 : 0 : error = fn(child, data);
2810 : 0 : klist_iter_exit(&i);
2811 : 0 : return error;
2812 : : }
2813 : : EXPORT_SYMBOL_GPL(device_for_each_child);
2814 : :
2815 : : /**
2816 : : * device_for_each_child_reverse - device child iterator in reversed order.
2817 : : * @parent: parent struct device.
2818 : : * @fn: function to be called for each device.
2819 : : * @data: data for the callback.
2820 : : *
2821 : : * Iterate over @parent's child devices, and call @fn for each,
2822 : : * passing it @data.
2823 : : *
2824 : : * We check the return of @fn each time. If it returns anything
2825 : : * other than 0, we break out and return that value.
2826 : : */
2827 : 0 : int device_for_each_child_reverse(struct device *parent, void *data,
2828 : : int (*fn)(struct device *dev, void *data))
2829 : : {
2830 : 0 : struct klist_iter i;
2831 : 0 : struct device *child;
2832 : 0 : int error = 0;
2833 : :
2834 [ # # ]: 0 : if (!parent->p)
2835 : : return 0;
2836 : :
2837 : 0 : klist_iter_init(&parent->p->klist_children, &i);
2838 [ # # # # ]: 0 : while ((child = prev_device(&i)) && !error)
2839 : 0 : error = fn(child, data);
2840 : 0 : klist_iter_exit(&i);
2841 : 0 : return error;
2842 : : }
2843 : : EXPORT_SYMBOL_GPL(device_for_each_child_reverse);
2844 : :
2845 : : /**
2846 : : * device_find_child - device iterator for locating a particular device.
2847 : : * @parent: parent struct device
2848 : : * @match: Callback function to check device
2849 : : * @data: Data to pass to match function
2850 : : *
2851 : : * This is similar to the device_for_each_child() function above, but it
2852 : : * returns a reference to a device that is 'found' for later use, as
2853 : : * determined by the @match callback.
2854 : : *
2855 : : * The callback should return 0 if the device doesn't match and non-zero
2856 : : * if it does. If the callback returns non-zero and a reference to the
2857 : : * current device can be obtained, this function will return to the caller
2858 : : * and not iterate over any more devices.
2859 : : *
2860 : : * NOTE: you will need to drop the reference with put_device() after use.
2861 : : */
2862 : 0 : struct device *device_find_child(struct device *parent, void *data,
2863 : : int (*match)(struct device *dev, void *data))
2864 : : {
2865 : 0 : struct klist_iter i;
2866 : 0 : struct device *child;
2867 : :
2868 [ # # ]: 0 : if (!parent)
2869 : : return NULL;
2870 : :
2871 : 0 : klist_iter_init(&parent->p->klist_children, &i);
2872 [ # # ]: 0 : while ((child = next_device(&i)))
2873 [ # # # # ]: 0 : if (match(child, data) && get_device(child))
2874 : : break;
2875 : 0 : klist_iter_exit(&i);
2876 : 0 : return child;
2877 : : }
2878 : : EXPORT_SYMBOL_GPL(device_find_child);
2879 : :
2880 : : /**
2881 : : * device_find_child_by_name - device iterator for locating a child device.
2882 : : * @parent: parent struct device
2883 : : * @name: name of the child device
2884 : : *
2885 : : * This is similar to the device_find_child() function above, but it
2886 : : * returns a reference to a device that has the name @name.
2887 : : *
2888 : : * NOTE: you will need to drop the reference with put_device() after use.
2889 : : */
2890 : 0 : struct device *device_find_child_by_name(struct device *parent,
2891 : : const char *name)
2892 : : {
2893 : 0 : struct klist_iter i;
2894 : 0 : struct device *child;
2895 : :
2896 [ # # ]: 0 : if (!parent)
2897 : : return NULL;
2898 : :
2899 : 0 : klist_iter_init(&parent->p->klist_children, &i);
2900 [ # # ]: 0 : while ((child = next_device(&i)))
2901 [ # # # # : 0 : if (!strcmp(dev_name(child), name) && get_device(child))
# # ]
2902 : : break;
2903 : 0 : klist_iter_exit(&i);
2904 : 0 : return child;
2905 : : }
2906 : : EXPORT_SYMBOL_GPL(device_find_child_by_name);
2907 : :
2908 : 28 : int __init devices_init(void)
2909 : : {
2910 : 28 : devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
2911 [ + - ]: 28 : if (!devices_kset)
2912 : : return -ENOMEM;
2913 : 28 : dev_kobj = kobject_create_and_add("dev", NULL);
2914 [ - + ]: 28 : if (!dev_kobj)
2915 : 0 : goto dev_kobj_err;
2916 : 28 : sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
2917 [ - + ]: 28 : if (!sysfs_dev_block_kobj)
2918 : 0 : goto block_kobj_err;
2919 : 28 : sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
2920 [ - + ]: 28 : if (!sysfs_dev_char_kobj)
2921 : 0 : goto char_kobj_err;
2922 : :
2923 : : return 0;
2924 : :
2925 : : char_kobj_err:
2926 : 0 : kobject_put(sysfs_dev_block_kobj);
2927 : 0 : block_kobj_err:
2928 : 0 : kobject_put(dev_kobj);
2929 : 0 : dev_kobj_err:
2930 : 0 : kset_unregister(devices_kset);
2931 : 0 : return -ENOMEM;
2932 : : }
2933 : :
2934 : 0 : static int device_check_offline(struct device *dev, void *not_used)
2935 : : {
2936 : 0 : int ret;
2937 : :
2938 : 0 : ret = device_for_each_child(dev, NULL, device_check_offline);
2939 [ # # ]: 0 : if (ret)
2940 : : return ret;
2941 : :
2942 [ # # # # : 0 : return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0;
# # ]
2943 : : }
2944 : :
2945 : : /**
2946 : : * device_offline - Prepare the device for hot-removal.
2947 : : * @dev: Device to be put offline.
2948 : : *
2949 : : * Execute the device bus type's .offline() callback, if present, to prepare
2950 : : * the device for a subsequent hot-removal. If that succeeds, the device must
2951 : : * not be used until either it is removed or its bus type's .online() callback
2952 : : * is executed.
2953 : : *
2954 : : * Call under device_hotplug_lock.
2955 : : */
2956 : 0 : int device_offline(struct device *dev)
2957 : : {
2958 : 0 : int ret;
2959 : :
2960 [ # # ]: 0 : if (dev->offline_disabled)
2961 : : return -EPERM;
2962 : :
2963 : 0 : ret = device_for_each_child(dev, NULL, device_check_offline);
2964 [ # # ]: 0 : if (ret)
2965 : : return ret;
2966 : :
2967 : 0 : device_lock(dev);
2968 [ # # # # ]: 0 : if (device_supports_offline(dev)) {
2969 [ # # ]: 0 : if (dev->offline) {
2970 : : ret = 1;
2971 : : } else {
2972 : 0 : ret = dev->bus->offline(dev);
2973 [ # # ]: 0 : if (!ret) {
2974 : 0 : kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
2975 : 0 : dev->offline = true;
2976 : : }
2977 : : }
2978 : : }
2979 : 0 : device_unlock(dev);
2980 : :
2981 : 0 : return ret;
2982 : : }
2983 : :
2984 : : /**
2985 : : * device_online - Put the device back online after successful device_offline().
2986 : : * @dev: Device to be put back online.
2987 : : *
2988 : : * If device_offline() has been successfully executed for @dev, but the device
2989 : : * has not been removed subsequently, execute its bus type's .online() callback
2990 : : * to indicate that the device can be used again.
2991 : : *
2992 : : * Call under device_hotplug_lock.
2993 : : */
2994 : 0 : int device_online(struct device *dev)
2995 : : {
2996 : 0 : int ret = 0;
2997 : :
2998 : 0 : device_lock(dev);
2999 [ # # # # ]: 0 : if (device_supports_offline(dev)) {
3000 [ # # ]: 0 : if (dev->offline) {
3001 : 0 : ret = dev->bus->online(dev);
3002 [ # # ]: 0 : if (!ret) {
3003 : 0 : kobject_uevent(&dev->kobj, KOBJ_ONLINE);
3004 : 0 : dev->offline = false;
3005 : : }
3006 : : } else {
3007 : : ret = 1;
3008 : : }
3009 : : }
3010 : 0 : device_unlock(dev);
3011 : :
3012 : 0 : return ret;
3013 : : }
3014 : :
3015 : : struct root_device {
3016 : : struct device dev;
3017 : : struct module *owner;
3018 : : };
3019 : :
3020 : 0 : static inline struct root_device *to_root_device(struct device *d)
3021 : : {
3022 : 0 : return container_of(d, struct root_device, dev);
3023 : : }
3024 : :
3025 : 0 : static void root_device_release(struct device *dev)
3026 : : {
3027 : 0 : kfree(to_root_device(dev));
3028 : 0 : }
3029 : :
3030 : : /**
3031 : : * __root_device_register - allocate and register a root device
3032 : : * @name: root device name
3033 : : * @owner: owner module of the root device, usually THIS_MODULE
3034 : : *
3035 : : * This function allocates a root device and registers it
3036 : : * using device_register(). In order to free the returned
3037 : : * device, use root_device_unregister().
3038 : : *
3039 : : * Root devices are dummy devices which allow other devices
3040 : : * to be grouped under /sys/devices. Use this function to
3041 : : * allocate a root device and then use it as the parent of
3042 : : * any device which should appear under /sys/devices/{name}
3043 : : *
3044 : : * The /sys/devices/{name} directory will also contain a
3045 : : * 'module' symlink which points to the @owner directory
3046 : : * in sysfs.
3047 : : *
3048 : : * Returns &struct device pointer on success, or ERR_PTR() on error.
3049 : : *
3050 : : * Note: You probably want to use root_device_register().
3051 : : */
3052 : 0 : struct device *__root_device_register(const char *name, struct module *owner)
3053 : : {
3054 : 0 : struct root_device *root;
3055 : 0 : int err = -ENOMEM;
3056 : :
3057 : 0 : root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
3058 [ # # ]: 0 : if (!root)
3059 : : return ERR_PTR(err);
3060 : :
3061 : 0 : err = dev_set_name(&root->dev, "%s", name);
3062 [ # # ]: 0 : if (err) {
3063 : 0 : kfree(root);
3064 : 0 : return ERR_PTR(err);
3065 : : }
3066 : :
3067 : 0 : root->dev.release = root_device_release;
3068 : :
3069 : 0 : err = device_register(&root->dev);
3070 [ # # ]: 0 : if (err) {
3071 : 0 : put_device(&root->dev);
3072 : 0 : return ERR_PTR(err);
3073 : : }
3074 : :
3075 : : #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */
3076 [ # # ]: 0 : if (owner) {
3077 : 0 : struct module_kobject *mk = &owner->mkobj;
3078 : :
3079 : 0 : err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
3080 [ # # ]: 0 : if (err) {
3081 : 0 : device_unregister(&root->dev);
3082 : 0 : return ERR_PTR(err);
3083 : : }
3084 : 0 : root->owner = owner;
3085 : : }
3086 : : #endif
3087 : :
3088 : : return &root->dev;
3089 : : }
3090 : : EXPORT_SYMBOL_GPL(__root_device_register);
3091 : :
3092 : : /**
3093 : : * root_device_unregister - unregister and free a root device
3094 : : * @dev: device going away
3095 : : *
3096 : : * This function unregisters and cleans up a device that was created by
3097 : : * root_device_register().
3098 : : */
3099 : 0 : void root_device_unregister(struct device *dev)
3100 : : {
3101 : 0 : struct root_device *root = to_root_device(dev);
3102 : :
3103 [ # # ]: 0 : if (root->owner)
3104 : 0 : sysfs_remove_link(&root->dev.kobj, "module");
3105 : :
3106 : 0 : device_unregister(dev);
3107 : 0 : }
3108 : : EXPORT_SYMBOL_GPL(root_device_unregister);
3109 : :
3110 : :
3111 : 0 : static void device_create_release(struct device *dev)
3112 : : {
3113 : 0 : pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3114 : 0 : kfree(dev);
3115 : 0 : }
3116 : :
3117 : : static __printf(6, 0) struct device *
3118 : 1512 : device_create_groups_vargs(struct class *class, struct device *parent,
3119 : : dev_t devt, void *drvdata,
3120 : : const struct attribute_group **groups,
3121 : : const char *fmt, va_list args)
3122 : : {
3123 : 1512 : struct device *dev = NULL;
3124 : 1512 : int retval = -ENODEV;
3125 : :
3126 [ + - - + ]: 1512 : if (class == NULL || IS_ERR(class))
3127 : 0 : goto error;
3128 : :
3129 : 1512 : dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3130 [ - + ]: 1512 : if (!dev) {
3131 : 0 : retval = -ENOMEM;
3132 : 0 : goto error;
3133 : : }
3134 : :
3135 : 1512 : device_initialize(dev);
3136 : 1512 : dev->devt = devt;
3137 : 1512 : dev->class = class;
3138 : 1512 : dev->parent = parent;
3139 : 1512 : dev->groups = groups;
3140 : 1512 : dev->release = device_create_release;
3141 : 1512 : dev_set_drvdata(dev, drvdata);
3142 : :
3143 : 1512 : retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
3144 [ - + ]: 1512 : if (retval)
3145 : 0 : goto error;
3146 : :
3147 : 1512 : retval = device_add(dev);
3148 [ - + ]: 1512 : if (retval)
3149 : 0 : goto error;
3150 : :
3151 : : return dev;
3152 : :
3153 : 0 : error:
3154 [ # # ]: 0 : put_device(dev);
3155 : 0 : return ERR_PTR(retval);
3156 : : }
3157 : :
3158 : : /**
3159 : : * device_create_vargs - creates a device and registers it with sysfs
3160 : : * @class: pointer to the struct class that this device should be registered to
3161 : : * @parent: pointer to the parent struct device of this new device, if any
3162 : : * @devt: the dev_t for the char device to be added
3163 : : * @drvdata: the data to be added to the device for callbacks
3164 : : * @fmt: string for the device's name
3165 : : * @args: va_list for the device's name
3166 : : *
3167 : : * This function can be used by char device classes. A struct device
3168 : : * will be created in sysfs, registered to the specified class.
3169 : : *
3170 : : * A "dev" file will be created, showing the dev_t for the device, if
3171 : : * the dev_t is not 0,0.
3172 : : * If a pointer to a parent struct device is passed in, the newly created
3173 : : * struct device will be a child of that device in sysfs.
3174 : : * The pointer to the struct device will be returned from the call.
3175 : : * Any further sysfs files that might be required can be created using this
3176 : : * pointer.
3177 : : *
3178 : : * Returns &struct device pointer on success, or ERR_PTR() on error.
3179 : : *
3180 : : * Note: the struct class passed to this function must have previously
3181 : : * been created with a call to class_create().
3182 : : */
3183 : 1064 : struct device *device_create_vargs(struct class *class, struct device *parent,
3184 : : dev_t devt, void *drvdata, const char *fmt,
3185 : : va_list args)
3186 : : {
3187 : 336 : return device_create_groups_vargs(class, parent, devt, drvdata, NULL,
3188 : : fmt, args);
3189 : : }
3190 : : EXPORT_SYMBOL_GPL(device_create_vargs);
3191 : :
3192 : : /**
3193 : : * device_create - creates a device and registers it with sysfs
3194 : : * @class: pointer to the struct class that this device should be registered to
3195 : : * @parent: pointer to the parent struct device of this new device, if any
3196 : : * @devt: the dev_t for the char device to be added
3197 : : * @drvdata: the data to be added to the device for callbacks
3198 : : * @fmt: string for the device's name
3199 : : *
3200 : : * This function can be used by char device classes. A struct device
3201 : : * will be created in sysfs, registered to the specified class.
3202 : : *
3203 : : * A "dev" file will be created, showing the dev_t for the device, if
3204 : : * the dev_t is not 0,0.
3205 : : * If a pointer to a parent struct device is passed in, the newly created
3206 : : * struct device will be a child of that device in sysfs.
3207 : : * The pointer to the struct device will be returned from the call.
3208 : : * Any further sysfs files that might be required can be created using this
3209 : : * pointer.
3210 : : *
3211 : : * Returns &struct device pointer on success, or ERR_PTR() on error.
3212 : : *
3213 : : * Note: the struct class passed to this function must have previously
3214 : : * been created with a call to class_create().
3215 : : */
3216 : 728 : struct device *device_create(struct class *class, struct device *parent,
3217 : : dev_t devt, void *drvdata, const char *fmt, ...)
3218 : : {
3219 : 728 : va_list vargs;
3220 : 728 : struct device *dev;
3221 : :
3222 : 728 : va_start(vargs, fmt);
3223 : 728 : dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
3224 : 728 : va_end(vargs);
3225 : 728 : return dev;
3226 : : }
3227 : : EXPORT_SYMBOL_GPL(device_create);
3228 : :
3229 : : /**
3230 : : * device_create_with_groups - creates a device and registers it with sysfs
3231 : : * @class: pointer to the struct class that this device should be registered to
3232 : : * @parent: pointer to the parent struct device of this new device, if any
3233 : : * @devt: the dev_t for the char device to be added
3234 : : * @drvdata: the data to be added to the device for callbacks
3235 : : * @groups: NULL-terminated list of attribute groups to be created
3236 : : * @fmt: string for the device's name
3237 : : *
3238 : : * This function can be used by char device classes. A struct device
3239 : : * will be created in sysfs, registered to the specified class.
3240 : : * Additional attributes specified in the groups parameter will also
3241 : : * be created automatically.
3242 : : *
3243 : : * A "dev" file will be created, showing the dev_t for the device, if
3244 : : * the dev_t is not 0,0.
3245 : : * If a pointer to a parent struct device is passed in, the newly created
3246 : : * struct device will be a child of that device in sysfs.
3247 : : * The pointer to the struct device will be returned from the call.
3248 : : * Any further sysfs files that might be required can be created using this
3249 : : * pointer.
3250 : : *
3251 : : * Returns &struct device pointer on success, or ERR_PTR() on error.
3252 : : *
3253 : : * Note: the struct class passed to this function must have previously
3254 : : * been created with a call to class_create().
3255 : : */
3256 : 448 : struct device *device_create_with_groups(struct class *class,
3257 : : struct device *parent, dev_t devt,
3258 : : void *drvdata,
3259 : : const struct attribute_group **groups,
3260 : : const char *fmt, ...)
3261 : : {
3262 : 448 : va_list vargs;
3263 : 448 : struct device *dev;
3264 : :
3265 : 448 : va_start(vargs, fmt);
3266 : 448 : dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,
3267 : : fmt, vargs);
3268 : 448 : va_end(vargs);
3269 : 448 : return dev;
3270 : : }
3271 : : EXPORT_SYMBOL_GPL(device_create_with_groups);
3272 : :
3273 : : /**
3274 : : * device_destroy - removes a device that was created with device_create()
3275 : : * @class: pointer to the struct class that this device was registered with
3276 : : * @devt: the dev_t of the device that was previously registered
3277 : : *
3278 : : * This call unregisters and cleans up a device that was created with a
3279 : : * call to device_create().
3280 : : */
3281 : 0 : void device_destroy(struct class *class, dev_t devt)
3282 : : {
3283 : 0 : struct device *dev;
3284 : :
3285 : 0 : dev = class_find_device_by_devt(class, devt);
3286 [ # # ]: 0 : if (dev) {
3287 : 0 : put_device(dev);
3288 : 0 : device_unregister(dev);
3289 : : }
3290 : 0 : }
3291 : : EXPORT_SYMBOL_GPL(device_destroy);
3292 : :
3293 : : /**
3294 : : * device_rename - renames a device
3295 : : * @dev: the pointer to the struct device to be renamed
3296 : : * @new_name: the new name of the device
3297 : : *
3298 : : * It is the responsibility of the caller to provide mutual
3299 : : * exclusion between two different calls of device_rename
3300 : : * on the same device to ensure that new_name is valid and
3301 : : * won't conflict with other devices.
3302 : : *
3303 : : * Note: Don't call this function. Currently, the networking layer calls this
3304 : : * function, but that will change. The following text from Kay Sievers offers
3305 : : * some insight:
3306 : : *
3307 : : * Renaming devices is racy at many levels, symlinks and other stuff are not
3308 : : * replaced atomically, and you get a "move" uevent, but it's not easy to
3309 : : * connect the event to the old and new device. Device nodes are not renamed at
3310 : : * all, there isn't even support for that in the kernel now.
3311 : : *
3312 : : * In the meantime, during renaming, your target name might be taken by another
3313 : : * driver, creating conflicts. Or the old name is taken directly after you
3314 : : * renamed it -- then you get events for the same DEVPATH, before you even see
3315 : : * the "move" event. It's just a mess, and nothing new should ever rely on
3316 : : * kernel device renaming. Besides that, it's not even implemented now for
3317 : : * other things than (driver-core wise very simple) network devices.
3318 : : *
3319 : : * We are currently about to change network renaming in udev to completely
3320 : : * disallow renaming of devices in the same namespace as the kernel uses,
3321 : : * because we can't solve the problems properly, that arise with swapping names
3322 : : * of multiple interfaces without races. Means, renaming of eth[0-9]* will only
3323 : : * be allowed to some other name than eth[0-9]*, for the aforementioned
3324 : : * reasons.
3325 : : *
3326 : : * Make up a "real" name in the driver before you register anything, or add
3327 : : * some other attributes for userspace to find the device, or use udev to add
3328 : : * symlinks -- but never rename kernel devices later, it's a complete mess. We
3329 : : * don't even want to get into that and try to implement the missing pieces in
3330 : : * the core. We really have other pieces to fix in the driver core mess. :)
3331 : : */
3332 : 0 : int device_rename(struct device *dev, const char *new_name)
3333 : : {
3334 : 0 : struct kobject *kobj = &dev->kobj;
3335 : 0 : char *old_device_name = NULL;
3336 : 0 : int error;
3337 : :
3338 [ # # ]: 0 : dev = get_device(dev);
3339 [ # # ]: 0 : if (!dev)
3340 : 0 : return -EINVAL;
3341 : :
3342 : 0 : dev_dbg(dev, "renaming to %s\n", new_name);
3343 : :
3344 [ # # ]: 0 : old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
3345 [ # # ]: 0 : if (!old_device_name) {
3346 : 0 : error = -ENOMEM;
3347 : 0 : goto out;
3348 : : }
3349 : :
3350 [ # # ]: 0 : if (dev->class) {
3351 : 0 : error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj,
3352 : : kobj, old_device_name,
3353 : : new_name, kobject_namespace(kobj));
3354 [ # # ]: 0 : if (error)
3355 : 0 : goto out;
3356 : : }
3357 : :
3358 : 0 : error = kobject_rename(kobj, new_name);
3359 [ # # ]: 0 : if (error)
3360 : 0 : goto out;
3361 : :
3362 : 0 : out:
3363 : 0 : put_device(dev);
3364 : :
3365 : 0 : kfree(old_device_name);
3366 : :
3367 : 0 : return error;
3368 : : }
3369 : : EXPORT_SYMBOL_GPL(device_rename);
3370 : :
3371 : 0 : static int device_move_class_links(struct device *dev,
3372 : : struct device *old_parent,
3373 : : struct device *new_parent)
3374 : : {
3375 : 0 : int error = 0;
3376 : :
3377 [ # # ]: 0 : if (old_parent)
3378 : 0 : sysfs_remove_link(&dev->kobj, "device");
3379 [ # # ]: 0 : if (new_parent)
3380 : 0 : error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
3381 : : "device");
3382 : 0 : return error;
3383 : : }
3384 : :
3385 : : /**
3386 : : * device_move - moves a device to a new parent
3387 : : * @dev: the pointer to the struct device to be moved
3388 : : * @new_parent: the new parent of the device (can be NULL)
3389 : : * @dpm_order: how to reorder the dpm_list
3390 : : */
3391 : 0 : int device_move(struct device *dev, struct device *new_parent,
3392 : : enum dpm_order dpm_order)
3393 : : {
3394 : 0 : int error;
3395 : 0 : struct device *old_parent;
3396 : 0 : struct kobject *new_parent_kobj;
3397 : :
3398 [ # # ]: 0 : dev = get_device(dev);
3399 [ # # ]: 0 : if (!dev)
3400 : 0 : return -EINVAL;
3401 : :
3402 : 0 : device_pm_lock();
3403 [ # # ]: 0 : new_parent = get_device(new_parent);
3404 : 0 : new_parent_kobj = get_device_parent(dev, new_parent);
3405 [ # # ]: 0 : if (IS_ERR(new_parent_kobj)) {
3406 [ # # ]: 0 : error = PTR_ERR(new_parent_kobj);
3407 [ # # ]: 0 : put_device(new_parent);
3408 : 0 : goto out;
3409 : : }
3410 : :
3411 : 0 : pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
3412 : : __func__, new_parent ? dev_name(new_parent) : "<NULL>");
3413 : 0 : error = kobject_move(&dev->kobj, new_parent_kobj);
3414 [ # # ]: 0 : if (error) {
3415 : 0 : cleanup_glue_dir(dev, new_parent_kobj);
3416 [ # # ]: 0 : put_device(new_parent);
3417 : 0 : goto out;
3418 : : }
3419 : 0 : old_parent = dev->parent;
3420 : 0 : dev->parent = new_parent;
3421 [ # # ]: 0 : if (old_parent)
3422 : 0 : klist_remove(&dev->p->knode_parent);
3423 [ # # ]: 0 : if (new_parent) {
3424 : 0 : klist_add_tail(&dev->p->knode_parent,
3425 : 0 : &new_parent->p->klist_children);
3426 : 0 : set_dev_node(dev, dev_to_node(new_parent));
3427 : : }
3428 : :
3429 [ # # ]: 0 : if (dev->class) {
3430 : 0 : error = device_move_class_links(dev, old_parent, new_parent);
3431 [ # # ]: 0 : if (error) {
3432 : : /* We ignore errors on cleanup since we're hosed anyway... */
3433 : 0 : device_move_class_links(dev, new_parent, old_parent);
3434 [ # # ]: 0 : if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
3435 [ # # ]: 0 : if (new_parent)
3436 : 0 : klist_remove(&dev->p->knode_parent);
3437 : 0 : dev->parent = old_parent;
3438 [ # # ]: 0 : if (old_parent) {
3439 : 0 : klist_add_tail(&dev->p->knode_parent,
3440 : 0 : &old_parent->p->klist_children);
3441 : 0 : set_dev_node(dev, dev_to_node(old_parent));
3442 : : }
3443 : : }
3444 : 0 : cleanup_glue_dir(dev, new_parent_kobj);
3445 [ # # ]: 0 : put_device(new_parent);
3446 : 0 : goto out;
3447 : : }
3448 : : }
3449 [ # # # # ]: 0 : switch (dpm_order) {
3450 : : case DPM_ORDER_NONE:
3451 : : break;
3452 : 0 : case DPM_ORDER_DEV_AFTER_PARENT:
3453 : 0 : device_pm_move_after(dev, new_parent);
3454 : 0 : devices_kset_move_after(dev, new_parent);
3455 : 0 : break;
3456 : 0 : case DPM_ORDER_PARENT_BEFORE_DEV:
3457 : 0 : device_pm_move_before(new_parent, dev);
3458 : 0 : devices_kset_move_before(new_parent, dev);
3459 : 0 : break;
3460 : 0 : case DPM_ORDER_DEV_LAST:
3461 : 0 : device_pm_move_last(dev);
3462 : 0 : devices_kset_move_last(dev);
3463 : 0 : break;
3464 : : }
3465 : :
3466 [ # # ]: 0 : put_device(old_parent);
3467 : 0 : out:
3468 : 0 : device_pm_unlock();
3469 : 0 : put_device(dev);
3470 : 0 : return error;
3471 : : }
3472 : : EXPORT_SYMBOL_GPL(device_move);
3473 : :
3474 : : /**
3475 : : * device_shutdown - call ->shutdown() on each device to shutdown.
3476 : : */
3477 : 0 : void device_shutdown(void)
3478 : : {
3479 : 0 : struct device *dev, *parent;
3480 : :
3481 : 0 : wait_for_device_probe();
3482 : 0 : device_block_probing();
3483 : :
3484 : 0 : cpufreq_suspend();
3485 : :
3486 : 0 : spin_lock(&devices_kset->list_lock);
3487 : : /*
3488 : : * Walk the devices list backward, shutting down each in turn.
3489 : : * Beware that device unplug events may also start pulling
3490 : : * devices offline, even as the system is shutting down.
3491 : : */
3492 [ # # ]: 0 : while (!list_empty(&devices_kset->list)) {
3493 : 0 : dev = list_entry(devices_kset->list.prev, struct device,
3494 : : kobj.entry);
3495 : :
3496 : : /*
3497 : : * hold reference count of device's parent to
3498 : : * prevent it from being freed because parent's
3499 : : * lock is to be held
3500 : : */
3501 [ # # ]: 0 : parent = get_device(dev->parent);
3502 [ # # ]: 0 : get_device(dev);
3503 : : /*
3504 : : * Make sure the device is off the kset list, in the
3505 : : * event that dev->*->shutdown() doesn't remove it.
3506 : : */
3507 : 0 : list_del_init(&dev->kobj.entry);
3508 : 0 : spin_unlock(&devices_kset->list_lock);
3509 : :
3510 : : /* hold lock to avoid race with probe/release */
3511 [ # # ]: 0 : if (parent)
3512 : 0 : device_lock(parent);
3513 : 0 : device_lock(dev);
3514 : :
3515 : : /* Don't allow any more runtime suspends */
3516 : 0 : pm_runtime_get_noresume(dev);
3517 : 0 : pm_runtime_barrier(dev);
3518 : :
3519 [ # # # # ]: 0 : if (dev->class && dev->class->shutdown_pre) {
3520 [ # # ]: 0 : if (initcall_debug)
3521 : 0 : dev_info(dev, "shutdown_pre\n");
3522 : 0 : dev->class->shutdown_pre(dev);
3523 : : }
3524 [ # # # # ]: 0 : if (dev->bus && dev->bus->shutdown) {
3525 [ # # ]: 0 : if (initcall_debug)
3526 : 0 : dev_info(dev, "shutdown\n");
3527 : 0 : dev->bus->shutdown(dev);
3528 [ # # # # ]: 0 : } else if (dev->driver && dev->driver->shutdown) {
3529 [ # # ]: 0 : if (initcall_debug)
3530 : 0 : dev_info(dev, "shutdown\n");
3531 : 0 : dev->driver->shutdown(dev);
3532 : : }
3533 : :
3534 : 0 : device_unlock(dev);
3535 [ # # ]: 0 : if (parent)
3536 : 0 : device_unlock(parent);
3537 : :
3538 [ # # ]: 0 : put_device(dev);
3539 [ # # ]: 0 : put_device(parent);
3540 : :
3541 : 0 : spin_lock(&devices_kset->list_lock);
3542 : : }
3543 : 0 : spin_unlock(&devices_kset->list_lock);
3544 : 0 : }
3545 : :
3546 : : /*
3547 : : * Device logging functions
3548 : : */
3549 : :
3550 : : #ifdef CONFIG_PRINTK
3551 : : static int
3552 : 2180 : create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
3553 : : {
3554 : 2180 : const char *subsys;
3555 : 2180 : size_t pos = 0;
3556 : :
3557 [ + + ]: 2180 : if (dev->class)
3558 : 252 : subsys = dev->class->name;
3559 [ + - ]: 1928 : else if (dev->bus)
3560 : 1928 : subsys = dev->bus->name;
3561 : : else
3562 : : return 0;
3563 : :
3564 : 2180 : pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
3565 [ - + ]: 2180 : if (pos >= hdrlen)
3566 : 0 : goto overflow;
3567 : :
3568 : : /*
3569 : : * Add device identifier DEVICE=:
3570 : : * b12:8 block dev_t
3571 : : * c127:3 char dev_t
3572 : : * n8 netdev ifindex
3573 : : * +sound:card0 subsystem:devname
3574 : : */
3575 [ - + ]: 2180 : if (MAJOR(dev->devt)) {
3576 : 0 : char c;
3577 : :
3578 [ # # ]: 0 : if (strcmp(subsys, "block") == 0)
3579 : : c = 'b';
3580 : : else
3581 : 0 : c = 'c';
3582 : 0 : pos++;
3583 : 0 : pos += snprintf(hdr + pos, hdrlen - pos,
3584 : : "DEVICE=%c%u:%u",
3585 : : c, MAJOR(dev->devt), MINOR(dev->devt));
3586 [ - + ]: 2180 : } else if (strcmp(subsys, "net") == 0) {
3587 : 0 : struct net_device *net = to_net_dev(dev);
3588 : :
3589 : 0 : pos++;
3590 : 0 : pos += snprintf(hdr + pos, hdrlen - pos,
3591 : : "DEVICE=n%u", net->ifindex);
3592 : : } else {
3593 : 2180 : pos++;
3594 [ + - ]: 4360 : pos += snprintf(hdr + pos, hdrlen - pos,
3595 : : "DEVICE=+%s:%s", subsys, dev_name(dev));
3596 : : }
3597 : :
3598 [ - + ]: 2180 : if (pos >= hdrlen)
3599 : 0 : goto overflow;
3600 : :
3601 : 2180 : return pos;
3602 : :
3603 : 0 : overflow:
3604 [ # # ]: 0 : dev_WARN(dev, "device/subsystem name too long");
3605 : 0 : return 0;
3606 : : }
3607 : :
3608 : 2180 : int dev_vprintk_emit(int level, const struct device *dev,
3609 : : const char *fmt, va_list args)
3610 : : {
3611 : 2180 : char hdr[128];
3612 : 2180 : size_t hdrlen;
3613 : :
3614 : 2180 : hdrlen = create_syslog_header(dev, hdr, sizeof(hdr));
3615 : :
3616 [ - + ]: 2180 : return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args);
3617 : : }
3618 : : EXPORT_SYMBOL(dev_vprintk_emit);
3619 : :
3620 : 2180 : int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
3621 : : {
3622 : 2180 : va_list args;
3623 : 2180 : int r;
3624 : :
3625 : 2180 : va_start(args, fmt);
3626 : :
3627 : 2180 : r = dev_vprintk_emit(level, dev, fmt, args);
3628 : :
3629 : 2180 : va_end(args);
3630 : :
3631 : 2180 : return r;
3632 : : }
3633 : : EXPORT_SYMBOL(dev_printk_emit);
3634 : :
3635 : 2180 : static void __dev_printk(const char *level, const struct device *dev,
3636 : : struct va_format *vaf)
3637 : : {
3638 [ + - ]: 2180 : if (dev)
3639 [ + - ]: 4360 : dev_printk_emit(level[1] - '0', dev, "%s %s: %pV",
3640 : : dev_driver_string(dev), dev_name(dev), vaf);
3641 : : else
3642 : 0 : printk("%s(NULL device *): %pV", level, vaf);
3643 : 2180 : }
3644 : :
3645 : 784 : void dev_printk(const char *level, const struct device *dev,
3646 : : const char *fmt, ...)
3647 : : {
3648 : 784 : struct va_format vaf;
3649 : 784 : va_list args;
3650 : :
3651 : 784 : va_start(args, fmt);
3652 : :
3653 : 784 : vaf.fmt = fmt;
3654 : 784 : vaf.va = &args;
3655 : :
3656 : 784 : __dev_printk(level, dev, &vaf);
3657 : :
3658 : 784 : va_end(args);
3659 : 784 : }
3660 : : EXPORT_SYMBOL(dev_printk);
3661 : :
3662 : : #define define_dev_printk_level(func, kern_level) \
3663 : : void func(const struct device *dev, const char *fmt, ...) \
3664 : : { \
3665 : : struct va_format vaf; \
3666 : : va_list args; \
3667 : : \
3668 : : va_start(args, fmt); \
3669 : : \
3670 : : vaf.fmt = fmt; \
3671 : : vaf.va = &args; \
3672 : : \
3673 : : __dev_printk(kern_level, dev, &vaf); \
3674 : : \
3675 : : va_end(args); \
3676 : : } \
3677 : : EXPORT_SYMBOL(func);
3678 : :
3679 : 0 : define_dev_printk_level(_dev_emerg, KERN_EMERG);
3680 : 0 : define_dev_printk_level(_dev_alert, KERN_ALERT);
3681 : 0 : define_dev_printk_level(_dev_crit, KERN_CRIT);
3682 : 134 : define_dev_printk_level(_dev_err, KERN_ERR);
3683 : 94 : define_dev_printk_level(_dev_warn, KERN_WARNING);
3684 : 0 : define_dev_printk_level(_dev_notice, KERN_NOTICE);
3685 : 1168 : define_dev_printk_level(_dev_info, KERN_INFO);
3686 : :
3687 : : #endif
3688 : :
3689 : 476 : static inline bool fwnode_is_primary(struct fwnode_handle *fwnode)
3690 : : {
3691 [ # # # # : 0 : return fwnode && !IS_ERR(fwnode->secondary);
# # ]
3692 : : }
3693 : :
3694 : : /**
3695 : : * set_primary_fwnode - Change the primary firmware node of a given device.
3696 : : * @dev: Device to handle.
3697 : : * @fwnode: New primary firmware node of the device.
3698 : : *
3699 : : * Set the device's firmware node pointer to @fwnode, but if a secondary
3700 : : * firmware node of the device is present, preserve it.
3701 : : */
3702 : 476 : void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
3703 : : {
3704 [ + - ]: 476 : if (fwnode) {
3705 : 476 : struct fwnode_handle *fn = dev->fwnode;
3706 : :
3707 [ - + - + ]: 476 : if (fwnode_is_primary(fn))
3708 : 0 : fn = fn->secondary;
3709 : :
3710 [ - + ]: 476 : if (fn) {
3711 [ # # ]: 0 : WARN_ON(fwnode->secondary);
3712 : 0 : fwnode->secondary = fn;
3713 : : }
3714 : 476 : dev->fwnode = fwnode;
3715 : : } else {
3716 [ # # ]: 0 : dev->fwnode = fwnode_is_primary(dev->fwnode) ?
3717 [ # # ]: 0 : dev->fwnode->secondary : NULL;
3718 : : }
3719 : 476 : }
3720 : : EXPORT_SYMBOL_GPL(set_primary_fwnode);
3721 : :
3722 : : /**
3723 : : * set_secondary_fwnode - Change the secondary firmware node of a given device.
3724 : : * @dev: Device to handle.
3725 : : * @fwnode: New secondary firmware node of the device.
3726 : : *
3727 : : * If a primary firmware node of the device is present, set its secondary
3728 : : * pointer to @fwnode. Otherwise, set the device's firmware node pointer to
3729 : : * @fwnode.
3730 : : */
3731 : 0 : void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
3732 : : {
3733 [ # # ]: 0 : if (fwnode)
3734 : 0 : fwnode->secondary = ERR_PTR(-ENODEV);
3735 : :
3736 [ # # # # ]: 0 : if (fwnode_is_primary(dev->fwnode))
3737 : 0 : dev->fwnode->secondary = fwnode;
3738 : : else
3739 : 0 : dev->fwnode = fwnode;
3740 : 0 : }
3741 : :
3742 : : /**
3743 : : * device_set_of_node_from_dev - reuse device-tree node of another device
3744 : : * @dev: device whose device-tree node is being set
3745 : : * @dev2: device whose device-tree node is being reused
3746 : : *
3747 : : * Takes another reference to the new device-tree node after first dropping
3748 : : * any reference held to the old node.
3749 : : */
3750 : 0 : void device_set_of_node_from_dev(struct device *dev, const struct device *dev2)
3751 : : {
3752 : 0 : of_node_put(dev->of_node);
3753 : 0 : dev->of_node = of_node_get(dev2->of_node);
3754 : 0 : dev->of_node_reused = true;
3755 : 0 : }
3756 : : EXPORT_SYMBOL_GPL(device_set_of_node_from_dev);
3757 : :
3758 : 84 : int device_match_name(struct device *dev, const void *name)
3759 : : {
3760 [ + - ]: 168 : return sysfs_streq(dev_name(dev), name);
3761 : : }
3762 : : EXPORT_SYMBOL_GPL(device_match_name);
3763 : :
3764 : 0 : int device_match_of_node(struct device *dev, const void *np)
3765 : : {
3766 : 0 : return dev->of_node == np;
3767 : : }
3768 : : EXPORT_SYMBOL_GPL(device_match_of_node);
3769 : :
3770 : 0 : int device_match_fwnode(struct device *dev, const void *fwnode)
3771 : : {
3772 : 0 : return dev_fwnode(dev) == fwnode;
3773 : : }
3774 : : EXPORT_SYMBOL_GPL(device_match_fwnode);
3775 : :
3776 : 173376 : int device_match_devt(struct device *dev, const void *pdevt)
3777 : : {
3778 : 173376 : return dev->devt == *(dev_t *)pdevt;
3779 : : }
3780 : : EXPORT_SYMBOL_GPL(device_match_devt);
3781 : :
3782 : 0 : int device_match_acpi_dev(struct device *dev, const void *adev)
3783 : : {
3784 [ # # ]: 0 : return ACPI_COMPANION(dev) == adev;
3785 : : }
3786 : : EXPORT_SYMBOL(device_match_acpi_dev);
3787 : :
3788 : 0 : int device_match_any(struct device *dev, const void *unused)
3789 : : {
3790 : 0 : return 1;
3791 : : }
3792 : : EXPORT_SYMBOL_GPL(device_match_any);
|
