core.c 80.0 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
L
Linus Torvalds 已提交
2 3 4 5 6
/*
 * drivers/base/core.c - core driver model code (device registration, etc)
 *
 * Copyright (c) 2002-3 Patrick Mochel
 * Copyright (c) 2002-3 Open Source Development Labs
7 8
 * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
 * Copyright (c) 2006 Novell, Inc.
L
Linus Torvalds 已提交
9 10 11 12
 */

#include <linux/device.h>
#include <linux/err.h>
13
#include <linux/fwnode.h>
L
Linus Torvalds 已提交
14 15 16 17
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
18
#include <linux/kdev_t.h>
19
#include <linux/notifier.h>
20 21
#include <linux/of.h>
#include <linux/of_device.h>
22
#include <linux/genhd.h>
23
#include <linux/mutex.h>
24
#include <linux/pm_runtime.h>
25
#include <linux/netdevice.h>
26
#include <linux/sched/signal.h>
27
#include <linux/sysfs.h>
L
Linus Torvalds 已提交
28 29 30 31

#include "base.h"
#include "power/power.h"

32 33 34 35 36 37
#ifdef CONFIG_SYSFS_DEPRECATED
#ifdef CONFIG_SYSFS_DEPRECATED_V2
long sysfs_deprecated = 1;
#else
long sysfs_deprecated = 0;
#endif
38
static int __init sysfs_deprecated_setup(char *arg)
39
{
40
	return kstrtol(arg, 10, &sysfs_deprecated);
41 42 43 44
}
early_param("sysfs.deprecated", sysfs_deprecated_setup);
#endif

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
/* Device links support. */

#ifdef CONFIG_SRCU
static DEFINE_MUTEX(device_links_lock);
DEFINE_STATIC_SRCU(device_links_srcu);

static inline void device_links_write_lock(void)
{
	mutex_lock(&device_links_lock);
}

static inline void device_links_write_unlock(void)
{
	mutex_unlock(&device_links_lock);
}

int device_links_read_lock(void)
{
	return srcu_read_lock(&device_links_srcu);
}

void device_links_read_unlock(int idx)
{
	srcu_read_unlock(&device_links_srcu, idx);
}
#else /* !CONFIG_SRCU */
static DECLARE_RWSEM(device_links_lock);

static inline void device_links_write_lock(void)
{
	down_write(&device_links_lock);
}

static inline void device_links_write_unlock(void)
{
	up_write(&device_links_lock);
}

int device_links_read_lock(void)
{
	down_read(&device_links_lock);
	return 0;
}

void device_links_read_unlock(int not_used)
{
	up_read(&device_links_lock);
}
#endif /* !CONFIG_SRCU */

/**
 * device_is_dependent - Check if one device depends on another one
 * @dev: Device to check dependencies for.
 * @target: Device to check against.
 *
 * Check if @target depends on @dev or any device dependent on it (its child or
 * its consumer etc).  Return 1 if that is the case or 0 otherwise.
 */
static int device_is_dependent(struct device *dev, void *target)
{
	struct device_link *link;
	int ret;

	if (WARN_ON(dev == target))
		return 1;

	ret = device_for_each_child(dev, target, device_is_dependent);
	if (ret)
		return ret;

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		if (WARN_ON(link->consumer == target))
			return 1;

		ret = device_is_dependent(link->consumer, target);
		if (ret)
			break;
	}
	return ret;
}

static int device_reorder_to_tail(struct device *dev, void *not_used)
{
	struct device_link *link;

	/*
	 * Devices that have not been registered yet will be put to the ends
	 * of the lists during the registration, so skip them here.
	 */
	if (device_is_registered(dev))
		devices_kset_move_last(dev);

	if (device_pm_initialized(dev))
		device_pm_move_last(dev);

	device_for_each_child(dev, NULL, device_reorder_to_tail);
	list_for_each_entry(link, &dev->links.consumers, s_node)
		device_reorder_to_tail(link->consumer, NULL);

	return 0;
}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
/**
 * device_pm_move_to_tail - Move set of devices to the end of device lists
 * @dev: Device to move
 *
 * This is a device_reorder_to_tail() wrapper taking the requisite locks.
 *
 * It moves the @dev along with all of its children and all of its consumers
 * to the ends of the device_kset and dpm_list, recursively.
 */
void device_pm_move_to_tail(struct device *dev)
{
	int idx;

	idx = device_links_read_lock();
	device_pm_lock();
	device_reorder_to_tail(dev, NULL);
	device_pm_unlock();
	device_links_read_unlock(idx);
}

167 168 169 170 171 172
/**
 * device_link_add - Create a link between two devices.
 * @consumer: Consumer end of the link.
 * @supplier: Supplier end of the link.
 * @flags: Link flags.
 *
R
Rafael J. Wysocki 已提交
173 174 175 176 177 178 179 180
 * The caller is responsible for the proper synchronization of the link creation
 * with runtime PM.  First, setting the DL_FLAG_PM_RUNTIME flag will cause the
 * runtime PM framework to take the link into account.  Second, if the
 * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will
 * be forced into the active metastate and reference-counted upon the creation
 * of the link.  If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be
 * ignored.
 *
181 182 183 184 185 186 187 188 189 190 191 192
 * If the DL_FLAG_AUTOREMOVE is set, the link will be removed automatically
 * when the consumer device driver unbinds from it.  The combination of both
 * DL_FLAG_AUTOREMOVE and DL_FLAG_STATELESS set is invalid and will cause NULL
 * to be returned.
 *
 * A side effect of the link creation is re-ordering of dpm_list and the
 * devices_kset list by moving the consumer device and all devices depending
 * on it to the ends of these lists (that does not happen to devices that have
 * not been registered when this function is called).
 *
 * The supplier device is required to be registered when this function is called
 * and NULL will be returned if that is not the case.  The consumer device need
193
 * not be registered, however.
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
 */
struct device_link *device_link_add(struct device *consumer,
				    struct device *supplier, u32 flags)
{
	struct device_link *link;

	if (!consumer || !supplier ||
	    ((flags & DL_FLAG_STATELESS) && (flags & DL_FLAG_AUTOREMOVE)))
		return NULL;

	device_links_write_lock();
	device_pm_lock();

	/*
	 * If the supplier has not been fully registered yet or there is a
	 * reverse dependency between the consumer and the supplier already in
	 * the graph, return NULL.
	 */
	if (!device_pm_initialized(supplier)
	    || device_is_dependent(consumer, supplier)) {
		link = NULL;
		goto out;
	}

	list_for_each_entry(link, &supplier->links.consumers, s_node)
219 220
		if (link->consumer == consumer) {
			kref_get(&link->kref);
221
			goto out;
222
		}
223

R
Rafael J. Wysocki 已提交
224
	link = kzalloc(sizeof(*link), GFP_KERNEL);
225 226 227
	if (!link)
		goto out;

228 229 230 231 232 233 234 235 236
	if (flags & DL_FLAG_PM_RUNTIME) {
		if (flags & DL_FLAG_RPM_ACTIVE) {
			if (pm_runtime_get_sync(supplier) < 0) {
				pm_runtime_put_noidle(supplier);
				kfree(link);
				link = NULL;
				goto out;
			}
			link->rpm_active = true;
R
Rafael J. Wysocki 已提交
237
		}
238
		pm_runtime_new_link(consumer);
239 240 241 242 243 244 245
		/*
		 * If the link is being added by the consumer driver at probe
		 * time, balance the decrementation of the supplier's runtime PM
		 * usage counter after consumer probe in driver_probe_device().
		 */
		if (consumer->links.status == DL_DEV_PROBING)
			pm_runtime_get_noresume(supplier);
R
Rafael J. Wysocki 已提交
246
	}
247 248 249 250 251 252 253
	get_device(supplier);
	link->supplier = supplier;
	INIT_LIST_HEAD(&link->s_node);
	get_device(consumer);
	link->consumer = consumer;
	INIT_LIST_HEAD(&link->c_node);
	link->flags = flags;
254
	kref_init(&link->kref);
255

256
	/* Determine the initial link state. */
257 258 259 260 261 262 263
	if (flags & DL_FLAG_STATELESS) {
		link->status = DL_STATE_NONE;
	} else {
		switch (supplier->links.status) {
		case DL_DEV_DRIVER_BOUND:
			switch (consumer->links.status) {
			case DL_DEV_PROBING:
R
Rafael J. Wysocki 已提交
264
				/*
265 266 267
				 * Some callers expect the link creation during
				 * consumer driver probe to resume the supplier
				 * even without DL_FLAG_RPM_ACTIVE.
R
Rafael J. Wysocki 已提交
268 269
				 */
				if (flags & DL_FLAG_PM_RUNTIME)
270
					pm_runtime_resume(supplier);
R
Rafael J. Wysocki 已提交
271

272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
				link->status = DL_STATE_CONSUMER_PROBE;
				break;
			case DL_DEV_DRIVER_BOUND:
				link->status = DL_STATE_ACTIVE;
				break;
			default:
				link->status = DL_STATE_AVAILABLE;
				break;
			}
			break;
		case DL_DEV_UNBINDING:
			link->status = DL_STATE_SUPPLIER_UNBIND;
			break;
		default:
			link->status = DL_STATE_DORMANT;
			break;
		}
	}

	/*
	 * Move the consumer and all of the devices depending on it to the end
	 * of dpm_list and the devices_kset list.
	 *
	 * It is necessary to hold dpm_list locked throughout all that or else
	 * we may end up suspending with a wrong ordering of it.
	 */
	device_reorder_to_tail(consumer, NULL);

	list_add_tail_rcu(&link->s_node, &supplier->links.consumers);
	list_add_tail_rcu(&link->c_node, &consumer->links.suppliers);

	dev_info(consumer, "Linked as a consumer to %s\n", dev_name(supplier));

 out:
	device_pm_unlock();
	device_links_write_unlock();
	return link;
}
EXPORT_SYMBOL_GPL(device_link_add);

static void device_link_free(struct device_link *link)
{
	put_device(link->consumer);
	put_device(link->supplier);
	kfree(link);
}

#ifdef CONFIG_SRCU
static void __device_link_free_srcu(struct rcu_head *rhead)
{
	device_link_free(container_of(rhead, struct device_link, rcu_head));
}

325
static void __device_link_del(struct kref *kref)
326
{
327 328
	struct device_link *link = container_of(kref, struct device_link, kref);

329 330 331
	dev_info(link->consumer, "Dropping the link to %s\n",
		 dev_name(link->supplier));

332 333 334
	if (link->flags & DL_FLAG_PM_RUNTIME)
		pm_runtime_drop_link(link->consumer);

335 336 337 338 339
	list_del_rcu(&link->s_node);
	list_del_rcu(&link->c_node);
	call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu);
}
#else /* !CONFIG_SRCU */
340
static void __device_link_del(struct kref *kref)
341
{
342 343
	struct device_link *link = container_of(kref, struct device_link, kref);

344 345 346
	dev_info(link->consumer, "Dropping the link to %s\n",
		 dev_name(link->supplier));

347 348 349
	if (link->flags & DL_FLAG_PM_RUNTIME)
		pm_runtime_drop_link(link->consumer);

350 351 352 353 354 355 356 357 358 359 360
	list_del(&link->s_node);
	list_del(&link->c_node);
	device_link_free(link);
}
#endif /* !CONFIG_SRCU */

/**
 * device_link_del - Delete a link between two devices.
 * @link: Device link to delete.
 *
 * The caller must ensure proper synchronization of this function with runtime
361 362 363
 * PM.  If the link was added multiple times, it needs to be deleted as often.
 * Care is required for hotplugged devices:  Their links are purged on removal
 * and calling device_link_del() is then no longer allowed.
364 365 366 367 368
 */
void device_link_del(struct device_link *link)
{
	device_links_write_lock();
	device_pm_lock();
369
	kref_put(&link->kref, __device_link_del);
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
	device_pm_unlock();
	device_links_write_unlock();
}
EXPORT_SYMBOL_GPL(device_link_del);

static void device_links_missing_supplier(struct device *dev)
{
	struct device_link *link;

	list_for_each_entry(link, &dev->links.suppliers, c_node)
		if (link->status == DL_STATE_CONSUMER_PROBE)
			WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
}

/**
 * device_links_check_suppliers - Check presence of supplier drivers.
 * @dev: Consumer device.
 *
 * Check links from this device to any suppliers.  Walk the list of the device's
 * links to suppliers and see if all of them are available.  If not, simply
 * return -EPROBE_DEFER.
 *
 * We need to guarantee that the supplier will not go away after the check has
 * been positive here.  It only can go away in __device_release_driver() and
 * that function  checks the device's links to consumers.  This means we need to
 * mark the link as "consumer probe in progress" to make the supplier removal
 * wait for us to complete (or bad things may happen).
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
int device_links_check_suppliers(struct device *dev)
{
	struct device_link *link;
	int ret = 0;

	device_links_write_lock();

	list_for_each_entry(link, &dev->links.suppliers, c_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		if (link->status != DL_STATE_AVAILABLE) {
			device_links_missing_supplier(dev);
			ret = -EPROBE_DEFER;
			break;
		}
		WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE);
	}
	dev->links.status = DL_DEV_PROBING;

	device_links_write_unlock();
	return ret;
}

/**
 * device_links_driver_bound - Update device links after probing its driver.
 * @dev: Device to update the links for.
 *
 * The probe has been successful, so update links from this device to any
 * consumers by changing their status to "available".
 *
 * Also change the status of @dev's links to suppliers to "active".
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
void device_links_driver_bound(struct device *dev)
{
	struct device_link *link;

	device_links_write_lock();

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		WARN_ON(link->status != DL_STATE_DORMANT);
		WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
	}

	list_for_each_entry(link, &dev->links.suppliers, c_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		WARN_ON(link->status != DL_STATE_CONSUMER_PROBE);
		WRITE_ONCE(link->status, DL_STATE_ACTIVE);
	}

	dev->links.status = DL_DEV_DRIVER_BOUND;

	device_links_write_unlock();
}

/**
 * __device_links_no_driver - Update links of a device without a driver.
 * @dev: Device without a drvier.
 *
 * Delete all non-persistent links from this device to any suppliers.
 *
 * Persistent links stay around, but their status is changed to "available",
 * unless they already are in the "supplier unbind in progress" state in which
 * case they need not be updated.
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
static void __device_links_no_driver(struct device *dev)
{
	struct device_link *link, *ln;

	list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		if (link->flags & DL_FLAG_AUTOREMOVE)
483
			kref_put(&link->kref, __device_link_del);
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
		else if (link->status != DL_STATE_SUPPLIER_UNBIND)
			WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
	}

	dev->links.status = DL_DEV_NO_DRIVER;
}

void device_links_no_driver(struct device *dev)
{
	device_links_write_lock();
	__device_links_no_driver(dev);
	device_links_write_unlock();
}

/**
 * device_links_driver_cleanup - Update links after driver removal.
 * @dev: Device whose driver has just gone away.
 *
 * Update links to consumers for @dev by changing their status to "dormant" and
 * invoke %__device_links_no_driver() to update links to suppliers for it as
 * appropriate.
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
void device_links_driver_cleanup(struct device *dev)
{
	struct device_link *link;

	device_links_write_lock();

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		WARN_ON(link->flags & DL_FLAG_AUTOREMOVE);
		WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND);
		WRITE_ONCE(link->status, DL_STATE_DORMANT);
	}

	__device_links_no_driver(dev);

	device_links_write_unlock();
}

/**
 * device_links_busy - Check if there are any busy links to consumers.
 * @dev: Device to check.
 *
 * Check each consumer of the device and return 'true' if its link's status
 * is one of "consumer probe" or "active" (meaning that the given consumer is
 * probing right now or its driver is present).  Otherwise, change the link
 * state to "supplier unbind" to prevent the consumer from being probed
 * successfully going forward.
 *
 * Return 'false' if there are no probing or active consumers.
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
bool device_links_busy(struct device *dev)
{
	struct device_link *link;
	bool ret = false;

	device_links_write_lock();

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		if (link->status == DL_STATE_CONSUMER_PROBE
		    || link->status == DL_STATE_ACTIVE) {
			ret = true;
			break;
		}
		WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
	}

	dev->links.status = DL_DEV_UNBINDING;

	device_links_write_unlock();
	return ret;
}

/**
 * device_links_unbind_consumers - Force unbind consumers of the given device.
 * @dev: Device to unbind the consumers of.
 *
 * Walk the list of links to consumers for @dev and if any of them is in the
 * "consumer probe" state, wait for all device probes in progress to complete
 * and start over.
 *
 * If that's not the case, change the status of the link to "supplier unbind"
 * and check if the link was in the "active" state.  If so, force the consumer
 * driver to unbind and start over (the consumer will not re-probe as we have
 * changed the state of the link already).
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
void device_links_unbind_consumers(struct device *dev)
{
	struct device_link *link;

 start:
	device_links_write_lock();

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		enum device_link_state status;

		if (link->flags & DL_FLAG_STATELESS)
			continue;

		status = link->status;
		if (status == DL_STATE_CONSUMER_PROBE) {
			device_links_write_unlock();

			wait_for_device_probe();
			goto start;
		}
		WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
		if (status == DL_STATE_ACTIVE) {
			struct device *consumer = link->consumer;

			get_device(consumer);

			device_links_write_unlock();

			device_release_driver_internal(consumer, NULL,
						       consumer->parent);
			put_device(consumer);
			goto start;
		}
	}

	device_links_write_unlock();
}

/**
 * device_links_purge - Delete existing links to other devices.
 * @dev: Target device.
 */
static void device_links_purge(struct device *dev)
{
	struct device_link *link, *ln;

	/*
	 * Delete all of the remaining links from this device to any other
	 * devices (either consumers or suppliers).
	 */
	device_links_write_lock();

	list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
		WARN_ON(link->status == DL_STATE_ACTIVE);
636
		__device_link_del(&link->kref);
637 638 639 640 641
	}

	list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) {
		WARN_ON(link->status != DL_STATE_DORMANT &&
			link->status != DL_STATE_NONE);
642
		__device_link_del(&link->kref);
643 644 645 646 647 648 649
	}

	device_links_write_unlock();
}

/* Device links support end. */

650 651
int (*platform_notify)(struct device *dev) = NULL;
int (*platform_notify_remove)(struct device *dev) = NULL;
652 653 654
static struct kobject *dev_kobj;
struct kobject *sysfs_dev_char_kobj;
struct kobject *sysfs_dev_block_kobj;
L
Linus Torvalds 已提交
655

656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
static DEFINE_MUTEX(device_hotplug_lock);

void lock_device_hotplug(void)
{
	mutex_lock(&device_hotplug_lock);
}

void unlock_device_hotplug(void)
{
	mutex_unlock(&device_hotplug_lock);
}

int lock_device_hotplug_sysfs(void)
{
	if (mutex_trylock(&device_hotplug_lock))
		return 0;

	/* Avoid busy looping (5 ms of sleep should do). */
	msleep(5);
	return restart_syscall();
}

678 679 680 681 682 683 684 685 686 687 688
#ifdef CONFIG_BLOCK
static inline int device_is_not_partition(struct device *dev)
{
	return !(dev->type == &part_type);
}
#else
static inline int device_is_not_partition(struct device *dev)
{
	return 1;
}
#endif
L
Linus Torvalds 已提交
689

690 691 692 693 694
/**
 * dev_driver_string - Return a device's driver name, if at all possible
 * @dev: struct device to get the name of
 *
 * Will return the device's driver's name if it is bound to a device.  If
Y
yan 已提交
695
 * the device is not bound to a driver, it will return the name of the bus
696 697 698
 * it is attached to.  If it is not attached to a bus either, an empty
 * string will be returned.
 */
699
const char *dev_driver_string(const struct device *dev)
700
{
701 702 703 704 705 706
	struct device_driver *drv;

	/* dev->driver can change to NULL underneath us because of unbinding,
	 * so be careful about accessing it.  dev->bus and dev->class should
	 * never change once they are set, so they don't need special care.
	 */
707
	drv = READ_ONCE(dev->driver);
708
	return drv ? drv->name :
709 710
			(dev->bus ? dev->bus->name :
			(dev->class ? dev->class->name : ""));
711
}
M
Matthew Wilcox 已提交
712
EXPORT_SYMBOL(dev_driver_string);
713

L
Linus Torvalds 已提交
714 715
#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)

716 717
static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
			     char *buf)
L
Linus Torvalds 已提交
718
{
719
	struct device_attribute *dev_attr = to_dev_attr(attr);
720
	struct device *dev = kobj_to_dev(kobj);
721
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
722 723

	if (dev_attr->show)
724
		ret = dev_attr->show(dev, dev_attr, buf);
725
	if (ret >= (ssize_t)PAGE_SIZE) {
726 727
		printk("dev_attr_show: %pS returned bad count\n",
				dev_attr->show);
728
	}
L
Linus Torvalds 已提交
729 730 731
	return ret;
}

732 733
static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
			      const char *buf, size_t count)
L
Linus Torvalds 已提交
734
{
735
	struct device_attribute *dev_attr = to_dev_attr(attr);
736
	struct device *dev = kobj_to_dev(kobj);
737
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
738 739

	if (dev_attr->store)
740
		ret = dev_attr->store(dev, dev_attr, buf, count);
L
Linus Torvalds 已提交
741 742 743
	return ret;
}

744
static const struct sysfs_ops dev_sysfs_ops = {
L
Linus Torvalds 已提交
745 746 747 748
	.show	= dev_attr_show,
	.store	= dev_attr_store,
};

749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
#define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)

ssize_t device_store_ulong(struct device *dev,
			   struct device_attribute *attr,
			   const char *buf, size_t size)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);
	char *end;
	unsigned long new = simple_strtoul(buf, &end, 0);
	if (end == buf)
		return -EINVAL;
	*(unsigned long *)(ea->var) = new;
	/* Always return full write size even if we didn't consume all */
	return size;
}
EXPORT_SYMBOL_GPL(device_store_ulong);

ssize_t device_show_ulong(struct device *dev,
			  struct device_attribute *attr,
			  char *buf)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);
	return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
}
EXPORT_SYMBOL_GPL(device_show_ulong);

ssize_t device_store_int(struct device *dev,
			 struct device_attribute *attr,
			 const char *buf, size_t size)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);
	char *end;
	long new = simple_strtol(buf, &end, 0);
	if (end == buf || new > INT_MAX || new < INT_MIN)
		return -EINVAL;
	*(int *)(ea->var) = new;
	/* Always return full write size even if we didn't consume all */
	return size;
}
EXPORT_SYMBOL_GPL(device_store_int);

ssize_t device_show_int(struct device *dev,
			struct device_attribute *attr,
			char *buf)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);

	return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
}
EXPORT_SYMBOL_GPL(device_show_int);
L
Linus Torvalds 已提交
799

800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t size)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);

	if (strtobool(buf, ea->var) < 0)
		return -EINVAL;

	return size;
}
EXPORT_SYMBOL_GPL(device_store_bool);

ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);

	return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var));
}
EXPORT_SYMBOL_GPL(device_show_bool);

L
Linus Torvalds 已提交
821
/**
822 823
 * device_release - free device structure.
 * @kobj: device's kobject.
L
Linus Torvalds 已提交
824
 *
825 826 827
 * This is called once the reference count for the object
 * reaches 0. We forward the call to the device's release
 * method, which should handle actually freeing the structure.
L
Linus Torvalds 已提交
828
 */
829
static void device_release(struct kobject *kobj)
L
Linus Torvalds 已提交
830
{
831
	struct device *dev = kobj_to_dev(kobj);
832
	struct device_private *p = dev->p;
L
Linus Torvalds 已提交
833

834 835 836 837 838 839 840 841 842 843 844
	/*
	 * Some platform devices are driven without driver attached
	 * and managed resources may have been acquired.  Make sure
	 * all resources are released.
	 *
	 * Drivers still can add resources into device after device
	 * is deleted but alive, so release devres here to avoid
	 * possible memory leak.
	 */
	devres_release_all(dev);

L
Linus Torvalds 已提交
845 846
	if (dev->release)
		dev->release(dev);
847 848
	else if (dev->type && dev->type->release)
		dev->type->release(dev);
849 850
	else if (dev->class && dev->class->dev_release)
		dev->class->dev_release(dev);
A
Arjan van de Ven 已提交
851 852
	else
		WARN(1, KERN_ERR "Device '%s' does not have a release() "
853
			"function, it is broken and must be fixed.\n",
854
			dev_name(dev));
855
	kfree(p);
L
Linus Torvalds 已提交
856 857
}

858 859
static const void *device_namespace(struct kobject *kobj)
{
860
	struct device *dev = kobj_to_dev(kobj);
861 862 863 864 865 866 867 868
	const void *ns = NULL;

	if (dev->class && dev->class->ns_type)
		ns = dev->class->namespace(dev);

	return ns;
}

869
static struct kobj_type device_ktype = {
L
Linus Torvalds 已提交
870 871
	.release	= device_release,
	.sysfs_ops	= &dev_sysfs_ops,
872
	.namespace	= device_namespace,
L
Linus Torvalds 已提交
873 874 875
};


876
static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
877 878 879
{
	struct kobj_type *ktype = get_ktype(kobj);

880
	if (ktype == &device_ktype) {
881
		struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
882 883
		if (dev->bus)
			return 1;
884 885
		if (dev->class)
			return 1;
L
Linus Torvalds 已提交
886 887 888 889
	}
	return 0;
}

890
static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
891
{
892
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
893

894 895 896 897 898
	if (dev->bus)
		return dev->bus->name;
	if (dev->class)
		return dev->class->name;
	return NULL;
L
Linus Torvalds 已提交
899 900
}

901 902
static int dev_uevent(struct kset *kset, struct kobject *kobj,
		      struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
903
{
904
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
905 906
	int retval = 0;

907
	/* add device node properties if present */
908
	if (MAJOR(dev->devt)) {
909 910
		const char *tmp;
		const char *name;
911
		umode_t mode = 0;
912 913
		kuid_t uid = GLOBAL_ROOT_UID;
		kgid_t gid = GLOBAL_ROOT_GID;
914

915 916
		add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
		add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
917
		name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
918 919
		if (name) {
			add_uevent_var(env, "DEVNAME=%s", name);
920 921
			if (mode)
				add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
922 923 924 925
			if (!uid_eq(uid, GLOBAL_ROOT_UID))
				add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid));
			if (!gid_eq(gid, GLOBAL_ROOT_GID))
				add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid));
926
			kfree(tmp);
927
		}
928 929
	}

930
	if (dev->type && dev->type->name)
931
		add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
932

933
	if (dev->driver)
934
		add_uevent_var(env, "DRIVER=%s", dev->driver->name);
935

936 937 938
	/* Add common DT information about the device */
	of_device_uevent(dev, env);

939
	/* have the bus specific function add its stuff */
940
	if (dev->bus && dev->bus->uevent) {
941
		retval = dev->bus->uevent(dev, env);
942
		if (retval)
943
			pr_debug("device: '%s': %s: bus uevent() returned %d\n",
944
				 dev_name(dev), __func__, retval);
L
Linus Torvalds 已提交
945 946
	}

947
	/* have the class specific function add its stuff */
948
	if (dev->class && dev->class->dev_uevent) {
949
		retval = dev->class->dev_uevent(dev, env);
950
		if (retval)
951
			pr_debug("device: '%s': %s: class uevent() "
952
				 "returned %d\n", dev_name(dev),
953
				 __func__, retval);
954 955
	}

956
	/* have the device type specific function add its stuff */
957
	if (dev->type && dev->type->uevent) {
958
		retval = dev->type->uevent(dev, env);
959
		if (retval)
960
			pr_debug("device: '%s': %s: dev_type uevent() "
961
				 "returned %d\n", dev_name(dev),
962
				 __func__, retval);
963 964
	}

L
Linus Torvalds 已提交
965 966 967
	return retval;
}

968
static const struct kset_uevent_ops device_uevent_ops = {
969 970 971
	.filter =	dev_uevent_filter,
	.name =		dev_uevent_name,
	.uevent =	dev_uevent,
L
Linus Torvalds 已提交
972 973
};

974
static ssize_t uevent_show(struct device *dev, struct device_attribute *attr,
975 976 977 978
			   char *buf)
{
	struct kobject *top_kobj;
	struct kset *kset;
979
	struct kobj_uevent_env *env = NULL;
980 981 982 983 984 985
	int i;
	size_t count = 0;
	int retval;

	/* search the kset, the device belongs to */
	top_kobj = &dev->kobj;
986 987
	while (!top_kobj->kset && top_kobj->parent)
		top_kobj = top_kobj->parent;
988 989
	if (!top_kobj->kset)
		goto out;
990

991 992 993 994 995 996 997 998 999
	kset = top_kobj->kset;
	if (!kset->uevent_ops || !kset->uevent_ops->uevent)
		goto out;

	/* respect filter */
	if (kset->uevent_ops && kset->uevent_ops->filter)
		if (!kset->uevent_ops->filter(kset, &dev->kobj))
			goto out;

1000 1001
	env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
	if (!env)
1002 1003
		return -ENOMEM;

1004
	/* let the kset specific function add its keys */
1005
	retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
1006 1007 1008 1009
	if (retval)
		goto out;

	/* copy keys to file */
1010 1011
	for (i = 0; i < env->envp_idx; i++)
		count += sprintf(&buf[count], "%s\n", env->envp[i]);
1012
out:
1013
	kfree(env);
1014 1015 1016
	return count;
}

1017
static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,
1018 1019
			    const char *buf, size_t count)
{
1020 1021
	if (kobject_synth_uevent(&dev->kobj, buf, count))
		dev_err(dev, "uevent: failed to send synthetic uevent\n");
1022

1023 1024
	return count;
}
1025
static DEVICE_ATTR_RW(uevent);
1026

1027
static ssize_t online_show(struct device *dev, struct device_attribute *attr,
1028 1029 1030 1031
			   char *buf)
{
	bool val;

1032
	device_lock(dev);
1033
	val = !dev->offline;
1034
	device_unlock(dev);
1035 1036 1037
	return sprintf(buf, "%u\n", val);
}

1038
static ssize_t online_store(struct device *dev, struct device_attribute *attr,
1039 1040 1041 1042 1043 1044 1045 1046 1047
			    const char *buf, size_t count)
{
	bool val;
	int ret;

	ret = strtobool(buf, &val);
	if (ret < 0)
		return ret;

1048 1049 1050 1051
	ret = lock_device_hotplug_sysfs();
	if (ret)
		return ret;

1052 1053 1054 1055
	ret = val ? device_online(dev) : device_offline(dev);
	unlock_device_hotplug();
	return ret < 0 ? ret : count;
}
1056
static DEVICE_ATTR_RW(online);
1057

1058
int device_add_groups(struct device *dev, const struct attribute_group **groups)
1059
{
1060
	return sysfs_create_groups(&dev->kobj, groups);
1061
}
1062
EXPORT_SYMBOL_GPL(device_add_groups);
1063

1064 1065
void device_remove_groups(struct device *dev,
			  const struct attribute_group **groups)
1066
{
1067
	sysfs_remove_groups(&dev->kobj, groups);
1068
}
1069
EXPORT_SYMBOL_GPL(device_remove_groups);
1070

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
union device_attr_group_devres {
	const struct attribute_group *group;
	const struct attribute_group **groups;
};

static int devm_attr_group_match(struct device *dev, void *res, void *data)
{
	return ((union device_attr_group_devres *)res)->group == data;
}

static void devm_attr_group_remove(struct device *dev, void *res)
{
	union device_attr_group_devres *devres = res;
	const struct attribute_group *group = devres->group;

	dev_dbg(dev, "%s: removing group %p\n", __func__, group);
	sysfs_remove_group(&dev->kobj, group);
}

static void devm_attr_groups_remove(struct device *dev, void *res)
{
	union device_attr_group_devres *devres = res;
	const struct attribute_group **groups = devres->groups;

	dev_dbg(dev, "%s: removing groups %p\n", __func__, groups);
	sysfs_remove_groups(&dev->kobj, groups);
}

/**
 * devm_device_add_group - given a device, create a managed attribute group
 * @dev:	The device to create the group for
 * @grp:	The attribute group to create
 *
 * This function creates a group for the first time.  It will explicitly
 * warn and error if any of the attribute files being created already exist.
 *
 * Returns 0 on success or error code on failure.
 */
int devm_device_add_group(struct device *dev, const struct attribute_group *grp)
{
	union device_attr_group_devres *devres;
	int error;

	devres = devres_alloc(devm_attr_group_remove,
			      sizeof(*devres), GFP_KERNEL);
	if (!devres)
		return -ENOMEM;

	error = sysfs_create_group(&dev->kobj, grp);
	if (error) {
		devres_free(devres);
		return error;
	}

	devres->group = grp;
	devres_add(dev, devres);
	return 0;
}
EXPORT_SYMBOL_GPL(devm_device_add_group);

/**
 * devm_device_remove_group: remove a managed group from a device
 * @dev:	device to remove the group from
 * @grp:	group to remove
 *
 * This function removes a group of attributes from a device. The attributes
 * previously have to have been created for this group, otherwise it will fail.
 */
void devm_device_remove_group(struct device *dev,
			      const struct attribute_group *grp)
{
	WARN_ON(devres_release(dev, devm_attr_group_remove,
			       devm_attr_group_match,
			       /* cast away const */ (void *)grp));
}
EXPORT_SYMBOL_GPL(devm_device_remove_group);

/**
 * devm_device_add_groups - create a bunch of managed attribute groups
 * @dev:	The device to create the group for
 * @groups:	The attribute groups to create, NULL terminated
 *
 * This function creates a bunch of managed attribute groups.  If an error
 * occurs when creating a group, all previously created groups will be
 * removed, unwinding everything back to the original state when this
 * function was called.  It will explicitly warn and error if any of the
 * attribute files being created already exist.
 *
 * Returns 0 on success or error code from sysfs_create_group on failure.
 */
int devm_device_add_groups(struct device *dev,
			   const struct attribute_group **groups)
{
	union device_attr_group_devres *devres;
	int error;

	devres = devres_alloc(devm_attr_groups_remove,
			      sizeof(*devres), GFP_KERNEL);
	if (!devres)
		return -ENOMEM;

	error = sysfs_create_groups(&dev->kobj, groups);
	if (error) {
		devres_free(devres);
		return error;
	}

	devres->groups = groups;
	devres_add(dev, devres);
	return 0;
}
EXPORT_SYMBOL_GPL(devm_device_add_groups);

/**
 * devm_device_remove_groups - remove a list of managed groups
 *
 * @dev:	The device for the groups to be removed from
 * @groups:	NULL terminated list of groups to be removed
 *
 * If groups is not NULL, remove the specified groups from the device.
 */
void devm_device_remove_groups(struct device *dev,
			       const struct attribute_group **groups)
{
	WARN_ON(devres_release(dev, devm_attr_groups_remove,
			       devm_attr_group_match,
			       /* cast away const */ (void *)groups));
}
EXPORT_SYMBOL_GPL(devm_device_remove_groups);
1200

1201 1202 1203
static int device_add_attrs(struct device *dev)
{
	struct class *class = dev->class;
1204
	const struct device_type *type = dev->type;
1205
	int error;
1206

1207
	if (class) {
1208
		error = device_add_groups(dev, class->dev_groups);
1209
		if (error)
1210
			return error;
1211
	}
1212

1213 1214
	if (type) {
		error = device_add_groups(dev, type->groups);
1215
		if (error)
1216
			goto err_remove_class_groups;
1217 1218
	}

1219 1220 1221 1222
	error = device_add_groups(dev, dev->groups);
	if (error)
		goto err_remove_type_groups;

1223
	if (device_supports_offline(dev) && !dev->offline_disabled) {
1224
		error = device_create_file(dev, &dev_attr_online);
1225
		if (error)
1226
			goto err_remove_dev_groups;
1227 1228
	}

1229 1230
	return 0;

1231 1232
 err_remove_dev_groups:
	device_remove_groups(dev, dev->groups);
1233 1234 1235
 err_remove_type_groups:
	if (type)
		device_remove_groups(dev, type->groups);
1236 1237 1238
 err_remove_class_groups:
	if (class)
		device_remove_groups(dev, class->dev_groups);
1239

1240 1241 1242 1243 1244 1245
	return error;
}

static void device_remove_attrs(struct device *dev)
{
	struct class *class = dev->class;
1246
	const struct device_type *type = dev->type;
1247

1248
	device_remove_file(dev, &dev_attr_online);
1249
	device_remove_groups(dev, dev->groups);
1250

1251 1252 1253
	if (type)
		device_remove_groups(dev, type->groups);

1254
	if (class)
1255
		device_remove_groups(dev, class->dev_groups);
1256 1257
}

1258
static ssize_t dev_show(struct device *dev, struct device_attribute *attr,
1259 1260 1261 1262
			char *buf)
{
	return print_dev_t(buf, dev->devt);
}
1263
static DEVICE_ATTR_RO(dev);
1264

1265
/* /sys/devices/ */
1266
struct kset *devices_kset;
L
Linus Torvalds 已提交
1267

1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
/**
 * devices_kset_move_before - Move device in the devices_kset's list.
 * @deva: Device to move.
 * @devb: Device @deva should come before.
 */
static void devices_kset_move_before(struct device *deva, struct device *devb)
{
	if (!devices_kset)
		return;
	pr_debug("devices_kset: Moving %s before %s\n",
		 dev_name(deva), dev_name(devb));
	spin_lock(&devices_kset->list_lock);
	list_move_tail(&deva->kobj.entry, &devb->kobj.entry);
	spin_unlock(&devices_kset->list_lock);
}

/**
 * devices_kset_move_after - Move device in the devices_kset's list.
 * @deva: Device to move
 * @devb: Device @deva should come after.
 */
static void devices_kset_move_after(struct device *deva, struct device *devb)
{
	if (!devices_kset)
		return;
	pr_debug("devices_kset: Moving %s after %s\n",
		 dev_name(deva), dev_name(devb));
	spin_lock(&devices_kset->list_lock);
	list_move(&deva->kobj.entry, &devb->kobj.entry);
	spin_unlock(&devices_kset->list_lock);
}

/**
 * devices_kset_move_last - move the device to the end of devices_kset's list.
 * @dev: device to move
 */
void devices_kset_move_last(struct device *dev)
{
	if (!devices_kset)
		return;
	pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev));
	spin_lock(&devices_kset->list_lock);
	list_move_tail(&dev->kobj.entry, &devices_kset->list);
	spin_unlock(&devices_kset->list_lock);
}

L
Linus Torvalds 已提交
1314
/**
1315 1316 1317
 * device_create_file - create sysfs attribute file for device.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
1318
 */
1319 1320
int device_create_file(struct device *dev,
		       const struct device_attribute *attr)
L
Linus Torvalds 已提交
1321 1322
{
	int error = 0;
1323 1324 1325

	if (dev) {
		WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
1326 1327
			"Attribute %s: write permission without 'store'\n",
			attr->attr.name);
1328
		WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
1329 1330
			"Attribute %s: read permission without 'show'\n",
			attr->attr.name);
L
Linus Torvalds 已提交
1331
		error = sysfs_create_file(&dev->kobj, &attr->attr);
1332 1333
	}

L
Linus Torvalds 已提交
1334 1335
	return error;
}
1336
EXPORT_SYMBOL_GPL(device_create_file);
L
Linus Torvalds 已提交
1337 1338

/**
1339 1340 1341
 * device_remove_file - remove sysfs attribute file.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
1342
 */
1343 1344
void device_remove_file(struct device *dev,
			const struct device_attribute *attr)
L
Linus Torvalds 已提交
1345
{
1346
	if (dev)
L
Linus Torvalds 已提交
1347 1348
		sysfs_remove_file(&dev->kobj, &attr->attr);
}
1349
EXPORT_SYMBOL_GPL(device_remove_file);
L
Linus Torvalds 已提交
1350

1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
/**
 * device_remove_file_self - remove sysfs attribute file from its own method.
 * @dev: device.
 * @attr: device attribute descriptor.
 *
 * See kernfs_remove_self() for details.
 */
bool device_remove_file_self(struct device *dev,
			     const struct device_attribute *attr)
{
	if (dev)
		return sysfs_remove_file_self(&dev->kobj, &attr->attr);
	else
		return false;
}
EXPORT_SYMBOL_GPL(device_remove_file_self);

1368 1369 1370 1371 1372
/**
 * device_create_bin_file - create sysfs binary attribute file for device.
 * @dev: device.
 * @attr: device binary attribute descriptor.
 */
1373 1374
int device_create_bin_file(struct device *dev,
			   const struct bin_attribute *attr)
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
{
	int error = -EINVAL;
	if (dev)
		error = sysfs_create_bin_file(&dev->kobj, attr);
	return error;
}
EXPORT_SYMBOL_GPL(device_create_bin_file);

/**
 * device_remove_bin_file - remove sysfs binary attribute file
 * @dev: device.
 * @attr: device binary attribute descriptor.
 */
1388 1389
void device_remove_bin_file(struct device *dev,
			    const struct bin_attribute *attr)
1390 1391 1392 1393 1394 1395
{
	if (dev)
		sysfs_remove_bin_file(&dev->kobj, attr);
}
EXPORT_SYMBOL_GPL(device_remove_bin_file);

1396 1397
static void klist_children_get(struct klist_node *n)
{
1398 1399
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
1400 1401 1402 1403 1404 1405

	get_device(dev);
}

static void klist_children_put(struct klist_node *n)
{
1406 1407
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
1408 1409 1410 1411

	put_device(dev);
}

L
Linus Torvalds 已提交
1412
/**
1413 1414
 * device_initialize - init device structure.
 * @dev: device.
L
Linus Torvalds 已提交
1415
 *
1416 1417
 * This prepares the device for use by other layers by initializing
 * its fields.
1418
 * It is the first half of device_register(), if called by
1419 1420 1421 1422 1423
 * that function, though it can also be called separately, so one
 * may use @dev's fields. In particular, get_device()/put_device()
 * may be used for reference counting of @dev after calling this
 * function.
 *
1424 1425 1426 1427 1428
 * All fields in @dev must be initialized by the caller to 0, except
 * for those explicitly set to some other value.  The simplest
 * approach is to use kzalloc() to allocate the structure containing
 * @dev.
 *
1429 1430
 * NOTE: Use put_device() to give up your reference instead of freeing
 * @dev directly once you have called this function.
L
Linus Torvalds 已提交
1431 1432 1433
 */
void device_initialize(struct device *dev)
{
1434
	dev->kobj.kset = devices_kset;
1435
	kobject_init(&dev->kobj, &device_ktype);
L
Linus Torvalds 已提交
1436
	INIT_LIST_HEAD(&dev->dma_pools);
1437
	mutex_init(&dev->mutex);
1438
	lockdep_set_novalidate_class(&dev->mutex);
T
Tejun Heo 已提交
1439 1440
	spin_lock_init(&dev->devres_lock);
	INIT_LIST_HEAD(&dev->devres_head);
1441
	device_pm_init(dev);
1442
	set_dev_node(dev, -1);
1443 1444 1445
#ifdef CONFIG_GENERIC_MSI_IRQ
	INIT_LIST_HEAD(&dev->msi_list);
#endif
1446 1447 1448
	INIT_LIST_HEAD(&dev->links.consumers);
	INIT_LIST_HEAD(&dev->links.suppliers);
	dev->links.status = DL_DEV_NO_DRIVER;
L
Linus Torvalds 已提交
1449
}
1450
EXPORT_SYMBOL_GPL(device_initialize);
L
Linus Torvalds 已提交
1451

1452
struct kobject *virtual_device_parent(struct device *dev)
1453
{
1454
	static struct kobject *virtual_dir = NULL;
1455

1456
	if (!virtual_dir)
1457
		virtual_dir = kobject_create_and_add("virtual",
1458
						     &devices_kset->kobj);
1459

1460
	return virtual_dir;
1461 1462
}

1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
struct class_dir {
	struct kobject kobj;
	struct class *class;
};

#define to_class_dir(obj) container_of(obj, struct class_dir, kobj)

static void class_dir_release(struct kobject *kobj)
{
	struct class_dir *dir = to_class_dir(kobj);
	kfree(dir);
}

static const
struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)
1478
{
1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492
	struct class_dir *dir = to_class_dir(kobj);
	return dir->class->ns_type;
}

static struct kobj_type class_dir_ktype = {
	.release	= class_dir_release,
	.sysfs_ops	= &kobj_sysfs_ops,
	.child_ns_type	= class_dir_child_ns_type
};

static struct kobject *
class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)
{
	struct class_dir *dir;
1493 1494
	int retval;

1495 1496
	dir = kzalloc(sizeof(*dir), GFP_KERNEL);
	if (!dir)
1497
		return ERR_PTR(-ENOMEM);
1498 1499 1500 1501

	dir->class = class;
	kobject_init(&dir->kobj, &class_dir_ktype);

1502
	dir->kobj.kset = &class->p->glue_dirs;
1503 1504 1505 1506

	retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
	if (retval < 0) {
		kobject_put(&dir->kobj);
1507
		return ERR_PTR(retval);
1508 1509 1510 1511
	}
	return &dir->kobj;
}

1512
static DEFINE_MUTEX(gdp_mutex);
1513 1514 1515 1516

static struct kobject *get_device_parent(struct device *dev,
					 struct device *parent)
{
1517 1518 1519 1520 1521
	if (dev->class) {
		struct kobject *kobj = NULL;
		struct kobject *parent_kobj;
		struct kobject *k;

1522
#ifdef CONFIG_BLOCK
1523
		/* block disks show up in /sys/block */
1524
		if (sysfs_deprecated && dev->class == &block_class) {
1525 1526
			if (parent && parent->class == &block_class)
				return &parent->kobj;
1527
			return &block_class.p->subsys.kobj;
1528
		}
1529
#endif
1530

1531 1532
		/*
		 * If we have no parent, we live in "virtual".
1533 1534
		 * Class-devices with a non class-device as parent, live
		 * in a "glue" directory to prevent namespace collisions.
1535 1536 1537
		 */
		if (parent == NULL)
			parent_kobj = virtual_device_parent(dev);
1538
		else if (parent->class && !dev->class->ns_type)
1539 1540 1541 1542
			return &parent->kobj;
		else
			parent_kobj = &parent->kobj;

1543 1544
		mutex_lock(&gdp_mutex);

1545
		/* find our class-directory at the parent and reference it */
1546 1547
		spin_lock(&dev->class->p->glue_dirs.list_lock);
		list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
1548 1549 1550 1551
			if (k->parent == parent_kobj) {
				kobj = kobject_get(k);
				break;
			}
1552
		spin_unlock(&dev->class->p->glue_dirs.list_lock);
1553 1554
		if (kobj) {
			mutex_unlock(&gdp_mutex);
1555
			return kobj;
1556
		}
1557 1558

		/* or create a new class-directory at the parent device */
1559
		k = class_dir_create_and_add(dev->class, parent_kobj);
1560
		/* do not emit an uevent for this simple "glue" directory */
1561
		mutex_unlock(&gdp_mutex);
1562
		return k;
1563 1564
	}

1565 1566 1567 1568
	/* subsystems can specify a default root directory for their devices */
	if (!parent && dev->bus && dev->bus->dev_root)
		return &dev->bus->dev_root->kobj;

1569
	if (parent)
1570 1571 1572
		return &parent->kobj;
	return NULL;
}
1573

1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592
static inline bool live_in_glue_dir(struct kobject *kobj,
				    struct device *dev)
{
	if (!kobj || !dev->class ||
	    kobj->kset != &dev->class->p->glue_dirs)
		return false;
	return true;
}

static inline struct kobject *get_glue_dir(struct device *dev)
{
	return dev->kobj.parent;
}

/*
 * make sure cleaning up dir as the last step, we need to make
 * sure .release handler of kobject is run with holding the
 * global lock
 */
1593
static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
1594
{
1595
	/* see if we live in a "glue" directory */
1596
	if (!live_in_glue_dir(glue_dir, dev))
1597 1598
		return;

1599
	mutex_lock(&gdp_mutex);
1600 1601
	if (!kobject_has_children(glue_dir))
		kobject_del(glue_dir);
1602
	kobject_put(glue_dir);
1603
	mutex_unlock(&gdp_mutex);
1604
}
1605

1606 1607
static int device_add_class_symlinks(struct device *dev)
{
1608
	struct device_node *of_node = dev_of_node(dev);
1609 1610
	int error;

1611
	if (of_node) {
1612
		error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node");
1613 1614 1615 1616 1617
		if (error)
			dev_warn(dev, "Error %d creating of_node link\n",error);
		/* An error here doesn't warrant bringing down the device */
	}

1618 1619
	if (!dev->class)
		return 0;
1620

1621
	error = sysfs_create_link(&dev->kobj,
1622
				  &dev->class->p->subsys.kobj,
1623 1624
				  "subsystem");
	if (error)
1625
		goto out_devnode;
1626

1627
	if (dev->parent && device_is_not_partition(dev)) {
1628
		error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
1629 1630
					  "device");
		if (error)
1631
			goto out_subsys;
1632 1633
	}

1634
#ifdef CONFIG_BLOCK
1635
	/* /sys/block has directories and does not need symlinks */
1636
	if (sysfs_deprecated && dev->class == &block_class)
1637
		return 0;
1638
#endif
1639

1640
	/* link in the class directory pointing to the device */
1641
	error = sysfs_create_link(&dev->class->p->subsys.kobj,
1642
				  &dev->kobj, dev_name(dev));
1643
	if (error)
1644
		goto out_device;
1645 1646 1647

	return 0;

1648 1649
out_device:
	sysfs_remove_link(&dev->kobj, "device");
1650

1651 1652
out_subsys:
	sysfs_remove_link(&dev->kobj, "subsystem");
1653 1654
out_devnode:
	sysfs_remove_link(&dev->kobj, "of_node");
1655 1656 1657 1658 1659
	return error;
}

static void device_remove_class_symlinks(struct device *dev)
{
1660 1661 1662
	if (dev_of_node(dev))
		sysfs_remove_link(&dev->kobj, "of_node");

1663 1664
	if (!dev->class)
		return;
1665

1666
	if (dev->parent && device_is_not_partition(dev))
1667
		sysfs_remove_link(&dev->kobj, "device");
1668
	sysfs_remove_link(&dev->kobj, "subsystem");
1669
#ifdef CONFIG_BLOCK
1670
	if (sysfs_deprecated && dev->class == &block_class)
1671
		return;
1672
#endif
1673
	sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
1674 1675
}

1676 1677 1678
/**
 * dev_set_name - set a device name
 * @dev: device
1679
 * @fmt: format string for the device's name
1680 1681 1682 1683
 */
int dev_set_name(struct device *dev, const char *fmt, ...)
{
	va_list vargs;
1684
	int err;
1685 1686

	va_start(vargs, fmt);
1687
	err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
1688
	va_end(vargs);
1689
	return err;
1690 1691 1692
}
EXPORT_SYMBOL_GPL(dev_set_name);

1693 1694 1695 1696 1697 1698 1699 1700
/**
 * device_to_dev_kobj - select a /sys/dev/ directory for the device
 * @dev: device
 *
 * By default we select char/ for new entries.  Setting class->dev_obj
 * to NULL prevents an entry from being created.  class->dev_kobj must
 * be set (or cleared) before any devices are registered to the class
 * otherwise device_create_sys_dev_entry() and
P
Peter Korsgaard 已提交
1701 1702
 * device_remove_sys_dev_entry() will disagree about the presence of
 * the link.
1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
 */
static struct kobject *device_to_dev_kobj(struct device *dev)
{
	struct kobject *kobj;

	if (dev->class)
		kobj = dev->class->dev_kobj;
	else
		kobj = sysfs_dev_char_kobj;

	return kobj;
}

static int device_create_sys_dev_entry(struct device *dev)
{
	struct kobject *kobj = device_to_dev_kobj(dev);
	int error = 0;
	char devt_str[15];

	if (kobj) {
		format_dev_t(devt_str, dev->devt);
		error = sysfs_create_link(kobj, &dev->kobj, devt_str);
	}

	return error;
}

static void device_remove_sys_dev_entry(struct device *dev)
{
	struct kobject *kobj = device_to_dev_kobj(dev);
	char devt_str[15];

	if (kobj) {
		format_dev_t(devt_str, dev->devt);
		sysfs_remove_link(kobj, devt_str);
	}
}

1741
static int device_private_init(struct device *dev)
1742 1743 1744 1745 1746 1747 1748
{
	dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
	if (!dev->p)
		return -ENOMEM;
	dev->p->device = dev;
	klist_init(&dev->p->klist_children, klist_children_get,
		   klist_children_put);
1749
	INIT_LIST_HEAD(&dev->p->deferred_probe);
1750 1751 1752
	return 0;
}

L
Linus Torvalds 已提交
1753
/**
1754 1755
 * device_add - add device to device hierarchy.
 * @dev: device.
L
Linus Torvalds 已提交
1756
 *
1757 1758
 * This is part 2 of device_register(), though may be called
 * separately _iff_ device_initialize() has been called separately.
L
Linus Torvalds 已提交
1759
 *
1760
 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
1761 1762
 * to the global and sibling lists for the device, then
 * adds it to the other relevant subsystems of the driver model.
1763
 *
1764 1765 1766 1767 1768 1769 1770
 * Do not call this routine or device_register() more than once for
 * any device structure.  The driver model core is not designed to work
 * with devices that get unregistered and then spring back to life.
 * (Among other things, it's very hard to guarantee that all references
 * to the previous incarnation of @dev have been dropped.)  Allocate
 * and register a fresh new struct device instead.
 *
1771 1772 1773
 * NOTE: _Never_ directly free @dev after calling this function, even
 * if it returned an error! Always use put_device() to give up your
 * reference instead.
L
Linus Torvalds 已提交
1774 1775 1776
 */
int device_add(struct device *dev)
{
1777
	struct device *parent;
1778
	struct kobject *kobj;
1779
	struct class_interface *class_intf;
1780
	int error = -EINVAL;
1781
	struct kobject *glue_dir = NULL;
1782

L
Linus Torvalds 已提交
1783
	dev = get_device(dev);
1784 1785 1786
	if (!dev)
		goto done;

1787
	if (!dev->p) {
1788 1789 1790
		error = device_private_init(dev);
		if (error)
			goto done;
1791 1792
	}

1793 1794 1795 1796 1797 1798
	/*
	 * for statically allocated devices, which should all be converted
	 * some day, we need to initialize the name. We prevent reading back
	 * the name, and force the use of dev_name()
	 */
	if (dev->init_name) {
1799
		dev_set_name(dev, "%s", dev->init_name);
1800 1801
		dev->init_name = NULL;
	}
1802

1803 1804 1805 1806
	/* subsystems can specify simple device enumeration */
	if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
		dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);

1807 1808
	if (!dev_name(dev)) {
		error = -EINVAL;
1809
		goto name_error;
1810
	}
L
Linus Torvalds 已提交
1811

1812
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1813

L
Linus Torvalds 已提交
1814
	parent = get_device(dev->parent);
1815
	kobj = get_device_parent(dev, parent);
1816 1817 1818 1819
	if (IS_ERR(kobj)) {
		error = PTR_ERR(kobj);
		goto parent_error;
	}
1820 1821
	if (kobj)
		dev->kobj.parent = kobj;
L
Linus Torvalds 已提交
1822

1823
	/* use parent numa_node */
1824
	if (parent && (dev_to_node(dev) == NUMA_NO_NODE))
1825 1826
		set_dev_node(dev, dev_to_node(parent));

L
Linus Torvalds 已提交
1827
	/* first, register with generic layer. */
1828 1829
	/* we require the name to be set before, and pass NULL */
	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
1830 1831
	if (error) {
		glue_dir = get_glue_dir(dev);
L
Linus Torvalds 已提交
1832
		goto Error;
1833
	}
1834

1835 1836 1837 1838
	/* notify platform of device entry */
	if (platform_notify)
		platform_notify(dev);

1839
	error = device_create_file(dev, &dev_attr_uevent);
1840 1841
	if (error)
		goto attrError;
1842

1843 1844 1845
	error = device_add_class_symlinks(dev);
	if (error)
		goto SymlinkError;
1846 1847
	error = device_add_attrs(dev);
	if (error)
1848
		goto AttrsError;
1849 1850
	error = bus_add_device(dev);
	if (error)
L
Linus Torvalds 已提交
1851
		goto BusError;
1852
	error = dpm_sysfs_add(dev);
1853
	if (error)
1854 1855
		goto DPMError;
	device_pm_add(dev);
1856

1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868
	if (MAJOR(dev->devt)) {
		error = device_create_file(dev, &dev_attr_dev);
		if (error)
			goto DevAttrError;

		error = device_create_sys_dev_entry(dev);
		if (error)
			goto SysEntryError;

		devtmpfs_create_node(dev);
	}

1869
	/* Notify clients of device addition.  This call must come
1870
	 * after dpm_sysfs_add() and before kobject_uevent().
1871 1872 1873 1874 1875
	 */
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_ADD_DEVICE, dev);

1876
	kobject_uevent(&dev->kobj, KOBJ_ADD);
1877
	bus_probe_device(dev);
L
Linus Torvalds 已提交
1878
	if (parent)
1879 1880
		klist_add_tail(&dev->p->knode_parent,
			       &parent->p->klist_children);
L
Linus Torvalds 已提交
1881

1882
	if (dev->class) {
1883
		mutex_lock(&dev->class->p->mutex);
1884
		/* tie the class to the device */
1885
		klist_add_tail(&dev->knode_class,
1886
			       &dev->class->p->klist_devices);
1887 1888

		/* notify any interfaces that the device is here */
1889
		list_for_each_entry(class_intf,
1890
				    &dev->class->p->interfaces, node)
1891 1892
			if (class_intf->add_dev)
				class_intf->add_dev(dev, class_intf);
1893
		mutex_unlock(&dev->class->p->mutex);
1894
	}
1895
done:
L
Linus Torvalds 已提交
1896 1897
	put_device(dev);
	return error;
1898 1899 1900 1901 1902 1903
 SysEntryError:
	if (MAJOR(dev->devt))
		device_remove_file(dev, &dev_attr_dev);
 DevAttrError:
	device_pm_remove(dev);
	dpm_sysfs_remove(dev);
1904
 DPMError:
1905 1906
	bus_remove_device(dev);
 BusError:
1907
	device_remove_attrs(dev);
1908
 AttrsError:
1909 1910
	device_remove_class_symlinks(dev);
 SymlinkError:
1911
	device_remove_file(dev, &dev_attr_uevent);
1912
 attrError:
1913
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1914
	glue_dir = get_glue_dir(dev);
L
Linus Torvalds 已提交
1915 1916
	kobject_del(&dev->kobj);
 Error:
1917
	cleanup_glue_dir(dev, glue_dir);
1918
parent_error:
1919
	put_device(parent);
1920 1921 1922
name_error:
	kfree(dev->p);
	dev->p = NULL;
1923
	goto done;
L
Linus Torvalds 已提交
1924
}
1925
EXPORT_SYMBOL_GPL(device_add);
L
Linus Torvalds 已提交
1926 1927

/**
1928 1929
 * device_register - register a device with the system.
 * @dev: pointer to the device structure
L
Linus Torvalds 已提交
1930
 *
1931 1932 1933 1934 1935 1936
 * This happens in two clean steps - initialize the device
 * and add it to the system. The two steps can be called
 * separately, but this is the easiest and most common.
 * I.e. you should only call the two helpers separately if
 * have a clearly defined need to use and refcount the device
 * before it is added to the hierarchy.
1937
 *
1938 1939 1940
 * For more information, see the kerneldoc for device_initialize()
 * and device_add().
 *
1941 1942 1943
 * NOTE: _Never_ directly free @dev after calling this function, even
 * if it returned an error! Always use put_device() to give up the
 * reference initialized in this function instead.
L
Linus Torvalds 已提交
1944 1945 1946 1947 1948 1949
 */
int device_register(struct device *dev)
{
	device_initialize(dev);
	return device_add(dev);
}
1950
EXPORT_SYMBOL_GPL(device_register);
L
Linus Torvalds 已提交
1951 1952

/**
1953 1954
 * get_device - increment reference count for device.
 * @dev: device.
L
Linus Torvalds 已提交
1955
 *
1956 1957 1958
 * This simply forwards the call to kobject_get(), though
 * we do take care to provide for the case that we get a NULL
 * pointer passed in.
L
Linus Torvalds 已提交
1959
 */
1960
struct device *get_device(struct device *dev)
L
Linus Torvalds 已提交
1961
{
1962
	return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
L
Linus Torvalds 已提交
1963
}
1964
EXPORT_SYMBOL_GPL(get_device);
L
Linus Torvalds 已提交
1965 1966

/**
1967 1968
 * put_device - decrement reference count.
 * @dev: device in question.
L
Linus Torvalds 已提交
1969
 */
1970
void put_device(struct device *dev)
L
Linus Torvalds 已提交
1971
{
1972
	/* might_sleep(); */
L
Linus Torvalds 已提交
1973 1974 1975
	if (dev)
		kobject_put(&dev->kobj);
}
1976
EXPORT_SYMBOL_GPL(put_device);
L
Linus Torvalds 已提交
1977 1978

/**
1979 1980
 * device_del - delete device from system.
 * @dev: device.
L
Linus Torvalds 已提交
1981
 *
1982 1983 1984 1985 1986
 * This is the first part of the device unregistration
 * sequence. This removes the device from the lists we control
 * from here, has it removed from the other driver model
 * subsystems it was added to in device_add(), and removes it
 * from the kobject hierarchy.
L
Linus Torvalds 已提交
1987
 *
1988 1989
 * NOTE: this should be called manually _iff_ device_add() was
 * also called manually.
L
Linus Torvalds 已提交
1990
 */
1991
void device_del(struct device *dev)
L
Linus Torvalds 已提交
1992
{
1993
	struct device *parent = dev->parent;
1994
	struct kobject *glue_dir = NULL;
1995
	struct class_interface *class_intf;
L
Linus Torvalds 已提交
1996

1997 1998 1999 2000 2001 2002
	/* Notify clients of device removal.  This call must come
	 * before dpm_sysfs_remove().
	 */
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_DEL_DEVICE, dev);
2003

2004
	dpm_sysfs_remove(dev);
L
Linus Torvalds 已提交
2005
	if (parent)
2006
		klist_del(&dev->p->knode_parent);
2007
	if (MAJOR(dev->devt)) {
2008
		devtmpfs_delete_node(dev);
2009
		device_remove_sys_dev_entry(dev);
2010
		device_remove_file(dev, &dev_attr_dev);
2011
	}
2012
	if (dev->class) {
2013
		device_remove_class_symlinks(dev);
2014

2015
		mutex_lock(&dev->class->p->mutex);
2016
		/* notify any interfaces that the device is now gone */
2017
		list_for_each_entry(class_intf,
2018
				    &dev->class->p->interfaces, node)
2019 2020 2021
			if (class_intf->remove_dev)
				class_intf->remove_dev(dev, class_intf);
		/* remove the device from the class list */
2022
		klist_del(&dev->knode_class);
2023
		mutex_unlock(&dev->class->p->mutex);
2024
	}
2025
	device_remove_file(dev, &dev_attr_uevent);
2026
	device_remove_attrs(dev);
2027
	bus_remove_device(dev);
2028
	device_pm_remove(dev);
2029
	driver_deferred_probe_del(dev);
2030
	device_remove_properties(dev);
2031
	device_links_purge(dev);
L
Linus Torvalds 已提交
2032 2033 2034 2035 2036 2037

	/* Notify the platform of the removal, in case they
	 * need to do anything...
	 */
	if (platform_notify_remove)
		platform_notify_remove(dev);
2038 2039 2040
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_REMOVED_DEVICE, dev);
2041
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
2042
	glue_dir = get_glue_dir(dev);
L
Linus Torvalds 已提交
2043
	kobject_del(&dev->kobj);
2044
	cleanup_glue_dir(dev, glue_dir);
2045
	put_device(parent);
L
Linus Torvalds 已提交
2046
}
2047
EXPORT_SYMBOL_GPL(device_del);
L
Linus Torvalds 已提交
2048 2049

/**
2050 2051
 * device_unregister - unregister device from system.
 * @dev: device going away.
L
Linus Torvalds 已提交
2052
 *
2053 2054 2055 2056 2057 2058
 * We do this in two parts, like we do device_register(). First,
 * we remove it from all the subsystems with device_del(), then
 * we decrement the reference count via put_device(). If that
 * is the final reference count, the device will be cleaned up
 * via device_release() above. Otherwise, the structure will
 * stick around until the final reference to the device is dropped.
L
Linus Torvalds 已提交
2059
 */
2060
void device_unregister(struct device *dev)
L
Linus Torvalds 已提交
2061
{
2062
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
L
Linus Torvalds 已提交
2063 2064 2065
	device_del(dev);
	put_device(dev);
}
2066
EXPORT_SYMBOL_GPL(device_unregister);
L
Linus Torvalds 已提交
2067

2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080
static struct device *prev_device(struct klist_iter *i)
{
	struct klist_node *n = klist_prev(i);
	struct device *dev = NULL;
	struct device_private *p;

	if (n) {
		p = to_device_private_parent(n);
		dev = p->device;
	}
	return dev;
}

2081
static struct device *next_device(struct klist_iter *i)
2082
{
2083
	struct klist_node *n = klist_next(i);
2084 2085 2086 2087 2088 2089 2090 2091
	struct device *dev = NULL;
	struct device_private *p;

	if (n) {
		p = to_device_private_parent(n);
		dev = p->device;
	}
	return dev;
2092 2093
}

2094
/**
2095
 * device_get_devnode - path of device node file
2096
 * @dev: device
2097
 * @mode: returned file access mode
2098 2099
 * @uid: returned file owner
 * @gid: returned file group
2100 2101 2102 2103 2104 2105 2106
 * @tmp: possibly allocated string
 *
 * Return the relative path of a possible device node.
 * Non-default names may need to allocate a memory to compose
 * a name. This memory is returned in tmp and needs to be
 * freed by the caller.
 */
2107
const char *device_get_devnode(struct device *dev,
2108
			       umode_t *mode, kuid_t *uid, kgid_t *gid,
2109
			       const char **tmp)
2110 2111 2112 2113 2114 2115
{
	char *s;

	*tmp = NULL;

	/* the device type may provide a specific name */
2116
	if (dev->type && dev->type->devnode)
2117
		*tmp = dev->type->devnode(dev, mode, uid, gid);
2118 2119 2120 2121
	if (*tmp)
		return *tmp;

	/* the class may provide a specific name */
2122 2123
	if (dev->class && dev->class->devnode)
		*tmp = dev->class->devnode(dev, mode);
2124 2125 2126 2127 2128 2129 2130 2131
	if (*tmp)
		return *tmp;

	/* return name without allocation, tmp == NULL */
	if (strchr(dev_name(dev), '!') == NULL)
		return dev_name(dev);

	/* replace '!' in the name with '/' */
2132 2133
	s = kstrdup(dev_name(dev), GFP_KERNEL);
	if (!s)
2134
		return NULL;
2135 2136
	strreplace(s, '!', '/');
	return *tmp = s;
2137 2138
}

L
Linus Torvalds 已提交
2139
/**
2140 2141 2142
 * device_for_each_child - device child iterator.
 * @parent: parent struct device.
 * @fn: function to be called for each device.
2143
 * @data: data for the callback.
L
Linus Torvalds 已提交
2144
 *
2145 2146
 * Iterate over @parent's child devices, and call @fn for each,
 * passing it @data.
L
Linus Torvalds 已提交
2147
 *
2148 2149
 * We check the return of @fn each time. If it returns anything
 * other than 0, we break out and return that value.
L
Linus Torvalds 已提交
2150
 */
2151 2152
int device_for_each_child(struct device *parent, void *data,
			  int (*fn)(struct device *dev, void *data))
L
Linus Torvalds 已提交
2153
{
2154
	struct klist_iter i;
2155
	struct device *child;
L
Linus Torvalds 已提交
2156 2157
	int error = 0;

2158 2159 2160
	if (!parent->p)
		return 0;

2161
	klist_iter_init(&parent->p->klist_children, &i);
2162
	while (!error && (child = next_device(&i)))
2163 2164
		error = fn(child, data);
	klist_iter_exit(&i);
L
Linus Torvalds 已提交
2165 2166
	return error;
}
2167
EXPORT_SYMBOL_GPL(device_for_each_child);
L
Linus Torvalds 已提交
2168

2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
/**
 * device_for_each_child_reverse - device child iterator in reversed order.
 * @parent: parent struct device.
 * @fn: function to be called for each device.
 * @data: data for the callback.
 *
 * Iterate over @parent's child devices, and call @fn for each,
 * passing it @data.
 *
 * We check the return of @fn each time. If it returns anything
 * other than 0, we break out and return that value.
 */
int device_for_each_child_reverse(struct device *parent, void *data,
				  int (*fn)(struct device *dev, void *data))
{
	struct klist_iter i;
	struct device *child;
	int error = 0;

	if (!parent->p)
		return 0;

	klist_iter_init(&parent->p->klist_children, &i);
	while ((child = prev_device(&i)) && !error)
		error = fn(child, data);
	klist_iter_exit(&i);
	return error;
}
EXPORT_SYMBOL_GPL(device_for_each_child_reverse);

2199 2200 2201 2202
/**
 * device_find_child - device iterator for locating a particular device.
 * @parent: parent struct device
 * @match: Callback function to check device
2203
 * @data: Data to pass to match function
2204 2205 2206 2207 2208 2209 2210 2211 2212
 *
 * This is similar to the device_for_each_child() function above, but it
 * returns a reference to a device that is 'found' for later use, as
 * determined by the @match callback.
 *
 * The callback should return 0 if the device doesn't match and non-zero
 * if it does.  If the callback returns non-zero and a reference to the
 * current device can be obtained, this function will return to the caller
 * and not iterate over any more devices.
2213 2214
 *
 * NOTE: you will need to drop the reference with put_device() after use.
2215
 */
2216 2217
struct device *device_find_child(struct device *parent, void *data,
				 int (*match)(struct device *dev, void *data))
2218 2219 2220 2221 2222 2223 2224
{
	struct klist_iter i;
	struct device *child;

	if (!parent)
		return NULL;

2225
	klist_iter_init(&parent->p->klist_children, &i);
2226 2227 2228 2229 2230 2231
	while ((child = next_device(&i)))
		if (match(child, data) && get_device(child))
			break;
	klist_iter_exit(&i);
	return child;
}
2232
EXPORT_SYMBOL_GPL(device_find_child);
2233

L
Linus Torvalds 已提交
2234 2235
int __init devices_init(void)
{
2236 2237 2238
	devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
	if (!devices_kset)
		return -ENOMEM;
2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
	dev_kobj = kobject_create_and_add("dev", NULL);
	if (!dev_kobj)
		goto dev_kobj_err;
	sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
	if (!sysfs_dev_block_kobj)
		goto block_kobj_err;
	sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
	if (!sysfs_dev_char_kobj)
		goto char_kobj_err;

2249
	return 0;
2250 2251 2252 2253 2254 2255 2256 2257

 char_kobj_err:
	kobject_put(sysfs_dev_block_kobj);
 block_kobj_err:
	kobject_put(dev_kobj);
 dev_kobj_err:
	kset_unregister(devices_kset);
	return -ENOMEM;
L
Linus Torvalds 已提交
2258 2259
}

2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340
static int device_check_offline(struct device *dev, void *not_used)
{
	int ret;

	ret = device_for_each_child(dev, NULL, device_check_offline);
	if (ret)
		return ret;

	return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0;
}

/**
 * device_offline - Prepare the device for hot-removal.
 * @dev: Device to be put offline.
 *
 * Execute the device bus type's .offline() callback, if present, to prepare
 * the device for a subsequent hot-removal.  If that succeeds, the device must
 * not be used until either it is removed or its bus type's .online() callback
 * is executed.
 *
 * Call under device_hotplug_lock.
 */
int device_offline(struct device *dev)
{
	int ret;

	if (dev->offline_disabled)
		return -EPERM;

	ret = device_for_each_child(dev, NULL, device_check_offline);
	if (ret)
		return ret;

	device_lock(dev);
	if (device_supports_offline(dev)) {
		if (dev->offline) {
			ret = 1;
		} else {
			ret = dev->bus->offline(dev);
			if (!ret) {
				kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
				dev->offline = true;
			}
		}
	}
	device_unlock(dev);

	return ret;
}

/**
 * device_online - Put the device back online after successful device_offline().
 * @dev: Device to be put back online.
 *
 * If device_offline() has been successfully executed for @dev, but the device
 * has not been removed subsequently, execute its bus type's .online() callback
 * to indicate that the device can be used again.
 *
 * Call under device_hotplug_lock.
 */
int device_online(struct device *dev)
{
	int ret = 0;

	device_lock(dev);
	if (device_supports_offline(dev)) {
		if (dev->offline) {
			ret = dev->bus->online(dev);
			if (!ret) {
				kobject_uevent(&dev->kobj, KOBJ_ONLINE);
				dev->offline = false;
			}
		} else {
			ret = 1;
		}
	}
	device_unlock(dev);

	return ret;
}

2341
struct root_device {
2342 2343 2344 2345
	struct device dev;
	struct module *owner;
};

2346
static inline struct root_device *to_root_device(struct device *d)
2347 2348 2349
{
	return container_of(d, struct root_device, dev);
}
2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373

static void root_device_release(struct device *dev)
{
	kfree(to_root_device(dev));
}

/**
 * __root_device_register - allocate and register a root device
 * @name: root device name
 * @owner: owner module of the root device, usually THIS_MODULE
 *
 * This function allocates a root device and registers it
 * using device_register(). In order to free the returned
 * device, use root_device_unregister().
 *
 * Root devices are dummy devices which allow other devices
 * to be grouped under /sys/devices. Use this function to
 * allocate a root device and then use it as the parent of
 * any device which should appear under /sys/devices/{name}
 *
 * The /sys/devices/{name} directory will also contain a
 * 'module' symlink which points to the @owner directory
 * in sysfs.
 *
2374 2375
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386
 * Note: You probably want to use root_device_register().
 */
struct device *__root_device_register(const char *name, struct module *owner)
{
	struct root_device *root;
	int err = -ENOMEM;

	root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
	if (!root)
		return ERR_PTR(err);

2387
	err = dev_set_name(&root->dev, "%s", name);
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400
	if (err) {
		kfree(root);
		return ERR_PTR(err);
	}

	root->dev.release = root_device_release;

	err = device_register(&root->dev);
	if (err) {
		put_device(&root->dev);
		return ERR_PTR(err);
	}

2401
#ifdef CONFIG_MODULES	/* gotta find a "cleaner" way to do this */
2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419
	if (owner) {
		struct module_kobject *mk = &owner->mkobj;

		err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
		if (err) {
			device_unregister(&root->dev);
			return ERR_PTR(err);
		}
		root->owner = owner;
	}
#endif

	return &root->dev;
}
EXPORT_SYMBOL_GPL(__root_device_register);

/**
 * root_device_unregister - unregister and free a root device
2420
 * @dev: device going away
2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435
 *
 * This function unregisters and cleans up a device that was created by
 * root_device_register().
 */
void root_device_unregister(struct device *dev)
{
	struct root_device *root = to_root_device(dev);

	if (root->owner)
		sysfs_remove_link(&root->dev.kobj, "module");

	device_unregister(dev);
}
EXPORT_SYMBOL_GPL(root_device_unregister);

2436 2437 2438

static void device_create_release(struct device *dev)
{
2439
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
2440 2441 2442
	kfree(dev);
}

2443
static __printf(6, 0) struct device *
2444 2445 2446 2447
device_create_groups_vargs(struct class *class, struct device *parent,
			   dev_t devt, void *drvdata,
			   const struct attribute_group **groups,
			   const char *fmt, va_list args)
2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460
{
	struct device *dev = NULL;
	int retval = -ENODEV;

	if (class == NULL || IS_ERR(class))
		goto error;

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev) {
		retval = -ENOMEM;
		goto error;
	}

2461
	device_initialize(dev);
2462 2463 2464
	dev->devt = devt;
	dev->class = class;
	dev->parent = parent;
2465
	dev->groups = groups;
2466
	dev->release = device_create_release;
2467
	dev_set_drvdata(dev, drvdata);
2468

2469 2470 2471 2472
	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
	if (retval)
		goto error;

2473
	retval = device_add(dev);
2474 2475 2476 2477 2478 2479
	if (retval)
		goto error;

	return dev;

error:
2480
	put_device(dev);
2481 2482
	return ERR_PTR(retval);
}
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515

/**
 * device_create_vargs - creates a device and registers it with sysfs
 * @class: pointer to the struct class that this device should be registered to
 * @parent: pointer to the parent struct device of this new device, if any
 * @devt: the dev_t for the char device to be added
 * @drvdata: the data to be added to the device for callbacks
 * @fmt: string for the device's name
 * @args: va_list for the device's name
 *
 * This function can be used by char device classes.  A struct device
 * will be created in sysfs, registered to the specified class.
 *
 * A "dev" file will be created, showing the dev_t for the device, if
 * the dev_t is not 0,0.
 * If a pointer to a parent struct device is passed in, the newly created
 * struct device will be a child of that device in sysfs.
 * The pointer to the struct device will be returned from the call.
 * Any further sysfs files that might be required can be created using this
 * pointer.
 *
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
struct device *device_create_vargs(struct class *class, struct device *parent,
				   dev_t devt, void *drvdata, const char *fmt,
				   va_list args)
{
	return device_create_groups_vargs(class, parent, devt, drvdata, NULL,
					  fmt, args);
}
2516 2517 2518
EXPORT_SYMBOL_GPL(device_create_vargs);

/**
2519
 * device_create - creates a device and registers it with sysfs
2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536
 * @class: pointer to the struct class that this device should be registered to
 * @parent: pointer to the parent struct device of this new device, if any
 * @devt: the dev_t for the char device to be added
 * @drvdata: the data to be added to the device for callbacks
 * @fmt: string for the device's name
 *
 * This function can be used by char device classes.  A struct device
 * will be created in sysfs, registered to the specified class.
 *
 * A "dev" file will be created, showing the dev_t for the device, if
 * the dev_t is not 0,0.
 * If a pointer to a parent struct device is passed in, the newly created
 * struct device will be a child of that device in sysfs.
 * The pointer to the struct device will be returned from the call.
 * Any further sysfs files that might be required can be created using this
 * pointer.
 *
2537 2538
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
2539 2540 2541
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
2542 2543
struct device *device_create(struct class *class, struct device *parent,
			     dev_t devt, void *drvdata, const char *fmt, ...)
2544 2545 2546 2547 2548 2549 2550 2551 2552
{
	va_list vargs;
	struct device *dev;

	va_start(vargs, fmt);
	dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
	va_end(vargs);
	return dev;
}
2553
EXPORT_SYMBOL_GPL(device_create);
2554

2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598
/**
 * device_create_with_groups - creates a device and registers it with sysfs
 * @class: pointer to the struct class that this device should be registered to
 * @parent: pointer to the parent struct device of this new device, if any
 * @devt: the dev_t for the char device to be added
 * @drvdata: the data to be added to the device for callbacks
 * @groups: NULL-terminated list of attribute groups to be created
 * @fmt: string for the device's name
 *
 * This function can be used by char device classes.  A struct device
 * will be created in sysfs, registered to the specified class.
 * Additional attributes specified in the groups parameter will also
 * be created automatically.
 *
 * A "dev" file will be created, showing the dev_t for the device, if
 * the dev_t is not 0,0.
 * If a pointer to a parent struct device is passed in, the newly created
 * struct device will be a child of that device in sysfs.
 * The pointer to the struct device will be returned from the call.
 * Any further sysfs files that might be required can be created using this
 * pointer.
 *
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
struct device *device_create_with_groups(struct class *class,
					 struct device *parent, dev_t devt,
					 void *drvdata,
					 const struct attribute_group **groups,
					 const char *fmt, ...)
{
	va_list vargs;
	struct device *dev;

	va_start(vargs, fmt);
	dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,
					 fmt, vargs);
	va_end(vargs);
	return dev;
}
EXPORT_SYMBOL_GPL(device_create_with_groups);

2599
static int __match_devt(struct device *dev, const void *data)
2600
{
2601
	const dev_t *devt = data;
2602

2603
	return dev->devt == *devt;
2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616
}

/**
 * device_destroy - removes a device that was created with device_create()
 * @class: pointer to the struct class that this device was registered with
 * @devt: the dev_t of the device that was previously registered
 *
 * This call unregisters and cleans up a device that was created with a
 * call to device_create().
 */
void device_destroy(struct class *class, dev_t devt)
{
	struct device *dev;
2617

2618
	dev = class_find_device(class, NULL, &devt, __match_devt);
2619 2620
	if (dev) {
		put_device(dev);
2621
		device_unregister(dev);
2622
	}
2623 2624
}
EXPORT_SYMBOL_GPL(device_destroy);
2625 2626 2627 2628 2629

/**
 * device_rename - renames a device
 * @dev: the pointer to the struct device to be renamed
 * @new_name: the new name of the device
2630 2631 2632 2633 2634
 *
 * It is the responsibility of the caller to provide mutual
 * exclusion between two different calls of device_rename
 * on the same device to ensure that new_name is valid and
 * won't conflict with other devices.
2635
 *
2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663
 * Note: Don't call this function.  Currently, the networking layer calls this
 * function, but that will change.  The following text from Kay Sievers offers
 * some insight:
 *
 * Renaming devices is racy at many levels, symlinks and other stuff are not
 * replaced atomically, and you get a "move" uevent, but it's not easy to
 * connect the event to the old and new device. Device nodes are not renamed at
 * all, there isn't even support for that in the kernel now.
 *
 * In the meantime, during renaming, your target name might be taken by another
 * driver, creating conflicts. Or the old name is taken directly after you
 * renamed it -- then you get events for the same DEVPATH, before you even see
 * the "move" event. It's just a mess, and nothing new should ever rely on
 * kernel device renaming. Besides that, it's not even implemented now for
 * other things than (driver-core wise very simple) network devices.
 *
 * We are currently about to change network renaming in udev to completely
 * disallow renaming of devices in the same namespace as the kernel uses,
 * because we can't solve the problems properly, that arise with swapping names
 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only
 * be allowed to some other name than eth[0-9]*, for the aforementioned
 * reasons.
 *
 * Make up a "real" name in the driver before you register anything, or add
 * some other attributes for userspace to find the device, or use udev to add
 * symlinks -- but never rename kernel devices later, it's a complete mess. We
 * don't even want to get into that and try to implement the missing pieces in
 * the core. We really have other pieces to fix in the driver core mess. :)
2664
 */
2665
int device_rename(struct device *dev, const char *new_name)
2666
{
2667
	struct kobject *kobj = &dev->kobj;
2668
	char *old_device_name = NULL;
2669 2670 2671 2672 2673 2674
	int error;

	dev = get_device(dev);
	if (!dev)
		return -EINVAL;

2675
	dev_dbg(dev, "renaming to %s\n", new_name);
2676

2677
	old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
2678 2679 2680
	if (!old_device_name) {
		error = -ENOMEM;
		goto out;
2681 2682
	}

2683
	if (dev->class) {
2684 2685 2686
		error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj,
					     kobj, old_device_name,
					     new_name, kobject_namespace(kobj));
2687 2688 2689
		if (error)
			goto out;
	}
2690

2691
	error = kobject_rename(kobj, new_name);
2692
	if (error)
2693
		goto out;
2694

2695
out:
2696 2697
	put_device(dev);

2698
	kfree(old_device_name);
2699 2700 2701

	return error;
}
2702
EXPORT_SYMBOL_GPL(device_rename);
2703 2704 2705 2706 2707

static int device_move_class_links(struct device *dev,
				   struct device *old_parent,
				   struct device *new_parent)
{
2708
	int error = 0;
2709

2710 2711 2712 2713 2714 2715
	if (old_parent)
		sysfs_remove_link(&dev->kobj, "device");
	if (new_parent)
		error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
					  "device");
	return error;
2716 2717 2718 2719 2720
}

/**
 * device_move - moves a device to a new parent
 * @dev: the pointer to the struct device to be moved
2721
 * @new_parent: the new parent of the device (can be NULL)
2722
 * @dpm_order: how to reorder the dpm_list
2723
 */
2724 2725
int device_move(struct device *dev, struct device *new_parent,
		enum dpm_order dpm_order)
2726 2727 2728
{
	int error;
	struct device *old_parent;
2729
	struct kobject *new_parent_kobj;
2730 2731 2732 2733 2734

	dev = get_device(dev);
	if (!dev)
		return -EINVAL;

2735
	device_pm_lock();
2736
	new_parent = get_device(new_parent);
2737
	new_parent_kobj = get_device_parent(dev, new_parent);
2738 2739 2740 2741 2742
	if (IS_ERR(new_parent_kobj)) {
		error = PTR_ERR(new_parent_kobj);
		put_device(new_parent);
		goto out;
	}
2743

2744 2745
	pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
		 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
2746
	error = kobject_move(&dev->kobj, new_parent_kobj);
2747
	if (error) {
2748
		cleanup_glue_dir(dev, new_parent_kobj);
2749 2750 2751 2752 2753 2754
		put_device(new_parent);
		goto out;
	}
	old_parent = dev->parent;
	dev->parent = new_parent;
	if (old_parent)
2755
		klist_remove(&dev->p->knode_parent);
2756
	if (new_parent) {
2757 2758
		klist_add_tail(&dev->p->knode_parent,
			       &new_parent->p->klist_children);
2759 2760 2761
		set_dev_node(dev, dev_to_node(new_parent));
	}

2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775
	if (dev->class) {
		error = device_move_class_links(dev, old_parent, new_parent);
		if (error) {
			/* We ignore errors on cleanup since we're hosed anyway... */
			device_move_class_links(dev, new_parent, old_parent);
			if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
				if (new_parent)
					klist_remove(&dev->p->knode_parent);
				dev->parent = old_parent;
				if (old_parent) {
					klist_add_tail(&dev->p->knode_parent,
						       &old_parent->p->klist_children);
					set_dev_node(dev, dev_to_node(old_parent));
				}
2776
			}
2777 2778 2779
			cleanup_glue_dir(dev, new_parent_kobj);
			put_device(new_parent);
			goto out;
2780 2781
		}
	}
2782 2783 2784 2785 2786
	switch (dpm_order) {
	case DPM_ORDER_NONE:
		break;
	case DPM_ORDER_DEV_AFTER_PARENT:
		device_pm_move_after(dev, new_parent);
2787
		devices_kset_move_after(dev, new_parent);
2788 2789 2790
		break;
	case DPM_ORDER_PARENT_BEFORE_DEV:
		device_pm_move_before(new_parent, dev);
2791
		devices_kset_move_before(new_parent, dev);
2792 2793 2794
		break;
	case DPM_ORDER_DEV_LAST:
		device_pm_move_last(dev);
2795
		devices_kset_move_last(dev);
2796 2797
		break;
	}
2798

2799 2800
	put_device(old_parent);
out:
2801
	device_pm_unlock();
2802 2803 2804 2805
	put_device(dev);
	return error;
}
EXPORT_SYMBOL_GPL(device_move);
2806 2807 2808 2809 2810 2811

/**
 * device_shutdown - call ->shutdown() on each device to shutdown.
 */
void device_shutdown(void)
{
2812
	struct device *dev, *parent;
2813 2814 2815 2816 2817 2818 2819 2820 2821 2822

	spin_lock(&devices_kset->list_lock);
	/*
	 * Walk the devices list backward, shutting down each in turn.
	 * Beware that device unplug events may also start pulling
	 * devices offline, even as the system is shutting down.
	 */
	while (!list_empty(&devices_kset->list)) {
		dev = list_entry(devices_kset->list.prev, struct device,
				kobj.entry);
2823 2824 2825 2826 2827 2828

		/*
		 * hold reference count of device's parent to
		 * prevent it from being freed because parent's
		 * lock is to be held
		 */
2829
		parent = get_device(dev->parent);
2830 2831 2832 2833 2834 2835 2836
		get_device(dev);
		/*
		 * Make sure the device is off the kset list, in the
		 * event that dev->*->shutdown() doesn't remove it.
		 */
		list_del_init(&dev->kobj.entry);
		spin_unlock(&devices_kset->list_lock);
2837

2838
		/* hold lock to avoid race with probe/release */
2839 2840
		if (parent)
			device_lock(parent);
2841 2842
		device_lock(dev);

2843 2844 2845
		/* Don't allow any more runtime suspends */
		pm_runtime_get_noresume(dev);
		pm_runtime_barrier(dev);
2846

2847
		if (dev->class && dev->class->shutdown_pre) {
2848
			if (initcall_debug)
2849 2850 2851 2852
				dev_info(dev, "shutdown_pre\n");
			dev->class->shutdown_pre(dev);
		}
		if (dev->bus && dev->bus->shutdown) {
2853 2854
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
2855 2856
			dev->bus->shutdown(dev);
		} else if (dev->driver && dev->driver->shutdown) {
2857 2858
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
2859 2860
			dev->driver->shutdown(dev);
		}
2861 2862

		device_unlock(dev);
2863 2864
		if (parent)
			device_unlock(parent);
2865

2866
		put_device(dev);
2867
		put_device(parent);
2868 2869

		spin_lock(&devices_kset->list_lock);
2870
	}
2871
	spin_unlock(&devices_kset->list_lock);
2872
}
2873 2874 2875 2876 2877 2878

/*
 * Device logging functions
 */

#ifdef CONFIG_PRINTK
2879 2880
static int
create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
2881
{
2882
	const char *subsys;
2883
	size_t pos = 0;
2884

2885 2886 2887 2888 2889
	if (dev->class)
		subsys = dev->class->name;
	else if (dev->bus)
		subsys = dev->bus->name;
	else
2890
		return 0;
2891

2892
	pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
2893 2894
	if (pos >= hdrlen)
		goto overflow;
2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909

	/*
	 * Add device identifier DEVICE=:
	 *   b12:8         block dev_t
	 *   c127:3        char dev_t
	 *   n8            netdev ifindex
	 *   +sound:card0  subsystem:devname
	 */
	if (MAJOR(dev->devt)) {
		char c;

		if (strcmp(subsys, "block") == 0)
			c = 'b';
		else
			c = 'c';
2910 2911 2912 2913
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=%c%u:%u",
				c, MAJOR(dev->devt), MINOR(dev->devt));
2914 2915 2916
	} else if (strcmp(subsys, "net") == 0) {
		struct net_device *net = to_net_dev(dev);

2917 2918 2919
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=n%u", net->ifindex);
2920
	} else {
2921 2922 2923
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=+%s:%s", subsys, dev_name(dev));
2924
	}
2925

2926 2927 2928
	if (pos >= hdrlen)
		goto overflow;

2929
	return pos;
2930 2931 2932 2933

overflow:
	dev_WARN(dev, "device/subsystem name too long");
	return 0;
2934 2935
}

2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962
int dev_vprintk_emit(int level, const struct device *dev,
		     const char *fmt, va_list args)
{
	char hdr[128];
	size_t hdrlen;

	hdrlen = create_syslog_header(dev, hdr, sizeof(hdr));

	return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args);
}
EXPORT_SYMBOL(dev_vprintk_emit);

int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
{
	va_list args;
	int r;

	va_start(args, fmt);

	r = dev_vprintk_emit(level, dev, fmt, args);

	va_end(args);

	return r;
}
EXPORT_SYMBOL(dev_printk_emit);

2963
static void __dev_printk(const char *level, const struct device *dev,
2964 2965
			struct va_format *vaf)
{
2966 2967 2968 2969 2970
	if (dev)
		dev_printk_emit(level[1] - '0', dev, "%s %s: %pV",
				dev_driver_string(dev), dev_name(dev), vaf);
	else
		printk("%s(NULL device *): %pV", level, vaf);
2971 2972
}

2973 2974
void dev_printk(const char *level, const struct device *dev,
		const char *fmt, ...)
2975 2976 2977 2978 2979 2980 2981 2982 2983
{
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);

	vaf.fmt = fmt;
	vaf.va = &args;

2984
	__dev_printk(level, dev, &vaf);
2985

2986 2987 2988 2989 2990
	va_end(args);
}
EXPORT_SYMBOL(dev_printk);

#define define_dev_printk_level(func, kern_level)		\
2991
void func(const struct device *dev, const char *fmt, ...)	\
2992 2993 2994 2995 2996 2997 2998 2999 3000
{								\
	struct va_format vaf;					\
	va_list args;						\
								\
	va_start(args, fmt);					\
								\
	vaf.fmt = fmt;						\
	vaf.va = &args;						\
								\
3001
	__dev_printk(kern_level, dev, &vaf);			\
3002
								\
3003 3004 3005 3006
	va_end(args);						\
}								\
EXPORT_SYMBOL(func);

3007 3008 3009 3010 3011 3012
define_dev_printk_level(_dev_emerg, KERN_EMERG);
define_dev_printk_level(_dev_alert, KERN_ALERT);
define_dev_printk_level(_dev_crit, KERN_CRIT);
define_dev_printk_level(_dev_err, KERN_ERR);
define_dev_printk_level(_dev_warn, KERN_WARNING);
define_dev_printk_level(_dev_notice, KERN_NOTICE);
3013 3014 3015
define_dev_printk_level(_dev_info, KERN_INFO);

#endif
3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037

static inline bool fwnode_is_primary(struct fwnode_handle *fwnode)
{
	return fwnode && !IS_ERR(fwnode->secondary);
}

/**
 * set_primary_fwnode - Change the primary firmware node of a given device.
 * @dev: Device to handle.
 * @fwnode: New primary firmware node of the device.
 *
 * Set the device's firmware node pointer to @fwnode, but if a secondary
 * firmware node of the device is present, preserve it.
 */
void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
{
	if (fwnode) {
		struct fwnode_handle *fn = dev->fwnode;

		if (fwnode_is_primary(fn))
			fn = fn->secondary;

3038 3039 3040 3041
		if (fn) {
			WARN_ON(fwnode->secondary);
			fwnode->secondary = fn;
		}
3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068
		dev->fwnode = fwnode;
	} else {
		dev->fwnode = fwnode_is_primary(dev->fwnode) ?
			dev->fwnode->secondary : NULL;
	}
}
EXPORT_SYMBOL_GPL(set_primary_fwnode);

/**
 * set_secondary_fwnode - Change the secondary firmware node of a given device.
 * @dev: Device to handle.
 * @fwnode: New secondary firmware node of the device.
 *
 * If a primary firmware node of the device is present, set its secondary
 * pointer to @fwnode.  Otherwise, set the device's firmware node pointer to
 * @fwnode.
 */
void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
{
	if (fwnode)
		fwnode->secondary = ERR_PTR(-ENODEV);

	if (fwnode_is_primary(dev->fwnode))
		dev->fwnode->secondary = fwnode;
	else
		dev->fwnode = fwnode;
}
3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084

/**
 * device_set_of_node_from_dev - reuse device-tree node of another device
 * @dev: device whose device-tree node is being set
 * @dev2: device whose device-tree node is being reused
 *
 * Takes another reference to the new device-tree node after first dropping
 * any reference held to the old node.
 */
void device_set_of_node_from_dev(struct device *dev, const struct device *dev2)
{
	of_node_put(dev->of_node);
	dev->of_node = of_node_get(dev2->of_node);
	dev->of_node_reused = true;
}
EXPORT_SYMBOL_GPL(device_set_of_node_from_dev);