core.c 56.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 * 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
6 7
 * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
 * Copyright (c) 2006 Novell, Inc.
L
Linus Torvalds 已提交
8 9 10 11 12 13 14 15 16 17 18
 *
 * This file is released under the GPLv2
 *
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
19
#include <linux/kdev_t.h>
20
#include <linux/notifier.h>
21 22
#include <linux/of.h>
#include <linux/of_device.h>
23
#include <linux/genhd.h>
24
#include <linux/kallsyms.h>
25
#include <linux/mutex.h>
26
#include <linux/async.h>
27
#include <linux/pm_runtime.h>
28
#include <linux/netdevice.h>
L
Linus Torvalds 已提交
29 30 31 32

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

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

46 47
int (*platform_notify)(struct device *dev) = NULL;
int (*platform_notify_remove)(struct device *dev) = NULL;
48 49 50
static struct kobject *dev_kobj;
struct kobject *sysfs_dev_char_kobj;
struct kobject *sysfs_dev_block_kobj;
L
Linus Torvalds 已提交
51

52 53 54 55 56 57 58 59 60 61 62
#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 已提交
63

64 65 66 67 68
/**
 * 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 已提交
69
 * the device is not bound to a driver, it will return the name of the bus
70 71 72
 * it is attached to.  If it is not attached to a bus either, an empty
 * string will be returned.
 */
73
const char *dev_driver_string(const struct device *dev)
74
{
75 76 77 78 79 80 81 82
	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.
	 */
	drv = ACCESS_ONCE(dev->driver);
	return drv ? drv->name :
83 84
			(dev->bus ? dev->bus->name :
			(dev->class ? dev->class->name : ""));
85
}
M
Matthew Wilcox 已提交
86
EXPORT_SYMBOL(dev_driver_string);
87

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

90 91
static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
			     char *buf)
L
Linus Torvalds 已提交
92
{
93
	struct device_attribute *dev_attr = to_dev_attr(attr);
94
	struct device *dev = kobj_to_dev(kobj);
95
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
96 97

	if (dev_attr->show)
98
		ret = dev_attr->show(dev, dev_attr, buf);
99
	if (ret >= (ssize_t)PAGE_SIZE) {
100 101
		print_symbol("dev_attr_show: %s returned bad count\n",
				(unsigned long)dev_attr->show);
102
	}
L
Linus Torvalds 已提交
103 104 105
	return ret;
}

106 107
static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
			      const char *buf, size_t count)
L
Linus Torvalds 已提交
108
{
109
	struct device_attribute *dev_attr = to_dev_attr(attr);
110
	struct device *dev = kobj_to_dev(kobj);
111
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
112 113

	if (dev_attr->store)
114
		ret = dev_attr->store(dev, dev_attr, buf, count);
L
Linus Torvalds 已提交
115 116 117
	return ret;
}

118
static const struct sysfs_ops dev_sysfs_ops = {
L
Linus Torvalds 已提交
119 120 121 122
	.show	= dev_attr_show,
	.store	= dev_attr_store,
};

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
#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 已提交
173

174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
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 已提交
195
/**
196 197
 * device_release - free device structure.
 * @kobj: device's kobject.
L
Linus Torvalds 已提交
198
 *
199 200 201
 * 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 已提交
202
 */
203
static void device_release(struct kobject *kobj)
L
Linus Torvalds 已提交
204
{
205
	struct device *dev = kobj_to_dev(kobj);
206
	struct device_private *p = dev->p;
L
Linus Torvalds 已提交
207

208 209 210 211 212 213 214 215 216 217 218
	/*
	 * 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 已提交
219 220
	if (dev->release)
		dev->release(dev);
221 222
	else if (dev->type && dev->type->release)
		dev->type->release(dev);
223 224
	else if (dev->class && dev->class->dev_release)
		dev->class->dev_release(dev);
A
Arjan van de Ven 已提交
225 226
	else
		WARN(1, KERN_ERR "Device '%s' does not have a release() "
227
			"function, it is broken and must be fixed.\n",
228
			dev_name(dev));
229
	kfree(p);
L
Linus Torvalds 已提交
230 231
}

232 233
static const void *device_namespace(struct kobject *kobj)
{
234
	struct device *dev = kobj_to_dev(kobj);
235 236 237 238 239 240 241 242
	const void *ns = NULL;

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

	return ns;
}

243
static struct kobj_type device_ktype = {
L
Linus Torvalds 已提交
244 245
	.release	= device_release,
	.sysfs_ops	= &dev_sysfs_ops,
246
	.namespace	= device_namespace,
L
Linus Torvalds 已提交
247 248 249
};


250
static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
251 252 253
{
	struct kobj_type *ktype = get_ktype(kobj);

254
	if (ktype == &device_ktype) {
255
		struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
256 257
		if (dev->bus)
			return 1;
258 259
		if (dev->class)
			return 1;
L
Linus Torvalds 已提交
260 261 262 263
	}
	return 0;
}

264
static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
265
{
266
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
267

268 269 270 271 272
	if (dev->bus)
		return dev->bus->name;
	if (dev->class)
		return dev->class->name;
	return NULL;
L
Linus Torvalds 已提交
273 274
}

275 276
static int dev_uevent(struct kset *kset, struct kobject *kobj,
		      struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
277
{
278
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
279 280
	int retval = 0;

281
	/* add device node properties if present */
282
	if (MAJOR(dev->devt)) {
283 284
		const char *tmp;
		const char *name;
285
		umode_t mode = 0;
286 287
		kuid_t uid = GLOBAL_ROOT_UID;
		kgid_t gid = GLOBAL_ROOT_GID;
288

289 290
		add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
		add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
291
		name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
292 293
		if (name) {
			add_uevent_var(env, "DEVNAME=%s", name);
294 295
			if (mode)
				add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
296 297 298 299
			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));
300
			kfree(tmp);
301
		}
302 303
	}

304
	if (dev->type && dev->type->name)
305
		add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
306

307
	if (dev->driver)
308
		add_uevent_var(env, "DRIVER=%s", dev->driver->name);
309

310 311 312
	/* Add common DT information about the device */
	of_device_uevent(dev, env);

313
	/* have the bus specific function add its stuff */
314
	if (dev->bus && dev->bus->uevent) {
315
		retval = dev->bus->uevent(dev, env);
316
		if (retval)
317
			pr_debug("device: '%s': %s: bus uevent() returned %d\n",
318
				 dev_name(dev), __func__, retval);
L
Linus Torvalds 已提交
319 320
	}

321
	/* have the class specific function add its stuff */
322
	if (dev->class && dev->class->dev_uevent) {
323
		retval = dev->class->dev_uevent(dev, env);
324
		if (retval)
325
			pr_debug("device: '%s': %s: class uevent() "
326
				 "returned %d\n", dev_name(dev),
327
				 __func__, retval);
328 329
	}

330
	/* have the device type specific function add its stuff */
331
	if (dev->type && dev->type->uevent) {
332
		retval = dev->type->uevent(dev, env);
333
		if (retval)
334
			pr_debug("device: '%s': %s: dev_type uevent() "
335
				 "returned %d\n", dev_name(dev),
336
				 __func__, retval);
337 338
	}

L
Linus Torvalds 已提交
339 340 341
	return retval;
}

342
static const struct kset_uevent_ops device_uevent_ops = {
343 344 345
	.filter =	dev_uevent_filter,
	.name =		dev_uevent_name,
	.uevent =	dev_uevent,
L
Linus Torvalds 已提交
346 347
};

348 349 350 351 352
static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct kobject *top_kobj;
	struct kset *kset;
353
	struct kobj_uevent_env *env = NULL;
354 355 356 357 358 359
	int i;
	size_t count = 0;
	int retval;

	/* search the kset, the device belongs to */
	top_kobj = &dev->kobj;
360 361
	while (!top_kobj->kset && top_kobj->parent)
		top_kobj = top_kobj->parent;
362 363
	if (!top_kobj->kset)
		goto out;
364

365 366 367 368 369 370 371 372 373
	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;

374 375
	env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
	if (!env)
376 377
		return -ENOMEM;

378
	/* let the kset specific function add its keys */
379
	retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
380 381 382 383
	if (retval)
		goto out;

	/* copy keys to file */
384 385
	for (i = 0; i < env->envp_idx; i++)
		count += sprintf(&buf[count], "%s\n", env->envp[i]);
386
out:
387
	kfree(env);
388 389 390
	return count;
}

391 392 393
static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
394 395
	enum kobject_action action;

396
	if (kobject_action_type(buf, count, &action) == 0)
397
		kobject_uevent(&dev->kobj, action);
398 399
	else
		dev_err(dev, "uevent: unknown action-string\n");
400 401 402
	return count;
}

403 404 405
static struct device_attribute uevent_attr =
	__ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);

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
static ssize_t show_online(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	bool val;

	lock_device_hotplug();
	val = !dev->offline;
	unlock_device_hotplug();
	return sprintf(buf, "%u\n", val);
}

static ssize_t store_online(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	bool val;
	int ret;

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

	lock_device_hotplug();
	ret = val ? device_online(dev) : device_offline(dev);
	unlock_device_hotplug();
	return ret < 0 ? ret : count;
}

static struct device_attribute online_attr =
	__ATTR(online, S_IRUGO | S_IWUSR, show_online, store_online);

436 437
static int device_add_attributes(struct device *dev,
				 struct device_attribute *attrs)
438
{
439
	int error = 0;
440
	int i;
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464

	if (attrs) {
		for (i = 0; attr_name(attrs[i]); i++) {
			error = device_create_file(dev, &attrs[i]);
			if (error)
				break;
		}
		if (error)
			while (--i >= 0)
				device_remove_file(dev, &attrs[i]);
	}
	return error;
}

static void device_remove_attributes(struct device *dev,
				     struct device_attribute *attrs)
{
	int i;

	if (attrs)
		for (i = 0; attr_name(attrs[i]); i++)
			device_remove_file(dev, &attrs[i]);
}

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
static int device_add_bin_attributes(struct device *dev,
				     struct bin_attribute *attrs)
{
	int error = 0;
	int i;

	if (attrs) {
		for (i = 0; attr_name(attrs[i]); i++) {
			error = device_create_bin_file(dev, &attrs[i]);
			if (error)
				break;
		}
		if (error)
			while (--i >= 0)
				device_remove_bin_file(dev, &attrs[i]);
	}
	return error;
}

static void device_remove_bin_attributes(struct device *dev,
					 struct bin_attribute *attrs)
{
	int i;

	if (attrs)
		for (i = 0; attr_name(attrs[i]); i++)
			device_remove_bin_file(dev, &attrs[i]);
}

494
static int device_add_groups(struct device *dev,
495
			     const struct attribute_group **groups)
496
{
497
	int error = 0;
498
	int i;
499

500 501 502
	if (groups) {
		for (i = 0; groups[i]; i++) {
			error = sysfs_create_group(&dev->kobj, groups[i]);
503 504
			if (error) {
				while (--i >= 0)
505 506
					sysfs_remove_group(&dev->kobj,
							   groups[i]);
507
				break;
508 509 510 511 512 513
			}
		}
	}
	return error;
}

514
static void device_remove_groups(struct device *dev,
515
				 const struct attribute_group **groups)
516 517
{
	int i;
518 519 520 521

	if (groups)
		for (i = 0; groups[i]; i++)
			sysfs_remove_group(&dev->kobj, groups[i]);
522 523
}

524 525 526
static int device_add_attrs(struct device *dev)
{
	struct class *class = dev->class;
527
	const struct device_type *type = dev->type;
528
	int error;
529

530
	if (class) {
531
		error = device_add_groups(dev, class->dev_groups);
532
		if (error)
533
			return error;
534 535 536
		error = device_add_attributes(dev, class->dev_attrs);
		if (error)
			goto err_remove_class_groups;
537 538 539
		error = device_add_bin_attributes(dev, class->dev_bin_attrs);
		if (error)
			goto err_remove_class_attrs;
540
	}
541

542 543
	if (type) {
		error = device_add_groups(dev, type->groups);
544
		if (error)
545
			goto err_remove_class_bin_attrs;
546 547
	}

548 549 550 551
	error = device_add_groups(dev, dev->groups);
	if (error)
		goto err_remove_type_groups;

552 553 554 555 556 557
	if (device_supports_offline(dev) && !dev->offline_disabled) {
		error = device_create_file(dev, &online_attr);
		if (error)
			goto err_remove_type_groups;
	}

558 559 560 561 562
	return 0;

 err_remove_type_groups:
	if (type)
		device_remove_groups(dev, type->groups);
563 564 565
 err_remove_class_bin_attrs:
	if (class)
		device_remove_bin_attributes(dev, class->dev_bin_attrs);
566 567 568
 err_remove_class_attrs:
	if (class)
		device_remove_attributes(dev, class->dev_attrs);
569 570 571
 err_remove_class_groups:
	if (class)
		device_remove_groups(dev, class->dev_groups);
572

573 574 575 576 577 578
	return error;
}

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

581
	device_remove_file(dev, &online_attr);
582
	device_remove_groups(dev, dev->groups);
583

584 585 586
	if (type)
		device_remove_groups(dev, type->groups);

587
	if (class) {
588
		device_remove_attributes(dev, class->dev_attrs);
589
		device_remove_bin_attributes(dev, class->dev_bin_attrs);
590
		device_remove_groups(dev, class->dev_groups);
591
	}
592 593 594
}


595 596 597 598 599 600
static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	return print_dev_t(buf, dev->devt);
}

601 602 603
static struct device_attribute devt_attr =
	__ATTR(dev, S_IRUGO, show_dev, NULL);

604
/* /sys/devices/ */
605
struct kset *devices_kset;
L
Linus Torvalds 已提交
606 607

/**
608 609 610
 * device_create_file - create sysfs attribute file for device.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
611
 */
612 613
int device_create_file(struct device *dev,
		       const struct device_attribute *attr)
L
Linus Torvalds 已提交
614 615
{
	int error = 0;
616 617 618

	if (dev) {
		WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
619 620
			"Attribute %s: write permission without 'store'\n",
			attr->attr.name);
621
		WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
622 623
			"Attribute %s: read permission without 'show'\n",
			attr->attr.name);
L
Linus Torvalds 已提交
624
		error = sysfs_create_file(&dev->kobj, &attr->attr);
625 626
	}

L
Linus Torvalds 已提交
627 628
	return error;
}
629
EXPORT_SYMBOL_GPL(device_create_file);
L
Linus Torvalds 已提交
630 631

/**
632 633 634
 * device_remove_file - remove sysfs attribute file.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
635
 */
636 637
void device_remove_file(struct device *dev,
			const struct device_attribute *attr)
L
Linus Torvalds 已提交
638
{
639
	if (dev)
L
Linus Torvalds 已提交
640 641
		sysfs_remove_file(&dev->kobj, &attr->attr);
}
642
EXPORT_SYMBOL_GPL(device_remove_file);
L
Linus Torvalds 已提交
643

644 645 646 647 648
/**
 * device_create_bin_file - create sysfs binary attribute file for device.
 * @dev: device.
 * @attr: device binary attribute descriptor.
 */
649 650
int device_create_bin_file(struct device *dev,
			   const struct bin_attribute *attr)
651 652 653 654 655 656 657 658 659 660 661 662 663
{
	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.
 */
664 665
void device_remove_bin_file(struct device *dev,
			    const struct bin_attribute *attr)
666 667 668 669 670 671
{
	if (dev)
		sysfs_remove_bin_file(&dev->kobj, attr);
}
EXPORT_SYMBOL_GPL(device_remove_bin_file);

672
/**
673
 * device_schedule_callback_owner - helper to schedule a callback for a device
674 675
 * @dev: device.
 * @func: callback function to invoke later.
676
 * @owner: module owning the callback routine
677 678 679 680 681 682 683 684 685 686
 *
 * Attribute methods must not unregister themselves or their parent device
 * (which would amount to the same thing).  Attempts to do so will deadlock,
 * since unregistration is mutually exclusive with driver callbacks.
 *
 * Instead methods can call this routine, which will attempt to allocate
 * and schedule a workqueue request to call back @func with @dev as its
 * argument in the workqueue's process context.  @dev will be pinned until
 * @func returns.
 *
687 688 689
 * This routine is usually called via the inline device_schedule_callback(),
 * which automatically sets @owner to THIS_MODULE.
 *
690
 * Returns 0 if the request was submitted, -ENOMEM if storage could not
691
 * be allocated, -ENODEV if a reference to @owner isn't available.
692 693 694 695 696
 *
 * NOTE: This routine won't work if CONFIG_SYSFS isn't set!  It uses an
 * underlying sysfs routine (since it is intended for use by attribute
 * methods), and if sysfs isn't available you'll get nothing but -ENOSYS.
 */
697 698
int device_schedule_callback_owner(struct device *dev,
		void (*func)(struct device *), struct module *owner)
699 700
{
	return sysfs_schedule_callback(&dev->kobj,
701
			(void (*)(void *)) func, dev, owner);
702
}
703
EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
704

705 706
static void klist_children_get(struct klist_node *n)
{
707 708
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
709 710 711 712 713 714

	get_device(dev);
}

static void klist_children_put(struct klist_node *n)
{
715 716
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
717 718 719 720

	put_device(dev);
}

L
Linus Torvalds 已提交
721
/**
722 723
 * device_initialize - init device structure.
 * @dev: device.
L
Linus Torvalds 已提交
724
 *
725 726
 * This prepares the device for use by other layers by initializing
 * its fields.
727
 * It is the first half of device_register(), if called by
728 729 730 731 732
 * 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.
 *
733 734 735 736 737
 * 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.
 *
738 739
 * NOTE: Use put_device() to give up your reference instead of freeing
 * @dev directly once you have called this function.
L
Linus Torvalds 已提交
740 741 742
 */
void device_initialize(struct device *dev)
{
743
	dev->kobj.kset = devices_kset;
744
	kobject_init(&dev->kobj, &device_ktype);
L
Linus Torvalds 已提交
745
	INIT_LIST_HEAD(&dev->dma_pools);
746
	mutex_init(&dev->mutex);
747
	lockdep_set_novalidate_class(&dev->mutex);
T
Tejun Heo 已提交
748 749
	spin_lock_init(&dev->devres_lock);
	INIT_LIST_HEAD(&dev->devres_head);
750
	device_pm_init(dev);
751
	set_dev_node(dev, -1);
L
Linus Torvalds 已提交
752
}
753
EXPORT_SYMBOL_GPL(device_initialize);
L
Linus Torvalds 已提交
754

755
struct kobject *virtual_device_parent(struct device *dev)
756
{
757
	static struct kobject *virtual_dir = NULL;
758

759
	if (!virtual_dir)
760
		virtual_dir = kobject_create_and_add("virtual",
761
						     &devices_kset->kobj);
762

763
	return virtual_dir;
764 765
}

766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
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)
781
{
782 783 784 785 786 787 788 789 790 791 792 793 794 795
	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;
796 797
	int retval;

798 799 800 801 802 803 804
	dir = kzalloc(sizeof(*dir), GFP_KERNEL);
	if (!dir)
		return NULL;

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

805
	dir->kobj.kset = &class->p->glue_dirs;
806 807 808 809 810 811 812 813 814 815 816 817 818

	retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
	if (retval < 0) {
		kobject_put(&dir->kobj);
		return NULL;
	}
	return &dir->kobj;
}


static struct kobject *get_device_parent(struct device *dev,
					 struct device *parent)
{
819
	if (dev->class) {
820
		static DEFINE_MUTEX(gdp_mutex);
821 822 823 824
		struct kobject *kobj = NULL;
		struct kobject *parent_kobj;
		struct kobject *k;

825
#ifdef CONFIG_BLOCK
826
		/* block disks show up in /sys/block */
827
		if (sysfs_deprecated && dev->class == &block_class) {
828 829
			if (parent && parent->class == &block_class)
				return &parent->kobj;
830
			return &block_class.p->subsys.kobj;
831
		}
832
#endif
833

834 835
		/*
		 * If we have no parent, we live in "virtual".
836 837
		 * Class-devices with a non class-device as parent, live
		 * in a "glue" directory to prevent namespace collisions.
838 839 840
		 */
		if (parent == NULL)
			parent_kobj = virtual_device_parent(dev);
841
		else if (parent->class && !dev->class->ns_type)
842 843 844 845
			return &parent->kobj;
		else
			parent_kobj = &parent->kobj;

846 847
		mutex_lock(&gdp_mutex);

848
		/* find our class-directory at the parent and reference it */
849 850
		spin_lock(&dev->class->p->glue_dirs.list_lock);
		list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
851 852 853 854
			if (k->parent == parent_kobj) {
				kobj = kobject_get(k);
				break;
			}
855
		spin_unlock(&dev->class->p->glue_dirs.list_lock);
856 857
		if (kobj) {
			mutex_unlock(&gdp_mutex);
858
			return kobj;
859
		}
860 861

		/* or create a new class-directory at the parent device */
862
		k = class_dir_create_and_add(dev->class, parent_kobj);
863
		/* do not emit an uevent for this simple "glue" directory */
864
		mutex_unlock(&gdp_mutex);
865
		return k;
866 867
	}

868 869 870 871
	/* subsystems can specify a default root directory for their devices */
	if (!parent && dev->bus && dev->bus->dev_root)
		return &dev->bus->dev_root->kobj;

872
	if (parent)
873 874 875
		return &parent->kobj;
	return NULL;
}
876

877
static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
878
{
879
	/* see if we live in a "glue" directory */
880
	if (!glue_dir || !dev->class ||
881
	    glue_dir->kset != &dev->class->p->glue_dirs)
882 883
		return;

884
	kobject_put(glue_dir);
885
}
886 887 888 889 890

static void cleanup_device_parent(struct device *dev)
{
	cleanup_glue_dir(dev, dev->kobj.parent);
}
891

892 893 894 895 896 897
static int device_add_class_symlinks(struct device *dev)
{
	int error;

	if (!dev->class)
		return 0;
898

899
	error = sysfs_create_link(&dev->kobj,
900
				  &dev->class->p->subsys.kobj,
901 902 903
				  "subsystem");
	if (error)
		goto out;
904

905
	if (dev->parent && device_is_not_partition(dev)) {
906
		error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
907 908
					  "device");
		if (error)
909
			goto out_subsys;
910 911
	}

912
#ifdef CONFIG_BLOCK
913
	/* /sys/block has directories and does not need symlinks */
914
	if (sysfs_deprecated && dev->class == &block_class)
915
		return 0;
916
#endif
917

918
	/* link in the class directory pointing to the device */
919
	error = sysfs_create_link(&dev->class->p->subsys.kobj,
920
				  &dev->kobj, dev_name(dev));
921
	if (error)
922
		goto out_device;
923 924 925

	return 0;

926 927
out_device:
	sysfs_remove_link(&dev->kobj, "device");
928

929 930 931 932 933 934 935 936 937 938
out_subsys:
	sysfs_remove_link(&dev->kobj, "subsystem");
out:
	return error;
}

static void device_remove_class_symlinks(struct device *dev)
{
	if (!dev->class)
		return;
939

940
	if (dev->parent && device_is_not_partition(dev))
941
		sysfs_remove_link(&dev->kobj, "device");
942
	sysfs_remove_link(&dev->kobj, "subsystem");
943
#ifdef CONFIG_BLOCK
944
	if (sysfs_deprecated && dev->class == &block_class)
945
		return;
946
#endif
947
	sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
948 949
}

950 951 952
/**
 * dev_set_name - set a device name
 * @dev: device
953
 * @fmt: format string for the device's name
954 955 956 957
 */
int dev_set_name(struct device *dev, const char *fmt, ...)
{
	va_list vargs;
958
	int err;
959 960

	va_start(vargs, fmt);
961
	err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
962
	va_end(vargs);
963
	return err;
964 965 966
}
EXPORT_SYMBOL_GPL(dev_set_name);

967 968 969 970 971 972 973 974
/**
 * 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 已提交
975 976
 * device_remove_sys_dev_entry() will disagree about the presence of
 * the link.
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
 */
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);
	}
}

1015 1016 1017 1018 1019 1020 1021 1022
int device_private_init(struct device *dev)
{
	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);
1023
	INIT_LIST_HEAD(&dev->p->deferred_probe);
1024 1025 1026
	return 0;
}

L
Linus Torvalds 已提交
1027
/**
1028 1029
 * device_add - add device to device hierarchy.
 * @dev: device.
L
Linus Torvalds 已提交
1030
 *
1031 1032
 * This is part 2 of device_register(), though may be called
 * separately _iff_ device_initialize() has been called separately.
L
Linus Torvalds 已提交
1033
 *
1034
 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
1035 1036
 * to the global and sibling lists for the device, then
 * adds it to the other relevant subsystems of the driver model.
1037
 *
1038 1039 1040 1041 1042 1043 1044
 * 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.
 *
1045 1046 1047
 * 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 已提交
1048 1049 1050 1051
 */
int device_add(struct device *dev)
{
	struct device *parent = NULL;
1052
	struct kobject *kobj;
1053
	struct class_interface *class_intf;
1054
	int error = -EINVAL;
1055

L
Linus Torvalds 已提交
1056
	dev = get_device(dev);
1057 1058 1059
	if (!dev)
		goto done;

1060
	if (!dev->p) {
1061 1062 1063
		error = device_private_init(dev);
		if (error)
			goto done;
1064 1065
	}

1066 1067 1068 1069 1070 1071
	/*
	 * 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) {
1072
		dev_set_name(dev, "%s", dev->init_name);
1073 1074
		dev->init_name = NULL;
	}
1075

1076 1077 1078 1079
	/* 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);

1080 1081
	if (!dev_name(dev)) {
		error = -EINVAL;
1082
		goto name_error;
1083
	}
L
Linus Torvalds 已提交
1084

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

L
Linus Torvalds 已提交
1087
	parent = get_device(dev->parent);
1088 1089 1090
	kobj = get_device_parent(dev, parent);
	if (kobj)
		dev->kobj.parent = kobj;
L
Linus Torvalds 已提交
1091

1092 1093 1094 1095
	/* use parent numa_node */
	if (parent)
		set_dev_node(dev, dev_to_node(parent));

L
Linus Torvalds 已提交
1096
	/* first, register with generic layer. */
1097 1098
	/* we require the name to be set before, and pass NULL */
	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
1099
	if (error)
L
Linus Torvalds 已提交
1100
		goto Error;
1101

1102 1103 1104 1105
	/* notify platform of device entry */
	if (platform_notify)
		platform_notify(dev);

1106
	error = device_create_file(dev, &uevent_attr);
1107 1108
	if (error)
		goto attrError;
1109

1110
	if (MAJOR(dev->devt)) {
1111 1112
		error = device_create_file(dev, &devt_attr);
		if (error)
1113
			goto ueventattrError;
1114 1115 1116 1117

		error = device_create_sys_dev_entry(dev);
		if (error)
			goto devtattrError;
1118 1119

		devtmpfs_create_node(dev);
1120 1121
	}

1122 1123 1124
	error = device_add_class_symlinks(dev);
	if (error)
		goto SymlinkError;
1125 1126
	error = device_add_attrs(dev);
	if (error)
1127
		goto AttrsError;
1128 1129
	error = bus_add_device(dev);
	if (error)
L
Linus Torvalds 已提交
1130
		goto BusError;
1131
	error = dpm_sysfs_add(dev);
1132
	if (error)
1133 1134
		goto DPMError;
	device_pm_add(dev);
1135 1136

	/* Notify clients of device addition.  This call must come
1137
	 * after dpm_sysfs_add() and before kobject_uevent().
1138 1139 1140 1141 1142
	 */
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_ADD_DEVICE, dev);

1143
	kobject_uevent(&dev->kobj, KOBJ_ADD);
1144
	bus_probe_device(dev);
L
Linus Torvalds 已提交
1145
	if (parent)
1146 1147
		klist_add_tail(&dev->p->knode_parent,
			       &parent->p->klist_children);
L
Linus Torvalds 已提交
1148

1149
	if (dev->class) {
1150
		mutex_lock(&dev->class->p->mutex);
1151
		/* tie the class to the device */
1152
		klist_add_tail(&dev->knode_class,
1153
			       &dev->class->p->klist_devices);
1154 1155

		/* notify any interfaces that the device is here */
1156
		list_for_each_entry(class_intf,
1157
				    &dev->class->p->interfaces, node)
1158 1159
			if (class_intf->add_dev)
				class_intf->add_dev(dev, class_intf);
1160
		mutex_unlock(&dev->class->p->mutex);
1161
	}
1162
done:
L
Linus Torvalds 已提交
1163 1164
	put_device(dev);
	return error;
1165
 DPMError:
1166 1167
	bus_remove_device(dev);
 BusError:
1168
	device_remove_attrs(dev);
1169
 AttrsError:
1170 1171
	device_remove_class_symlinks(dev);
 SymlinkError:
1172 1173
	if (MAJOR(dev->devt))
		devtmpfs_delete_node(dev);
1174 1175 1176
	if (MAJOR(dev->devt))
		device_remove_sys_dev_entry(dev);
 devtattrError:
1177 1178
	if (MAJOR(dev->devt))
		device_remove_file(dev, &devt_attr);
1179
 ueventattrError:
1180
	device_remove_file(dev, &uevent_attr);
1181
 attrError:
1182
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
L
Linus Torvalds 已提交
1183 1184
	kobject_del(&dev->kobj);
 Error:
1185
	cleanup_device_parent(dev);
L
Linus Torvalds 已提交
1186 1187
	if (parent)
		put_device(parent);
1188 1189 1190
name_error:
	kfree(dev->p);
	dev->p = NULL;
1191
	goto done;
L
Linus Torvalds 已提交
1192
}
1193
EXPORT_SYMBOL_GPL(device_add);
L
Linus Torvalds 已提交
1194 1195

/**
1196 1197
 * device_register - register a device with the system.
 * @dev: pointer to the device structure
L
Linus Torvalds 已提交
1198
 *
1199 1200 1201 1202 1203 1204
 * 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.
1205
 *
1206 1207 1208
 * For more information, see the kerneldoc for device_initialize()
 * and device_add().
 *
1209 1210 1211
 * 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 已提交
1212 1213 1214 1215 1216 1217
 */
int device_register(struct device *dev)
{
	device_initialize(dev);
	return device_add(dev);
}
1218
EXPORT_SYMBOL_GPL(device_register);
L
Linus Torvalds 已提交
1219 1220

/**
1221 1222
 * get_device - increment reference count for device.
 * @dev: device.
L
Linus Torvalds 已提交
1223
 *
1224 1225 1226
 * 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 已提交
1227
 */
1228
struct device *get_device(struct device *dev)
L
Linus Torvalds 已提交
1229
{
1230
	return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
L
Linus Torvalds 已提交
1231
}
1232
EXPORT_SYMBOL_GPL(get_device);
L
Linus Torvalds 已提交
1233 1234

/**
1235 1236
 * put_device - decrement reference count.
 * @dev: device in question.
L
Linus Torvalds 已提交
1237
 */
1238
void put_device(struct device *dev)
L
Linus Torvalds 已提交
1239
{
1240
	/* might_sleep(); */
L
Linus Torvalds 已提交
1241 1242 1243
	if (dev)
		kobject_put(&dev->kobj);
}
1244
EXPORT_SYMBOL_GPL(put_device);
L
Linus Torvalds 已提交
1245 1246

/**
1247 1248
 * device_del - delete device from system.
 * @dev: device.
L
Linus Torvalds 已提交
1249
 *
1250 1251 1252 1253 1254
 * 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 已提交
1255
 *
1256 1257
 * NOTE: this should be called manually _iff_ device_add() was
 * also called manually.
L
Linus Torvalds 已提交
1258
 */
1259
void device_del(struct device *dev)
L
Linus Torvalds 已提交
1260
{
1261
	struct device *parent = dev->parent;
1262
	struct class_interface *class_intf;
L
Linus Torvalds 已提交
1263

1264 1265 1266 1267 1268 1269
	/* 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);
1270
	dpm_sysfs_remove(dev);
L
Linus Torvalds 已提交
1271
	if (parent)
1272
		klist_del(&dev->p->knode_parent);
1273
	if (MAJOR(dev->devt)) {
1274
		devtmpfs_delete_node(dev);
1275
		device_remove_sys_dev_entry(dev);
1276
		device_remove_file(dev, &devt_attr);
1277
	}
1278
	if (dev->class) {
1279
		device_remove_class_symlinks(dev);
1280

1281
		mutex_lock(&dev->class->p->mutex);
1282
		/* notify any interfaces that the device is now gone */
1283
		list_for_each_entry(class_intf,
1284
				    &dev->class->p->interfaces, node)
1285 1286 1287
			if (class_intf->remove_dev)
				class_intf->remove_dev(dev, class_intf);
		/* remove the device from the class list */
1288
		klist_del(&dev->knode_class);
1289
		mutex_unlock(&dev->class->p->mutex);
1290
	}
1291
	device_remove_file(dev, &uevent_attr);
1292
	device_remove_attrs(dev);
1293
	bus_remove_device(dev);
1294
	device_pm_remove(dev);
1295
	driver_deferred_probe_del(dev);
L
Linus Torvalds 已提交
1296 1297 1298 1299 1300 1301

	/* Notify the platform of the removal, in case they
	 * need to do anything...
	 */
	if (platform_notify_remove)
		platform_notify_remove(dev);
1302
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1303
	cleanup_device_parent(dev);
L
Linus Torvalds 已提交
1304
	kobject_del(&dev->kobj);
1305
	put_device(parent);
L
Linus Torvalds 已提交
1306
}
1307
EXPORT_SYMBOL_GPL(device_del);
L
Linus Torvalds 已提交
1308 1309

/**
1310 1311
 * device_unregister - unregister device from system.
 * @dev: device going away.
L
Linus Torvalds 已提交
1312
 *
1313 1314 1315 1316 1317 1318
 * 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 已提交
1319
 */
1320
void device_unregister(struct device *dev)
L
Linus Torvalds 已提交
1321
{
1322
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
L
Linus Torvalds 已提交
1323 1324 1325
	device_del(dev);
	put_device(dev);
}
1326
EXPORT_SYMBOL_GPL(device_unregister);
L
Linus Torvalds 已提交
1327

1328
static struct device *next_device(struct klist_iter *i)
1329
{
1330
	struct klist_node *n = klist_next(i);
1331 1332 1333 1334 1335 1336 1337 1338
	struct device *dev = NULL;
	struct device_private *p;

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

1341
/**
1342
 * device_get_devnode - path of device node file
1343
 * @dev: device
1344
 * @mode: returned file access mode
1345 1346
 * @uid: returned file owner
 * @gid: returned file group
1347 1348 1349 1350 1351 1352 1353
 * @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.
 */
1354
const char *device_get_devnode(struct device *dev,
1355
			       umode_t *mode, kuid_t *uid, kgid_t *gid,
1356
			       const char **tmp)
1357 1358 1359 1360 1361 1362
{
	char *s;

	*tmp = NULL;

	/* the device type may provide a specific name */
1363
	if (dev->type && dev->type->devnode)
1364
		*tmp = dev->type->devnode(dev, mode, uid, gid);
1365 1366 1367 1368
	if (*tmp)
		return *tmp;

	/* the class may provide a specific name */
1369 1370
	if (dev->class && dev->class->devnode)
		*tmp = dev->class->devnode(dev, mode);
1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
	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 '/' */
	*tmp = kstrdup(dev_name(dev), GFP_KERNEL);
	if (!*tmp)
		return NULL;
	while ((s = strchr(*tmp, '!')))
		s[0] = '/';
	return *tmp;
}

L
Linus Torvalds 已提交
1387
/**
1388 1389 1390
 * device_for_each_child - device child iterator.
 * @parent: parent struct device.
 * @fn: function to be called for each device.
1391
 * @data: data for the callback.
L
Linus Torvalds 已提交
1392
 *
1393 1394
 * Iterate over @parent's child devices, and call @fn for each,
 * passing it @data.
L
Linus Torvalds 已提交
1395
 *
1396 1397
 * 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 已提交
1398
 */
1399 1400
int device_for_each_child(struct device *parent, void *data,
			  int (*fn)(struct device *dev, void *data))
L
Linus Torvalds 已提交
1401
{
1402
	struct klist_iter i;
1403
	struct device *child;
L
Linus Torvalds 已提交
1404 1405
	int error = 0;

1406 1407 1408
	if (!parent->p)
		return 0;

1409
	klist_iter_init(&parent->p->klist_children, &i);
1410 1411 1412
	while ((child = next_device(&i)) && !error)
		error = fn(child, data);
	klist_iter_exit(&i);
L
Linus Torvalds 已提交
1413 1414
	return error;
}
1415
EXPORT_SYMBOL_GPL(device_for_each_child);
L
Linus Torvalds 已提交
1416

1417 1418 1419 1420
/**
 * device_find_child - device iterator for locating a particular device.
 * @parent: parent struct device
 * @match: Callback function to check device
1421
 * @data: Data to pass to match function
1422 1423 1424 1425 1426 1427 1428 1429 1430
 *
 * 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.
1431 1432
 *
 * NOTE: you will need to drop the reference with put_device() after use.
1433
 */
1434 1435
struct device *device_find_child(struct device *parent, void *data,
				 int (*match)(struct device *dev, void *data))
1436 1437 1438 1439 1440 1441 1442
{
	struct klist_iter i;
	struct device *child;

	if (!parent)
		return NULL;

1443
	klist_iter_init(&parent->p->klist_children, &i);
1444 1445 1446 1447 1448 1449
	while ((child = next_device(&i)))
		if (match(child, data) && get_device(child))
			break;
	klist_iter_exit(&i);
	return child;
}
1450
EXPORT_SYMBOL_GPL(device_find_child);
1451

L
Linus Torvalds 已提交
1452 1453
int __init devices_init(void)
{
1454 1455 1456
	devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
	if (!devices_kset)
		return -ENOMEM;
1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
	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;

1467
	return 0;
1468 1469 1470 1471 1472 1473 1474 1475

 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 已提交
1476 1477
}

1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
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);
}

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

1571
struct root_device {
1572 1573 1574 1575
	struct device dev;
	struct module *owner;
};

1576
static inline struct root_device *to_root_device(struct device *d)
1577 1578 1579
{
	return container_of(d, struct root_device, dev);
}
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603

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.
 *
1604 1605
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
 * 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);

1617
	err = dev_set_name(&root->dev, "%s", name);
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
	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);
	}

1631
#ifdef CONFIG_MODULES	/* gotta find a "cleaner" way to do this */
1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649
	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
1650
 * @dev: device going away
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665
 *
 * 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);

1666 1667 1668

static void device_create_release(struct device *dev)
{
1669
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1670 1671 1672
	kfree(dev);
}

1673 1674 1675 1676 1677
static struct device *
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)
1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693
{
	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;
	}

	dev->devt = devt;
	dev->class = class;
	dev->parent = parent;
1694
	dev->groups = groups;
1695
	dev->release = device_create_release;
1696
	dev_set_drvdata(dev, drvdata);
1697

1698 1699 1700 1701
	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
	if (retval)
		goto error;

1702 1703 1704 1705 1706 1707 1708
	retval = device_register(dev);
	if (retval)
		goto error;

	return dev;

error:
1709
	put_device(dev);
1710 1711
	return ERR_PTR(retval);
}
1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744

/**
 * 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);
}
1745 1746 1747
EXPORT_SYMBOL_GPL(device_create_vargs);

/**
1748
 * device_create - creates a device and registers it with sysfs
1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765
 * @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.
 *
1766 1767
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
1768 1769 1770
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
1771 1772
struct device *device_create(struct class *class, struct device *parent,
			     dev_t devt, void *drvdata, const char *fmt, ...)
1773 1774 1775 1776 1777 1778 1779 1780 1781
{
	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;
}
1782
EXPORT_SYMBOL_GPL(device_create);
1783

1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827
/**
 * 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);

1828
static int __match_devt(struct device *dev, const void *data)
1829
{
1830
	const dev_t *devt = data;
1831

1832
	return dev->devt == *devt;
1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
}

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

1847
	dev = class_find_device(class, NULL, &devt, __match_devt);
1848 1849
	if (dev) {
		put_device(dev);
1850
		device_unregister(dev);
1851
	}
1852 1853
}
EXPORT_SYMBOL_GPL(device_destroy);
1854 1855 1856 1857 1858

/**
 * device_rename - renames a device
 * @dev: the pointer to the struct device to be renamed
 * @new_name: the new name of the device
1859 1860 1861 1862 1863
 *
 * 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.
1864
 *
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892
 * 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. :)
1893
 */
1894
int device_rename(struct device *dev, const char *new_name)
1895
{
1896
	char *old_device_name = NULL;
1897 1898 1899 1900 1901 1902
	int error;

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

1903
	pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
1904
		 __func__, new_name);
1905

1906
	old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1907 1908 1909
	if (!old_device_name) {
		error = -ENOMEM;
		goto out;
1910 1911
	}

1912
	if (dev->class) {
1913
		error = sysfs_rename_link(&dev->class->p->subsys.kobj,
1914 1915 1916 1917
			&dev->kobj, old_device_name, new_name);
		if (error)
			goto out;
	}
1918

1919
	error = kobject_rename(&dev->kobj, new_name);
1920
	if (error)
1921
		goto out;
1922

1923
out:
1924 1925
	put_device(dev);

1926
	kfree(old_device_name);
1927 1928 1929

	return error;
}
1930
EXPORT_SYMBOL_GPL(device_rename);
1931 1932 1933 1934 1935

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

1938 1939 1940 1941 1942 1943
	if (old_parent)
		sysfs_remove_link(&dev->kobj, "device");
	if (new_parent)
		error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
					  "device");
	return error;
1944 1945 1946 1947 1948
}

/**
 * device_move - moves a device to a new parent
 * @dev: the pointer to the struct device to be moved
1949
 * @new_parent: the new parent of the device (can by NULL)
1950
 * @dpm_order: how to reorder the dpm_list
1951
 */
1952 1953
int device_move(struct device *dev, struct device *new_parent,
		enum dpm_order dpm_order)
1954 1955 1956
{
	int error;
	struct device *old_parent;
1957
	struct kobject *new_parent_kobj;
1958 1959 1960 1961 1962

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

1963
	device_pm_lock();
1964
	new_parent = get_device(new_parent);
1965
	new_parent_kobj = get_device_parent(dev, new_parent);
1966

1967 1968
	pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
		 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1969
	error = kobject_move(&dev->kobj, new_parent_kobj);
1970
	if (error) {
1971
		cleanup_glue_dir(dev, new_parent_kobj);
1972 1973 1974 1975 1976 1977
		put_device(new_parent);
		goto out;
	}
	old_parent = dev->parent;
	dev->parent = new_parent;
	if (old_parent)
1978
		klist_remove(&dev->p->knode_parent);
1979
	if (new_parent) {
1980 1981
		klist_add_tail(&dev->p->knode_parent,
			       &new_parent->p->klist_children);
1982 1983 1984
		set_dev_node(dev, dev_to_node(new_parent));
	}

1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
	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));
				}
1999
			}
2000 2001 2002
			cleanup_glue_dir(dev, new_parent_kobj);
			put_device(new_parent);
			goto out;
2003 2004
		}
	}
2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017
	switch (dpm_order) {
	case DPM_ORDER_NONE:
		break;
	case DPM_ORDER_DEV_AFTER_PARENT:
		device_pm_move_after(dev, new_parent);
		break;
	case DPM_ORDER_PARENT_BEFORE_DEV:
		device_pm_move_before(new_parent, dev);
		break;
	case DPM_ORDER_DEV_LAST:
		device_pm_move_last(dev);
		break;
	}
2018

2019 2020
	put_device(old_parent);
out:
2021
	device_pm_unlock();
2022 2023 2024 2025
	put_device(dev);
	return error;
}
EXPORT_SYMBOL_GPL(device_move);
2026 2027 2028 2029 2030 2031

/**
 * device_shutdown - call ->shutdown() on each device to shutdown.
 */
void device_shutdown(void)
{
2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042
	struct device *dev;

	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);
2043 2044 2045 2046 2047 2048 2049

		/*
		 * hold reference count of device's parent to
		 * prevent it from being freed because parent's
		 * lock is to be held
		 */
		get_device(dev->parent);
2050 2051 2052 2053 2054 2055 2056
		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);
2057

2058 2059 2060 2061 2062
		/* hold lock to avoid race with probe/release */
		if (dev->parent)
			device_lock(dev->parent);
		device_lock(dev);

2063 2064 2065
		/* Don't allow any more runtime suspends */
		pm_runtime_get_noresume(dev);
		pm_runtime_barrier(dev);
2066 2067

		if (dev->bus && dev->bus->shutdown) {
2068 2069
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
2070 2071
			dev->bus->shutdown(dev);
		} else if (dev->driver && dev->driver->shutdown) {
2072 2073
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
2074 2075
			dev->driver->shutdown(dev);
		}
2076 2077 2078 2079 2080

		device_unlock(dev);
		if (dev->parent)
			device_unlock(dev->parent);

2081
		put_device(dev);
2082
		put_device(dev->parent);
2083 2084

		spin_lock(&devices_kset->list_lock);
2085
	}
2086
	spin_unlock(&devices_kset->list_lock);
2087
	async_synchronize_full();
2088
}
2089 2090 2091 2092 2093 2094

/*
 * Device logging functions
 */

#ifdef CONFIG_PRINTK
2095 2096
static int
create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
2097
{
2098
	const char *subsys;
2099
	size_t pos = 0;
2100

2101 2102 2103 2104 2105
	if (dev->class)
		subsys = dev->class->name;
	else if (dev->bus)
		subsys = dev->bus->name;
	else
2106
		return 0;
2107

2108
	pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123

	/*
	 * 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';
2124 2125 2126 2127
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=%c%u:%u",
				c, MAJOR(dev->devt), MINOR(dev->devt));
2128 2129 2130
	} else if (strcmp(subsys, "net") == 0) {
		struct net_device *net = to_net_dev(dev);

2131 2132 2133
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=n%u", net->ifindex);
2134
	} else {
2135 2136 2137
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=+%s:%s", subsys, dev_name(dev));
2138
	}
2139

2140 2141 2142 2143
	return pos;
}
EXPORT_SYMBOL(create_syslog_header);

2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170
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);

2171 2172 2173 2174 2175 2176
static int __dev_printk(const char *level, const struct device *dev,
			struct va_format *vaf)
{
	if (!dev)
		return printk("%s(NULL device *): %pV", level, vaf);

2177 2178 2179
	return dev_printk_emit(level[1] - '0', dev,
			       "%s %s: %pV",
			       dev_driver_string(dev), dev_name(dev), vaf);
2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194
}

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

	va_start(args, fmt);

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

	r = __dev_printk(level, dev, &vaf);
2195

2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214
	va_end(args);

	return r;
}
EXPORT_SYMBOL(dev_printk);

#define define_dev_printk_level(func, kern_level)		\
int func(const struct device *dev, const char *fmt, ...)	\
{								\
	struct va_format vaf;					\
	va_list args;						\
	int r;							\
								\
	va_start(args, fmt);					\
								\
	vaf.fmt = fmt;						\
	vaf.va = &args;						\
								\
	r = __dev_printk(kern_level, dev, &vaf);		\
2215
								\
2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230
	va_end(args);						\
								\
	return r;						\
}								\
EXPORT_SYMBOL(func);

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);
define_dev_printk_level(_dev_info, KERN_INFO);

#endif