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