core.c 81.3 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
/* 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;

108
	if (dev == target)
109 110 111 112 113 114 115
		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) {
116
		if (link->consumer == target)
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
			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
 * If the DL_FLAG_AUTOREMOVE_CONSUMER is set, the link will be removed
 * automatically when the consumer device driver unbinds from it.
 * The combination of both DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_STATELESS
 * set is invalid and will cause NULL to be returned.
185 186 187 188 189 190 191 192
 *
 * 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
 */
struct device_link *device_link_add(struct device *consumer,
				    struct device *supplier, u32 flags)
{
	struct device_link *link;

	if (!consumer || !supplier ||
201 202
	    ((flags & DL_FLAG_STATELESS) &&
	     (flags & DL_FLAG_AUTOREMOVE_CONSUMER)))
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
		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)
220 221
		if (link->consumer == consumer) {
			kref_get(&link->kref);
222
			goto out;
223
		}
224

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

229 230 231 232 233 234 235 236 237
	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 已提交
238
		}
239
		pm_runtime_new_link(consumer);
240 241 242 243 244 245 246
		/*
		 * 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 已提交
247
	}
248 249 250 251 252 253 254
	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;
255
	kref_init(&link->kref);
256

257
	/* Determine the initial link state. */
258 259 260 261 262 263 264
	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 已提交
265
				/*
266 267 268
				 * Some callers expect the link creation during
				 * consumer driver probe to resume the supplier
				 * even without DL_FLAG_RPM_ACTIVE.
R
Rafael J. Wysocki 已提交
269 270
				 */
				if (flags & DL_FLAG_PM_RUNTIME)
271
					pm_runtime_resume(supplier);
R
Rafael J. Wysocki 已提交
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 325
				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));
}

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

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

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

336 337 338 339 340
	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 */
341
static void __device_link_del(struct kref *kref)
342
{
343 344
	struct device_link *link = container_of(kref, struct device_link, kref);

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

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

351 352 353 354 355 356 357 358 359 360 361
	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
362 363 364
 * 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.
365 366 367 368 369
 */
void device_link_del(struct device_link *link)
{
	device_links_write_lock();
	device_pm_lock();
370
	kref_put(&link->kref, __device_link_del);
371 372 373 374 375
	device_pm_unlock();
	device_links_write_unlock();
}
EXPORT_SYMBOL_GPL(device_link_del);

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
/**
 * device_link_remove - remove a link between two devices.
 * @consumer: Consumer end of the link.
 * @supplier: Supplier end of the link.
 *
 * The caller must ensure proper synchronization of this function with runtime
 * PM.
 */
void device_link_remove(void *consumer, struct device *supplier)
{
	struct device_link *link;

	if (WARN_ON(consumer == supplier))
		return;

	device_links_write_lock();
	device_pm_lock();

	list_for_each_entry(link, &supplier->links.consumers, s_node) {
		if (link->consumer == consumer) {
			kref_put(&link->kref, __device_link_del);
			break;
		}
	}

	device_pm_unlock();
	device_links_write_unlock();
}
EXPORT_SYMBOL_GPL(device_link_remove);

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 483 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
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;

513
		if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER)
514
			kref_put(&link->kref, __device_link_del);
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
		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;

549
		WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER);
550
		WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND);
551 552 553 554 555 556 557 558 559 560

		/*
		 * autoremove the links between this @dev and its consumer
		 * devices that are not active, i.e. where the link state
		 * has moved to DL_STATE_SUPPLIER_UNBIND.
		 */
		if (link->status == DL_STATE_SUPPLIER_UNBIND &&
		    link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
			kref_put(&link->kref, __device_link_del);

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 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
		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);
677
		__device_link_del(&link->kref);
678 679 680 681 682
	}

	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);
683
		__device_link_del(&link->kref);
684 685 686 687 688 689 690
	}

	device_links_write_unlock();
}

/* Device links support end. */

691 692
int (*platform_notify)(struct device *dev) = NULL;
int (*platform_notify_remove)(struct device *dev) = NULL;
693 694 695
static struct kobject *dev_kobj;
struct kobject *sysfs_dev_char_kobj;
struct kobject *sysfs_dev_block_kobj;
L
Linus Torvalds 已提交
696

697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
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();
}

719 720 721 722 723 724 725 726 727 728 729
#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 已提交
730

731 732 733 734 735
/**
 * 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 已提交
736
 * the device is not bound to a driver, it will return the name of the bus
737 738 739
 * it is attached to.  If it is not attached to a bus either, an empty
 * string will be returned.
 */
740
const char *dev_driver_string(const struct device *dev)
741
{
742 743 744 745 746 747
	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.
	 */
748
	drv = READ_ONCE(dev->driver);
749
	return drv ? drv->name :
750 751
			(dev->bus ? dev->bus->name :
			(dev->class ? dev->class->name : ""));
752
}
M
Matthew Wilcox 已提交
753
EXPORT_SYMBOL(dev_driver_string);
754

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

757 758
static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
			     char *buf)
L
Linus Torvalds 已提交
759
{
760
	struct device_attribute *dev_attr = to_dev_attr(attr);
761
	struct device *dev = kobj_to_dev(kobj);
762
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
763 764

	if (dev_attr->show)
765
		ret = dev_attr->show(dev, dev_attr, buf);
766
	if (ret >= (ssize_t)PAGE_SIZE) {
767 768
		printk("dev_attr_show: %pS returned bad count\n",
				dev_attr->show);
769
	}
L
Linus Torvalds 已提交
770 771 772
	return ret;
}

773 774
static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
			      const char *buf, size_t count)
L
Linus Torvalds 已提交
775
{
776
	struct device_attribute *dev_attr = to_dev_attr(attr);
777
	struct device *dev = kobj_to_dev(kobj);
778
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
779 780

	if (dev_attr->store)
781
		ret = dev_attr->store(dev, dev_attr, buf, count);
L
Linus Torvalds 已提交
782 783 784
	return ret;
}

785
static const struct sysfs_ops dev_sysfs_ops = {
L
Linus Torvalds 已提交
786 787 788 789
	.show	= dev_attr_show,
	.store	= dev_attr_store,
};

790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839
#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 已提交
840

841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
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 已提交
862
/**
863 864
 * device_release - free device structure.
 * @kobj: device's kobject.
L
Linus Torvalds 已提交
865
 *
866 867 868
 * 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 已提交
869
 */
870
static void device_release(struct kobject *kobj)
L
Linus Torvalds 已提交
871
{
872
	struct device *dev = kobj_to_dev(kobj);
873
	struct device_private *p = dev->p;
L
Linus Torvalds 已提交
874

875 876 877 878 879 880 881 882 883 884 885
	/*
	 * 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 已提交
886 887
	if (dev->release)
		dev->release(dev);
888 889
	else if (dev->type && dev->type->release)
		dev->type->release(dev);
890 891
	else if (dev->class && dev->class->dev_release)
		dev->class->dev_release(dev);
A
Arjan van de Ven 已提交
892 893
	else
		WARN(1, KERN_ERR "Device '%s' does not have a release() "
894
			"function, it is broken and must be fixed.\n",
895
			dev_name(dev));
896
	kfree(p);
L
Linus Torvalds 已提交
897 898
}

899 900
static const void *device_namespace(struct kobject *kobj)
{
901
	struct device *dev = kobj_to_dev(kobj);
902 903 904 905 906 907 908 909
	const void *ns = NULL;

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

	return ns;
}

910 911 912 913 914 915 916 917
static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
{
	struct device *dev = kobj_to_dev(kobj);

	if (dev->class && dev->class->get_ownership)
		dev->class->get_ownership(dev, uid, gid);
}

918
static struct kobj_type device_ktype = {
L
Linus Torvalds 已提交
919 920
	.release	= device_release,
	.sysfs_ops	= &dev_sysfs_ops,
921
	.namespace	= device_namespace,
922
	.get_ownership	= device_get_ownership,
L
Linus Torvalds 已提交
923 924 925
};


926
static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
927 928 929
{
	struct kobj_type *ktype = get_ktype(kobj);

930
	if (ktype == &device_ktype) {
931
		struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
932 933
		if (dev->bus)
			return 1;
934 935
		if (dev->class)
			return 1;
L
Linus Torvalds 已提交
936 937 938 939
	}
	return 0;
}

940
static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
941
{
942
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
943

944 945 946 947 948
	if (dev->bus)
		return dev->bus->name;
	if (dev->class)
		return dev->class->name;
	return NULL;
L
Linus Torvalds 已提交
949 950
}

951 952
static int dev_uevent(struct kset *kset, struct kobject *kobj,
		      struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
953
{
954
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
955 956
	int retval = 0;

957
	/* add device node properties if present */
958
	if (MAJOR(dev->devt)) {
959 960
		const char *tmp;
		const char *name;
961
		umode_t mode = 0;
962 963
		kuid_t uid = GLOBAL_ROOT_UID;
		kgid_t gid = GLOBAL_ROOT_GID;
964

965 966
		add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
		add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
967
		name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
968 969
		if (name) {
			add_uevent_var(env, "DEVNAME=%s", name);
970 971
			if (mode)
				add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
972 973 974 975
			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));
976
			kfree(tmp);
977
		}
978 979
	}

980
	if (dev->type && dev->type->name)
981
		add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
982

983
	if (dev->driver)
984
		add_uevent_var(env, "DRIVER=%s", dev->driver->name);
985

986 987 988
	/* Add common DT information about the device */
	of_device_uevent(dev, env);

989
	/* have the bus specific function add its stuff */
990
	if (dev->bus && dev->bus->uevent) {
991
		retval = dev->bus->uevent(dev, env);
992
		if (retval)
993
			pr_debug("device: '%s': %s: bus uevent() returned %d\n",
994
				 dev_name(dev), __func__, retval);
L
Linus Torvalds 已提交
995 996
	}

997
	/* have the class specific function add its stuff */
998
	if (dev->class && dev->class->dev_uevent) {
999
		retval = dev->class->dev_uevent(dev, env);
1000
		if (retval)
1001
			pr_debug("device: '%s': %s: class uevent() "
1002
				 "returned %d\n", dev_name(dev),
1003
				 __func__, retval);
1004 1005
	}

1006
	/* have the device type specific function add its stuff */
1007
	if (dev->type && dev->type->uevent) {
1008
		retval = dev->type->uevent(dev, env);
1009
		if (retval)
1010
			pr_debug("device: '%s': %s: dev_type uevent() "
1011
				 "returned %d\n", dev_name(dev),
1012
				 __func__, retval);
1013 1014
	}

L
Linus Torvalds 已提交
1015 1016 1017
	return retval;
}

1018
static const struct kset_uevent_ops device_uevent_ops = {
1019 1020 1021
	.filter =	dev_uevent_filter,
	.name =		dev_uevent_name,
	.uevent =	dev_uevent,
L
Linus Torvalds 已提交
1022 1023
};

1024
static ssize_t uevent_show(struct device *dev, struct device_attribute *attr,
1025 1026 1027 1028
			   char *buf)
{
	struct kobject *top_kobj;
	struct kset *kset;
1029
	struct kobj_uevent_env *env = NULL;
1030 1031 1032 1033 1034 1035
	int i;
	size_t count = 0;
	int retval;

	/* search the kset, the device belongs to */
	top_kobj = &dev->kobj;
1036 1037
	while (!top_kobj->kset && top_kobj->parent)
		top_kobj = top_kobj->parent;
1038 1039
	if (!top_kobj->kset)
		goto out;
1040

1041 1042 1043 1044 1045 1046 1047 1048 1049
	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;

1050 1051
	env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
	if (!env)
1052 1053
		return -ENOMEM;

1054
	/* let the kset specific function add its keys */
1055
	retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
1056 1057 1058 1059
	if (retval)
		goto out;

	/* copy keys to file */
1060 1061
	for (i = 0; i < env->envp_idx; i++)
		count += sprintf(&buf[count], "%s\n", env->envp[i]);
1062
out:
1063
	kfree(env);
1064 1065 1066
	return count;
}

1067
static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,
1068 1069
			    const char *buf, size_t count)
{
1070 1071
	if (kobject_synth_uevent(&dev->kobj, buf, count))
		dev_err(dev, "uevent: failed to send synthetic uevent\n");
1072

1073 1074
	return count;
}
1075
static DEVICE_ATTR_RW(uevent);
1076

1077
static ssize_t online_show(struct device *dev, struct device_attribute *attr,
1078 1079 1080 1081
			   char *buf)
{
	bool val;

1082
	device_lock(dev);
1083
	val = !dev->offline;
1084
	device_unlock(dev);
1085 1086 1087
	return sprintf(buf, "%u\n", val);
}

1088
static ssize_t online_store(struct device *dev, struct device_attribute *attr,
1089 1090 1091 1092 1093 1094 1095 1096 1097
			    const char *buf, size_t count)
{
	bool val;
	int ret;

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

1098 1099 1100 1101
	ret = lock_device_hotplug_sysfs();
	if (ret)
		return ret;

1102 1103 1104 1105
	ret = val ? device_online(dev) : device_offline(dev);
	unlock_device_hotplug();
	return ret < 0 ? ret : count;
}
1106
static DEVICE_ATTR_RW(online);
1107

1108
int device_add_groups(struct device *dev, const struct attribute_group **groups)
1109
{
1110
	return sysfs_create_groups(&dev->kobj, groups);
1111
}
1112
EXPORT_SYMBOL_GPL(device_add_groups);
1113

1114 1115
void device_remove_groups(struct device *dev,
			  const struct attribute_group **groups)
1116
{
1117
	sysfs_remove_groups(&dev->kobj, groups);
1118
}
1119
EXPORT_SYMBOL_GPL(device_remove_groups);
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 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
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);
1250

1251 1252 1253
static int device_add_attrs(struct device *dev)
{
	struct class *class = dev->class;
1254
	const struct device_type *type = dev->type;
1255
	int error;
1256

1257
	if (class) {
1258
		error = device_add_groups(dev, class->dev_groups);
1259
		if (error)
1260
			return error;
1261
	}
1262

1263 1264
	if (type) {
		error = device_add_groups(dev, type->groups);
1265
		if (error)
1266
			goto err_remove_class_groups;
1267 1268
	}

1269 1270 1271 1272
	error = device_add_groups(dev, dev->groups);
	if (error)
		goto err_remove_type_groups;

1273
	if (device_supports_offline(dev) && !dev->offline_disabled) {
1274
		error = device_create_file(dev, &dev_attr_online);
1275
		if (error)
1276
			goto err_remove_dev_groups;
1277 1278
	}

1279 1280
	return 0;

1281 1282
 err_remove_dev_groups:
	device_remove_groups(dev, dev->groups);
1283 1284 1285
 err_remove_type_groups:
	if (type)
		device_remove_groups(dev, type->groups);
1286 1287 1288
 err_remove_class_groups:
	if (class)
		device_remove_groups(dev, class->dev_groups);
1289

1290 1291 1292 1293 1294 1295
	return error;
}

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

1298
	device_remove_file(dev, &dev_attr_online);
1299
	device_remove_groups(dev, dev->groups);
1300

1301 1302 1303
	if (type)
		device_remove_groups(dev, type->groups);

1304
	if (class)
1305
		device_remove_groups(dev, class->dev_groups);
1306 1307
}

1308
static ssize_t dev_show(struct device *dev, struct device_attribute *attr,
1309 1310 1311 1312
			char *buf)
{
	return print_dev_t(buf, dev->devt);
}
1313
static DEVICE_ATTR_RO(dev);
1314

1315
/* /sys/devices/ */
1316
struct kset *devices_kset;
L
Linus Torvalds 已提交
1317

1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
/**
 * 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 已提交
1364
/**
1365 1366 1367
 * device_create_file - create sysfs attribute file for device.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
1368
 */
1369 1370
int device_create_file(struct device *dev,
		       const struct device_attribute *attr)
L
Linus Torvalds 已提交
1371 1372
{
	int error = 0;
1373 1374 1375

	if (dev) {
		WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
1376 1377
			"Attribute %s: write permission without 'store'\n",
			attr->attr.name);
1378
		WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
1379 1380
			"Attribute %s: read permission without 'show'\n",
			attr->attr.name);
L
Linus Torvalds 已提交
1381
		error = sysfs_create_file(&dev->kobj, &attr->attr);
1382 1383
	}

L
Linus Torvalds 已提交
1384 1385
	return error;
}
1386
EXPORT_SYMBOL_GPL(device_create_file);
L
Linus Torvalds 已提交
1387 1388

/**
1389 1390 1391
 * device_remove_file - remove sysfs attribute file.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
1392
 */
1393 1394
void device_remove_file(struct device *dev,
			const struct device_attribute *attr)
L
Linus Torvalds 已提交
1395
{
1396
	if (dev)
L
Linus Torvalds 已提交
1397 1398
		sysfs_remove_file(&dev->kobj, &attr->attr);
}
1399
EXPORT_SYMBOL_GPL(device_remove_file);
L
Linus Torvalds 已提交
1400

1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
/**
 * 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);

1418 1419 1420 1421 1422
/**
 * device_create_bin_file - create sysfs binary attribute file for device.
 * @dev: device.
 * @attr: device binary attribute descriptor.
 */
1423 1424
int device_create_bin_file(struct device *dev,
			   const struct bin_attribute *attr)
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
{
	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.
 */
1438 1439
void device_remove_bin_file(struct device *dev,
			    const struct bin_attribute *attr)
1440 1441 1442 1443 1444 1445
{
	if (dev)
		sysfs_remove_bin_file(&dev->kobj, attr);
}
EXPORT_SYMBOL_GPL(device_remove_bin_file);

1446 1447
static void klist_children_get(struct klist_node *n)
{
1448 1449
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
1450 1451 1452 1453 1454 1455

	get_device(dev);
}

static void klist_children_put(struct klist_node *n)
{
1456 1457
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
1458 1459 1460 1461

	put_device(dev);
}

L
Linus Torvalds 已提交
1462
/**
1463 1464
 * device_initialize - init device structure.
 * @dev: device.
L
Linus Torvalds 已提交
1465
 *
1466 1467
 * This prepares the device for use by other layers by initializing
 * its fields.
1468
 * It is the first half of device_register(), if called by
1469 1470 1471 1472 1473
 * 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.
 *
1474 1475 1476 1477 1478
 * 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.
 *
1479 1480
 * NOTE: Use put_device() to give up your reference instead of freeing
 * @dev directly once you have called this function.
L
Linus Torvalds 已提交
1481 1482 1483
 */
void device_initialize(struct device *dev)
{
1484
	dev->kobj.kset = devices_kset;
1485
	kobject_init(&dev->kobj, &device_ktype);
L
Linus Torvalds 已提交
1486
	INIT_LIST_HEAD(&dev->dma_pools);
1487
	mutex_init(&dev->mutex);
1488
	lockdep_set_novalidate_class(&dev->mutex);
T
Tejun Heo 已提交
1489 1490
	spin_lock_init(&dev->devres_lock);
	INIT_LIST_HEAD(&dev->devres_head);
1491
	device_pm_init(dev);
1492
	set_dev_node(dev, -1);
1493 1494 1495
#ifdef CONFIG_GENERIC_MSI_IRQ
	INIT_LIST_HEAD(&dev->msi_list);
#endif
1496 1497 1498
	INIT_LIST_HEAD(&dev->links.consumers);
	INIT_LIST_HEAD(&dev->links.suppliers);
	dev->links.status = DL_DEV_NO_DRIVER;
L
Linus Torvalds 已提交
1499
}
1500
EXPORT_SYMBOL_GPL(device_initialize);
L
Linus Torvalds 已提交
1501

1502
struct kobject *virtual_device_parent(struct device *dev)
1503
{
1504
	static struct kobject *virtual_dir = NULL;
1505

1506
	if (!virtual_dir)
1507
		virtual_dir = kobject_create_and_add("virtual",
1508
						     &devices_kset->kobj);
1509

1510
	return virtual_dir;
1511 1512
}

1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
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)
1528
{
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
	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;
1543 1544
	int retval;

1545 1546
	dir = kzalloc(sizeof(*dir), GFP_KERNEL);
	if (!dir)
1547
		return ERR_PTR(-ENOMEM);
1548 1549 1550 1551

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

1552
	dir->kobj.kset = &class->p->glue_dirs;
1553 1554 1555 1556

	retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
	if (retval < 0) {
		kobject_put(&dir->kobj);
1557
		return ERR_PTR(retval);
1558 1559 1560 1561
	}
	return &dir->kobj;
}

1562
static DEFINE_MUTEX(gdp_mutex);
1563 1564 1565 1566

static struct kobject *get_device_parent(struct device *dev,
					 struct device *parent)
{
1567 1568 1569 1570 1571
	if (dev->class) {
		struct kobject *kobj = NULL;
		struct kobject *parent_kobj;
		struct kobject *k;

1572
#ifdef CONFIG_BLOCK
1573
		/* block disks show up in /sys/block */
1574
		if (sysfs_deprecated && dev->class == &block_class) {
1575 1576
			if (parent && parent->class == &block_class)
				return &parent->kobj;
1577
			return &block_class.p->subsys.kobj;
1578
		}
1579
#endif
1580

1581 1582
		/*
		 * If we have no parent, we live in "virtual".
1583 1584
		 * Class-devices with a non class-device as parent, live
		 * in a "glue" directory to prevent namespace collisions.
1585 1586 1587
		 */
		if (parent == NULL)
			parent_kobj = virtual_device_parent(dev);
1588
		else if (parent->class && !dev->class->ns_type)
1589 1590 1591 1592
			return &parent->kobj;
		else
			parent_kobj = &parent->kobj;

1593 1594
		mutex_lock(&gdp_mutex);

1595
		/* find our class-directory at the parent and reference it */
1596 1597
		spin_lock(&dev->class->p->glue_dirs.list_lock);
		list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
1598 1599 1600 1601
			if (k->parent == parent_kobj) {
				kobj = kobject_get(k);
				break;
			}
1602
		spin_unlock(&dev->class->p->glue_dirs.list_lock);
1603 1604
		if (kobj) {
			mutex_unlock(&gdp_mutex);
1605
			return kobj;
1606
		}
1607 1608

		/* or create a new class-directory at the parent device */
1609
		k = class_dir_create_and_add(dev->class, parent_kobj);
1610
		/* do not emit an uevent for this simple "glue" directory */
1611
		mutex_unlock(&gdp_mutex);
1612
		return k;
1613 1614
	}

1615 1616 1617 1618
	/* subsystems can specify a default root directory for their devices */
	if (!parent && dev->bus && dev->bus->dev_root)
		return &dev->bus->dev_root->kobj;

1619
	if (parent)
1620 1621 1622
		return &parent->kobj;
	return NULL;
}
1623

1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
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
 */
1643
static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
1644
{
1645
	/* see if we live in a "glue" directory */
1646
	if (!live_in_glue_dir(glue_dir, dev))
1647 1648
		return;

1649
	mutex_lock(&gdp_mutex);
1650 1651
	if (!kobject_has_children(glue_dir))
		kobject_del(glue_dir);
1652
	kobject_put(glue_dir);
1653
	mutex_unlock(&gdp_mutex);
1654
}
1655

1656 1657
static int device_add_class_symlinks(struct device *dev)
{
1658
	struct device_node *of_node = dev_of_node(dev);
1659 1660
	int error;

1661
	if (of_node) {
1662
		error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node");
1663 1664 1665 1666 1667
		if (error)
			dev_warn(dev, "Error %d creating of_node link\n",error);
		/* An error here doesn't warrant bringing down the device */
	}

1668 1669
	if (!dev->class)
		return 0;
1670

1671
	error = sysfs_create_link(&dev->kobj,
1672
				  &dev->class->p->subsys.kobj,
1673 1674
				  "subsystem");
	if (error)
1675
		goto out_devnode;
1676

1677
	if (dev->parent && device_is_not_partition(dev)) {
1678
		error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
1679 1680
					  "device");
		if (error)
1681
			goto out_subsys;
1682 1683
	}

1684
#ifdef CONFIG_BLOCK
1685
	/* /sys/block has directories and does not need symlinks */
1686
	if (sysfs_deprecated && dev->class == &block_class)
1687
		return 0;
1688
#endif
1689

1690
	/* link in the class directory pointing to the device */
1691
	error = sysfs_create_link(&dev->class->p->subsys.kobj,
1692
				  &dev->kobj, dev_name(dev));
1693
	if (error)
1694
		goto out_device;
1695 1696 1697

	return 0;

1698 1699
out_device:
	sysfs_remove_link(&dev->kobj, "device");
1700

1701 1702
out_subsys:
	sysfs_remove_link(&dev->kobj, "subsystem");
1703 1704
out_devnode:
	sysfs_remove_link(&dev->kobj, "of_node");
1705 1706 1707 1708 1709
	return error;
}

static void device_remove_class_symlinks(struct device *dev)
{
1710 1711 1712
	if (dev_of_node(dev))
		sysfs_remove_link(&dev->kobj, "of_node");

1713 1714
	if (!dev->class)
		return;
1715

1716
	if (dev->parent && device_is_not_partition(dev))
1717
		sysfs_remove_link(&dev->kobj, "device");
1718
	sysfs_remove_link(&dev->kobj, "subsystem");
1719
#ifdef CONFIG_BLOCK
1720
	if (sysfs_deprecated && dev->class == &block_class)
1721
		return;
1722
#endif
1723
	sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
1724 1725
}

1726 1727 1728
/**
 * dev_set_name - set a device name
 * @dev: device
1729
 * @fmt: format string for the device's name
1730 1731 1732 1733
 */
int dev_set_name(struct device *dev, const char *fmt, ...)
{
	va_list vargs;
1734
	int err;
1735 1736

	va_start(vargs, fmt);
1737
	err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
1738
	va_end(vargs);
1739
	return err;
1740 1741 1742
}
EXPORT_SYMBOL_GPL(dev_set_name);

1743 1744 1745 1746 1747 1748 1749 1750
/**
 * 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 已提交
1751 1752
 * device_remove_sys_dev_entry() will disagree about the presence of
 * the link.
1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
 */
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);
	}
}

1791
static int device_private_init(struct device *dev)
1792 1793 1794 1795 1796 1797 1798
{
	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);
1799
	INIT_LIST_HEAD(&dev->p->deferred_probe);
1800 1801 1802
	return 0;
}

L
Linus Torvalds 已提交
1803
/**
1804 1805
 * device_add - add device to device hierarchy.
 * @dev: device.
L
Linus Torvalds 已提交
1806
 *
1807 1808
 * This is part 2 of device_register(), though may be called
 * separately _iff_ device_initialize() has been called separately.
L
Linus Torvalds 已提交
1809
 *
1810
 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
1811 1812
 * to the global and sibling lists for the device, then
 * adds it to the other relevant subsystems of the driver model.
1813
 *
1814 1815 1816 1817 1818 1819 1820
 * 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.
 *
1821 1822 1823
 * 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 已提交
1824 1825 1826
 */
int device_add(struct device *dev)
{
1827
	struct device *parent;
1828
	struct kobject *kobj;
1829
	struct class_interface *class_intf;
1830
	int error = -EINVAL;
1831
	struct kobject *glue_dir = NULL;
1832

L
Linus Torvalds 已提交
1833
	dev = get_device(dev);
1834 1835 1836
	if (!dev)
		goto done;

1837
	if (!dev->p) {
1838 1839 1840
		error = device_private_init(dev);
		if (error)
			goto done;
1841 1842
	}

1843 1844 1845 1846 1847 1848
	/*
	 * 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) {
1849
		dev_set_name(dev, "%s", dev->init_name);
1850 1851
		dev->init_name = NULL;
	}
1852

1853 1854 1855 1856
	/* 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);

1857 1858
	if (!dev_name(dev)) {
		error = -EINVAL;
1859
		goto name_error;
1860
	}
L
Linus Torvalds 已提交
1861

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

L
Linus Torvalds 已提交
1864
	parent = get_device(dev->parent);
1865
	kobj = get_device_parent(dev, parent);
1866 1867 1868 1869
	if (IS_ERR(kobj)) {
		error = PTR_ERR(kobj);
		goto parent_error;
	}
1870 1871
	if (kobj)
		dev->kobj.parent = kobj;
L
Linus Torvalds 已提交
1872

1873
	/* use parent numa_node */
1874
	if (parent && (dev_to_node(dev) == NUMA_NO_NODE))
1875 1876
		set_dev_node(dev, dev_to_node(parent));

L
Linus Torvalds 已提交
1877
	/* first, register with generic layer. */
1878 1879
	/* we require the name to be set before, and pass NULL */
	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
1880 1881
	if (error) {
		glue_dir = get_glue_dir(dev);
L
Linus Torvalds 已提交
1882
		goto Error;
1883
	}
1884

1885 1886 1887 1888
	/* notify platform of device entry */
	if (platform_notify)
		platform_notify(dev);

1889
	error = device_create_file(dev, &dev_attr_uevent);
1890 1891
	if (error)
		goto attrError;
1892

1893 1894 1895
	error = device_add_class_symlinks(dev);
	if (error)
		goto SymlinkError;
1896 1897
	error = device_add_attrs(dev);
	if (error)
1898
		goto AttrsError;
1899 1900
	error = bus_add_device(dev);
	if (error)
L
Linus Torvalds 已提交
1901
		goto BusError;
1902
	error = dpm_sysfs_add(dev);
1903
	if (error)
1904 1905
		goto DPMError;
	device_pm_add(dev);
1906

1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
	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);
	}

1919
	/* Notify clients of device addition.  This call must come
1920
	 * after dpm_sysfs_add() and before kobject_uevent().
1921 1922 1923 1924 1925
	 */
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_ADD_DEVICE, dev);

1926
	kobject_uevent(&dev->kobj, KOBJ_ADD);
1927
	bus_probe_device(dev);
L
Linus Torvalds 已提交
1928
	if (parent)
1929 1930
		klist_add_tail(&dev->p->knode_parent,
			       &parent->p->klist_children);
L
Linus Torvalds 已提交
1931

1932
	if (dev->class) {
1933
		mutex_lock(&dev->class->p->mutex);
1934
		/* tie the class to the device */
1935
		klist_add_tail(&dev->knode_class,
1936
			       &dev->class->p->klist_devices);
1937 1938

		/* notify any interfaces that the device is here */
1939
		list_for_each_entry(class_intf,
1940
				    &dev->class->p->interfaces, node)
1941 1942
			if (class_intf->add_dev)
				class_intf->add_dev(dev, class_intf);
1943
		mutex_unlock(&dev->class->p->mutex);
1944
	}
1945
done:
L
Linus Torvalds 已提交
1946 1947
	put_device(dev);
	return error;
1948 1949 1950 1951 1952 1953
 SysEntryError:
	if (MAJOR(dev->devt))
		device_remove_file(dev, &dev_attr_dev);
 DevAttrError:
	device_pm_remove(dev);
	dpm_sysfs_remove(dev);
1954
 DPMError:
1955 1956
	bus_remove_device(dev);
 BusError:
1957
	device_remove_attrs(dev);
1958
 AttrsError:
1959 1960
	device_remove_class_symlinks(dev);
 SymlinkError:
1961
	device_remove_file(dev, &dev_attr_uevent);
1962
 attrError:
1963
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1964
	glue_dir = get_glue_dir(dev);
L
Linus Torvalds 已提交
1965 1966
	kobject_del(&dev->kobj);
 Error:
1967
	cleanup_glue_dir(dev, glue_dir);
1968
parent_error:
1969
	put_device(parent);
1970 1971 1972
name_error:
	kfree(dev->p);
	dev->p = NULL;
1973
	goto done;
L
Linus Torvalds 已提交
1974
}
1975
EXPORT_SYMBOL_GPL(device_add);
L
Linus Torvalds 已提交
1976 1977

/**
1978 1979
 * device_register - register a device with the system.
 * @dev: pointer to the device structure
L
Linus Torvalds 已提交
1980
 *
1981 1982 1983 1984 1985 1986
 * 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.
1987
 *
1988 1989 1990
 * For more information, see the kerneldoc for device_initialize()
 * and device_add().
 *
1991 1992 1993
 * 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 已提交
1994 1995 1996 1997 1998 1999
 */
int device_register(struct device *dev)
{
	device_initialize(dev);
	return device_add(dev);
}
2000
EXPORT_SYMBOL_GPL(device_register);
L
Linus Torvalds 已提交
2001 2002

/**
2003 2004
 * get_device - increment reference count for device.
 * @dev: device.
L
Linus Torvalds 已提交
2005
 *
2006 2007 2008
 * 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 已提交
2009
 */
2010
struct device *get_device(struct device *dev)
L
Linus Torvalds 已提交
2011
{
2012
	return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
L
Linus Torvalds 已提交
2013
}
2014
EXPORT_SYMBOL_GPL(get_device);
L
Linus Torvalds 已提交
2015 2016

/**
2017 2018
 * put_device - decrement reference count.
 * @dev: device in question.
L
Linus Torvalds 已提交
2019
 */
2020
void put_device(struct device *dev)
L
Linus Torvalds 已提交
2021
{
2022
	/* might_sleep(); */
L
Linus Torvalds 已提交
2023 2024 2025
	if (dev)
		kobject_put(&dev->kobj);
}
2026
EXPORT_SYMBOL_GPL(put_device);
L
Linus Torvalds 已提交
2027 2028

/**
2029 2030
 * device_del - delete device from system.
 * @dev: device.
L
Linus Torvalds 已提交
2031
 *
2032 2033 2034 2035 2036
 * 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 已提交
2037
 *
2038 2039
 * NOTE: this should be called manually _iff_ device_add() was
 * also called manually.
L
Linus Torvalds 已提交
2040
 */
2041
void device_del(struct device *dev)
L
Linus Torvalds 已提交
2042
{
2043
	struct device *parent = dev->parent;
2044
	struct kobject *glue_dir = NULL;
2045
	struct class_interface *class_intf;
L
Linus Torvalds 已提交
2046

2047 2048 2049 2050 2051 2052
	/* 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);
2053

2054
	dpm_sysfs_remove(dev);
L
Linus Torvalds 已提交
2055
	if (parent)
2056
		klist_del(&dev->p->knode_parent);
2057
	if (MAJOR(dev->devt)) {
2058
		devtmpfs_delete_node(dev);
2059
		device_remove_sys_dev_entry(dev);
2060
		device_remove_file(dev, &dev_attr_dev);
2061
	}
2062
	if (dev->class) {
2063
		device_remove_class_symlinks(dev);
2064

2065
		mutex_lock(&dev->class->p->mutex);
2066
		/* notify any interfaces that the device is now gone */
2067
		list_for_each_entry(class_intf,
2068
				    &dev->class->p->interfaces, node)
2069 2070 2071
			if (class_intf->remove_dev)
				class_intf->remove_dev(dev, class_intf);
		/* remove the device from the class list */
2072
		klist_del(&dev->knode_class);
2073
		mutex_unlock(&dev->class->p->mutex);
2074
	}
2075
	device_remove_file(dev, &dev_attr_uevent);
2076
	device_remove_attrs(dev);
2077
	bus_remove_device(dev);
2078
	device_pm_remove(dev);
2079
	driver_deferred_probe_del(dev);
2080
	device_remove_properties(dev);
2081
	device_links_purge(dev);
L
Linus Torvalds 已提交
2082 2083 2084 2085 2086 2087

	/* Notify the platform of the removal, in case they
	 * need to do anything...
	 */
	if (platform_notify_remove)
		platform_notify_remove(dev);
2088 2089 2090
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_REMOVED_DEVICE, dev);
2091
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
2092
	glue_dir = get_glue_dir(dev);
L
Linus Torvalds 已提交
2093
	kobject_del(&dev->kobj);
2094
	cleanup_glue_dir(dev, glue_dir);
2095
	put_device(parent);
L
Linus Torvalds 已提交
2096
}
2097
EXPORT_SYMBOL_GPL(device_del);
L
Linus Torvalds 已提交
2098 2099

/**
2100 2101
 * device_unregister - unregister device from system.
 * @dev: device going away.
L
Linus Torvalds 已提交
2102
 *
2103 2104 2105 2106 2107 2108
 * 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 已提交
2109
 */
2110
void device_unregister(struct device *dev)
L
Linus Torvalds 已提交
2111
{
2112
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
L
Linus Torvalds 已提交
2113 2114 2115
	device_del(dev);
	put_device(dev);
}
2116
EXPORT_SYMBOL_GPL(device_unregister);
L
Linus Torvalds 已提交
2117

2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130
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;
}

2131
static struct device *next_device(struct klist_iter *i)
2132
{
2133
	struct klist_node *n = klist_next(i);
2134 2135 2136 2137 2138 2139 2140 2141
	struct device *dev = NULL;
	struct device_private *p;

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

2144
/**
2145
 * device_get_devnode - path of device node file
2146
 * @dev: device
2147
 * @mode: returned file access mode
2148 2149
 * @uid: returned file owner
 * @gid: returned file group
2150 2151 2152 2153 2154 2155 2156
 * @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.
 */
2157
const char *device_get_devnode(struct device *dev,
2158
			       umode_t *mode, kuid_t *uid, kgid_t *gid,
2159
			       const char **tmp)
2160 2161 2162 2163 2164 2165
{
	char *s;

	*tmp = NULL;

	/* the device type may provide a specific name */
2166
	if (dev->type && dev->type->devnode)
2167
		*tmp = dev->type->devnode(dev, mode, uid, gid);
2168 2169 2170 2171
	if (*tmp)
		return *tmp;

	/* the class may provide a specific name */
2172 2173
	if (dev->class && dev->class->devnode)
		*tmp = dev->class->devnode(dev, mode);
2174 2175 2176 2177 2178 2179 2180 2181
	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 '/' */
2182 2183
	s = kstrdup(dev_name(dev), GFP_KERNEL);
	if (!s)
2184
		return NULL;
2185 2186
	strreplace(s, '!', '/');
	return *tmp = s;
2187 2188
}

L
Linus Torvalds 已提交
2189
/**
2190 2191 2192
 * device_for_each_child - device child iterator.
 * @parent: parent struct device.
 * @fn: function to be called for each device.
2193
 * @data: data for the callback.
L
Linus Torvalds 已提交
2194
 *
2195 2196
 * Iterate over @parent's child devices, and call @fn for each,
 * passing it @data.
L
Linus Torvalds 已提交
2197
 *
2198 2199
 * 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 已提交
2200
 */
2201 2202
int device_for_each_child(struct device *parent, void *data,
			  int (*fn)(struct device *dev, void *data))
L
Linus Torvalds 已提交
2203
{
2204
	struct klist_iter i;
2205
	struct device *child;
L
Linus Torvalds 已提交
2206 2207
	int error = 0;

2208 2209 2210
	if (!parent->p)
		return 0;

2211
	klist_iter_init(&parent->p->klist_children, &i);
2212
	while (!error && (child = next_device(&i)))
2213 2214
		error = fn(child, data);
	klist_iter_exit(&i);
L
Linus Torvalds 已提交
2215 2216
	return error;
}
2217
EXPORT_SYMBOL_GPL(device_for_each_child);
L
Linus Torvalds 已提交
2218

2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
/**
 * 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);

2249 2250 2251 2252
/**
 * device_find_child - device iterator for locating a particular device.
 * @parent: parent struct device
 * @match: Callback function to check device
2253
 * @data: Data to pass to match function
2254 2255 2256 2257 2258 2259 2260 2261 2262
 *
 * 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.
2263 2264
 *
 * NOTE: you will need to drop the reference with put_device() after use.
2265
 */
2266 2267
struct device *device_find_child(struct device *parent, void *data,
				 int (*match)(struct device *dev, void *data))
2268 2269 2270 2271 2272 2273 2274
{
	struct klist_iter i;
	struct device *child;

	if (!parent)
		return NULL;

2275
	klist_iter_init(&parent->p->klist_children, &i);
2276 2277 2278 2279 2280 2281
	while ((child = next_device(&i)))
		if (match(child, data) && get_device(child))
			break;
	klist_iter_exit(&i);
	return child;
}
2282
EXPORT_SYMBOL_GPL(device_find_child);
2283

L
Linus Torvalds 已提交
2284 2285
int __init devices_init(void)
{
2286 2287 2288
	devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
	if (!devices_kset)
		return -ENOMEM;
2289 2290 2291 2292 2293 2294 2295 2296 2297 2298
	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;

2299
	return 0;
2300 2301 2302 2303 2304 2305 2306 2307

 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 已提交
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 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390
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;
}

2391
struct root_device {
2392 2393 2394 2395
	struct device dev;
	struct module *owner;
};

2396
static inline struct root_device *to_root_device(struct device *d)
2397 2398 2399
{
	return container_of(d, struct root_device, dev);
}
2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423

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.
 *
2424 2425
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
 * 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);

2437
	err = dev_set_name(&root->dev, "%s", name);
2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450
	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);
	}

2451
#ifdef CONFIG_MODULES	/* gotta find a "cleaner" way to do this */
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469
	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
2470
 * @dev: device going away
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485
 *
 * 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);

2486 2487 2488

static void device_create_release(struct device *dev)
{
2489
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
2490 2491 2492
	kfree(dev);
}

2493
static __printf(6, 0) struct device *
2494 2495 2496 2497
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)
2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510
{
	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;
	}

2511
	device_initialize(dev);
2512 2513 2514
	dev->devt = devt;
	dev->class = class;
	dev->parent = parent;
2515
	dev->groups = groups;
2516
	dev->release = device_create_release;
2517
	dev_set_drvdata(dev, drvdata);
2518

2519 2520 2521 2522
	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
	if (retval)
		goto error;

2523
	retval = device_add(dev);
2524 2525 2526 2527 2528 2529
	if (retval)
		goto error;

	return dev;

error:
2530
	put_device(dev);
2531 2532
	return ERR_PTR(retval);
}
2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565

/**
 * 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);
}
2566 2567 2568
EXPORT_SYMBOL_GPL(device_create_vargs);

/**
2569
 * device_create - creates a device and registers it with sysfs
2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
 * @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.
 *
2587 2588
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
2589 2590 2591
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
2592 2593
struct device *device_create(struct class *class, struct device *parent,
			     dev_t devt, void *drvdata, const char *fmt, ...)
2594 2595 2596 2597 2598 2599 2600 2601 2602
{
	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;
}
2603
EXPORT_SYMBOL_GPL(device_create);
2604

2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648
/**
 * 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);

2649
static int __match_devt(struct device *dev, const void *data)
2650
{
2651
	const dev_t *devt = data;
2652

2653
	return dev->devt == *devt;
2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666
}

/**
 * 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;
2667

2668
	dev = class_find_device(class, NULL, &devt, __match_devt);
2669 2670
	if (dev) {
		put_device(dev);
2671
		device_unregister(dev);
2672
	}
2673 2674
}
EXPORT_SYMBOL_GPL(device_destroy);
2675 2676 2677 2678 2679

/**
 * device_rename - renames a device
 * @dev: the pointer to the struct device to be renamed
 * @new_name: the new name of the device
2680 2681 2682 2683 2684
 *
 * 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.
2685
 *
2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713
 * 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. :)
2714
 */
2715
int device_rename(struct device *dev, const char *new_name)
2716
{
2717
	struct kobject *kobj = &dev->kobj;
2718
	char *old_device_name = NULL;
2719 2720 2721 2722 2723 2724
	int error;

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

2725
	dev_dbg(dev, "renaming to %s\n", new_name);
2726

2727
	old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
2728 2729 2730
	if (!old_device_name) {
		error = -ENOMEM;
		goto out;
2731 2732
	}

2733
	if (dev->class) {
2734 2735 2736
		error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj,
					     kobj, old_device_name,
					     new_name, kobject_namespace(kobj));
2737 2738 2739
		if (error)
			goto out;
	}
2740

2741
	error = kobject_rename(kobj, new_name);
2742
	if (error)
2743
		goto out;
2744

2745
out:
2746 2747
	put_device(dev);

2748
	kfree(old_device_name);
2749 2750 2751

	return error;
}
2752
EXPORT_SYMBOL_GPL(device_rename);
2753 2754 2755 2756 2757

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

2760 2761 2762 2763 2764 2765
	if (old_parent)
		sysfs_remove_link(&dev->kobj, "device");
	if (new_parent)
		error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
					  "device");
	return error;
2766 2767 2768 2769 2770
}

/**
 * device_move - moves a device to a new parent
 * @dev: the pointer to the struct device to be moved
2771
 * @new_parent: the new parent of the device (can be NULL)
2772
 * @dpm_order: how to reorder the dpm_list
2773
 */
2774 2775
int device_move(struct device *dev, struct device *new_parent,
		enum dpm_order dpm_order)
2776 2777 2778
{
	int error;
	struct device *old_parent;
2779
	struct kobject *new_parent_kobj;
2780 2781 2782 2783 2784

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

2785
	device_pm_lock();
2786
	new_parent = get_device(new_parent);
2787
	new_parent_kobj = get_device_parent(dev, new_parent);
2788 2789 2790 2791 2792
	if (IS_ERR(new_parent_kobj)) {
		error = PTR_ERR(new_parent_kobj);
		put_device(new_parent);
		goto out;
	}
2793

2794 2795
	pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
		 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
2796
	error = kobject_move(&dev->kobj, new_parent_kobj);
2797
	if (error) {
2798
		cleanup_glue_dir(dev, new_parent_kobj);
2799 2800 2801 2802 2803 2804
		put_device(new_parent);
		goto out;
	}
	old_parent = dev->parent;
	dev->parent = new_parent;
	if (old_parent)
2805
		klist_remove(&dev->p->knode_parent);
2806
	if (new_parent) {
2807 2808
		klist_add_tail(&dev->p->knode_parent,
			       &new_parent->p->klist_children);
2809 2810 2811
		set_dev_node(dev, dev_to_node(new_parent));
	}

2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
	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));
				}
2826
			}
2827 2828 2829
			cleanup_glue_dir(dev, new_parent_kobj);
			put_device(new_parent);
			goto out;
2830 2831
		}
	}
2832 2833 2834 2835 2836
	switch (dpm_order) {
	case DPM_ORDER_NONE:
		break;
	case DPM_ORDER_DEV_AFTER_PARENT:
		device_pm_move_after(dev, new_parent);
2837
		devices_kset_move_after(dev, new_parent);
2838 2839 2840
		break;
	case DPM_ORDER_PARENT_BEFORE_DEV:
		device_pm_move_before(new_parent, dev);
2841
		devices_kset_move_before(new_parent, dev);
2842 2843 2844
		break;
	case DPM_ORDER_DEV_LAST:
		device_pm_move_last(dev);
2845
		devices_kset_move_last(dev);
2846 2847
		break;
	}
2848

2849 2850
	put_device(old_parent);
out:
2851
	device_pm_unlock();
2852 2853 2854 2855
	put_device(dev);
	return error;
}
EXPORT_SYMBOL_GPL(device_move);
2856 2857 2858 2859 2860 2861

/**
 * device_shutdown - call ->shutdown() on each device to shutdown.
 */
void device_shutdown(void)
{
2862
	struct device *dev, *parent;
2863

2864 2865 2866
	wait_for_device_probe();
	device_block_probing();

2867 2868 2869 2870 2871 2872 2873 2874 2875
	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);
2876 2877 2878 2879 2880 2881

		/*
		 * hold reference count of device's parent to
		 * prevent it from being freed because parent's
		 * lock is to be held
		 */
2882
		parent = get_device(dev->parent);
2883 2884 2885 2886 2887 2888 2889
		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);
2890

2891
		/* hold lock to avoid race with probe/release */
2892 2893
		if (parent)
			device_lock(parent);
2894 2895
		device_lock(dev);

2896 2897 2898
		/* Don't allow any more runtime suspends */
		pm_runtime_get_noresume(dev);
		pm_runtime_barrier(dev);
2899

2900
		if (dev->class && dev->class->shutdown_pre) {
2901
			if (initcall_debug)
2902 2903 2904 2905
				dev_info(dev, "shutdown_pre\n");
			dev->class->shutdown_pre(dev);
		}
		if (dev->bus && dev->bus->shutdown) {
2906 2907
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
2908 2909
			dev->bus->shutdown(dev);
		} else if (dev->driver && dev->driver->shutdown) {
2910 2911
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
2912 2913
			dev->driver->shutdown(dev);
		}
2914 2915

		device_unlock(dev);
2916 2917
		if (parent)
			device_unlock(parent);
2918

2919
		put_device(dev);
2920
		put_device(parent);
2921 2922

		spin_lock(&devices_kset->list_lock);
2923
	}
2924
	spin_unlock(&devices_kset->list_lock);
2925
}
2926 2927 2928 2929 2930 2931

/*
 * Device logging functions
 */

#ifdef CONFIG_PRINTK
2932 2933
static int
create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
2934
{
2935
	const char *subsys;
2936
	size_t pos = 0;
2937

2938 2939 2940 2941 2942
	if (dev->class)
		subsys = dev->class->name;
	else if (dev->bus)
		subsys = dev->bus->name;
	else
2943
		return 0;
2944

2945
	pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
2946 2947
	if (pos >= hdrlen)
		goto overflow;
2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962

	/*
	 * 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';
2963 2964 2965 2966
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=%c%u:%u",
				c, MAJOR(dev->devt), MINOR(dev->devt));
2967 2968 2969
	} else if (strcmp(subsys, "net") == 0) {
		struct net_device *net = to_net_dev(dev);

2970 2971 2972
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=n%u", net->ifindex);
2973
	} else {
2974 2975 2976
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=+%s:%s", subsys, dev_name(dev));
2977
	}
2978

2979 2980 2981
	if (pos >= hdrlen)
		goto overflow;

2982
	return pos;
2983 2984 2985 2986

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

2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015
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);

3016
static void __dev_printk(const char *level, const struct device *dev,
3017 3018
			struct va_format *vaf)
{
3019 3020 3021 3022 3023
	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);
3024 3025
}

3026 3027
void dev_printk(const char *level, const struct device *dev,
		const char *fmt, ...)
3028 3029 3030 3031 3032 3033 3034 3035 3036
{
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);

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

3037
	__dev_printk(level, dev, &vaf);
3038

3039 3040 3041 3042 3043
	va_end(args);
}
EXPORT_SYMBOL(dev_printk);

#define define_dev_printk_level(func, kern_level)		\
3044
void func(const struct device *dev, const char *fmt, ...)	\
3045 3046 3047 3048 3049 3050 3051 3052 3053
{								\
	struct va_format vaf;					\
	va_list args;						\
								\
	va_start(args, fmt);					\
								\
	vaf.fmt = fmt;						\
	vaf.va = &args;						\
								\
3054
	__dev_printk(kern_level, dev, &vaf);			\
3055
								\
3056 3057 3058 3059
	va_end(args);						\
}								\
EXPORT_SYMBOL(func);

3060 3061 3062 3063 3064 3065
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);
3066 3067 3068
define_dev_printk_level(_dev_info, KERN_INFO);

#endif
3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090

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;

3091 3092 3093 3094
		if (fn) {
			WARN_ON(fwnode->secondary);
			fwnode->secondary = fn;
		}
3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121
		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;
}
3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137

/**
 * 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);