core.c 54.2 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/pm_runtime.h>
27
#include <linux/netdevice.h>
28
#include <linux/sysfs.h>
L
Linus Torvalds 已提交
29 30 31 32

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

33 34 35 36 37 38
#ifdef CONFIG_SYSFS_DEPRECATED
#ifdef CONFIG_SYSFS_DEPRECATED_V2
long sysfs_deprecated = 1;
#else
long sysfs_deprecated = 0;
#endif
39
static int __init sysfs_deprecated_setup(char *arg)
40
{
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 63 64 65 66 67 68 69 70 71 72 73
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();
}

74 75 76 77 78 79 80 81 82 83 84
#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 已提交
85

86 87 88 89 90
/**
 * 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 已提交
91
 * the device is not bound to a driver, it will return the name of the bus
92 93 94
 * it is attached to.  If it is not attached to a bus either, an empty
 * string will be returned.
 */
95
const char *dev_driver_string(const struct device *dev)
96
{
97 98 99 100 101 102 103 104
	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 :
105 106
			(dev->bus ? dev->bus->name :
			(dev->class ? dev->class->name : ""));
107
}
M
Matthew Wilcox 已提交
108
EXPORT_SYMBOL(dev_driver_string);
109

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

112 113
static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
			     char *buf)
L
Linus Torvalds 已提交
114
{
115
	struct device_attribute *dev_attr = to_dev_attr(attr);
116
	struct device *dev = kobj_to_dev(kobj);
117
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
118 119

	if (dev_attr->show)
120
		ret = dev_attr->show(dev, dev_attr, buf);
121
	if (ret >= (ssize_t)PAGE_SIZE) {
122 123
		print_symbol("dev_attr_show: %s returned bad count\n",
				(unsigned long)dev_attr->show);
124
	}
L
Linus Torvalds 已提交
125 126 127
	return ret;
}

128 129
static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
			      const char *buf, size_t count)
L
Linus Torvalds 已提交
130
{
131
	struct device_attribute *dev_attr = to_dev_attr(attr);
132
	struct device *dev = kobj_to_dev(kobj);
133
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
134 135

	if (dev_attr->store)
136
		ret = dev_attr->store(dev, dev_attr, buf, count);
L
Linus Torvalds 已提交
137 138 139
	return ret;
}

140
static const struct sysfs_ops dev_sysfs_ops = {
L
Linus Torvalds 已提交
141 142 143 144
	.show	= dev_attr_show,
	.store	= dev_attr_store,
};

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 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
#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 已提交
195

196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
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 已提交
217
/**
218 219
 * device_release - free device structure.
 * @kobj: device's kobject.
L
Linus Torvalds 已提交
220
 *
221 222 223
 * 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 已提交
224
 */
225
static void device_release(struct kobject *kobj)
L
Linus Torvalds 已提交
226
{
227
	struct device *dev = kobj_to_dev(kobj);
228
	struct device_private *p = dev->p;
L
Linus Torvalds 已提交
229

230 231 232 233 234 235 236 237 238 239 240
	/*
	 * 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 已提交
241 242
	if (dev->release)
		dev->release(dev);
243 244
	else if (dev->type && dev->type->release)
		dev->type->release(dev);
245 246
	else if (dev->class && dev->class->dev_release)
		dev->class->dev_release(dev);
A
Arjan van de Ven 已提交
247 248
	else
		WARN(1, KERN_ERR "Device '%s' does not have a release() "
249
			"function, it is broken and must be fixed.\n",
250
			dev_name(dev));
251
	kfree(p);
L
Linus Torvalds 已提交
252 253
}

254 255
static const void *device_namespace(struct kobject *kobj)
{
256
	struct device *dev = kobj_to_dev(kobj);
257 258 259 260 261 262 263 264
	const void *ns = NULL;

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

	return ns;
}

265
static struct kobj_type device_ktype = {
L
Linus Torvalds 已提交
266 267
	.release	= device_release,
	.sysfs_ops	= &dev_sysfs_ops,
268
	.namespace	= device_namespace,
L
Linus Torvalds 已提交
269 270 271
};


272
static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
273 274 275
{
	struct kobj_type *ktype = get_ktype(kobj);

276
	if (ktype == &device_ktype) {
277
		struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
278 279
		if (dev->bus)
			return 1;
280 281
		if (dev->class)
			return 1;
L
Linus Torvalds 已提交
282 283 284 285
	}
	return 0;
}

286
static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
287
{
288
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
289

290 291 292 293 294
	if (dev->bus)
		return dev->bus->name;
	if (dev->class)
		return dev->class->name;
	return NULL;
L
Linus Torvalds 已提交
295 296
}

297 298
static int dev_uevent(struct kset *kset, struct kobject *kobj,
		      struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
299
{
300
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
301 302
	int retval = 0;

303
	/* add device node properties if present */
304
	if (MAJOR(dev->devt)) {
305 306
		const char *tmp;
		const char *name;
307
		umode_t mode = 0;
308 309
		kuid_t uid = GLOBAL_ROOT_UID;
		kgid_t gid = GLOBAL_ROOT_GID;
310

311 312
		add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
		add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
313
		name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
314 315
		if (name) {
			add_uevent_var(env, "DEVNAME=%s", name);
316 317
			if (mode)
				add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
318 319 320 321
			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));
322
			kfree(tmp);
323
		}
324 325
	}

326
	if (dev->type && dev->type->name)
327
		add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
328

329
	if (dev->driver)
330
		add_uevent_var(env, "DRIVER=%s", dev->driver->name);
331

332 333 334
	/* Add common DT information about the device */
	of_device_uevent(dev, env);

335
	/* have the bus specific function add its stuff */
336
	if (dev->bus && dev->bus->uevent) {
337
		retval = dev->bus->uevent(dev, env);
338
		if (retval)
339
			pr_debug("device: '%s': %s: bus uevent() returned %d\n",
340
				 dev_name(dev), __func__, retval);
L
Linus Torvalds 已提交
341 342
	}

343
	/* have the class specific function add its stuff */
344
	if (dev->class && dev->class->dev_uevent) {
345
		retval = dev->class->dev_uevent(dev, env);
346
		if (retval)
347
			pr_debug("device: '%s': %s: class uevent() "
348
				 "returned %d\n", dev_name(dev),
349
				 __func__, retval);
350 351
	}

352
	/* have the device type specific function add its stuff */
353
	if (dev->type && dev->type->uevent) {
354
		retval = dev->type->uevent(dev, env);
355
		if (retval)
356
			pr_debug("device: '%s': %s: dev_type uevent() "
357
				 "returned %d\n", dev_name(dev),
358
				 __func__, retval);
359 360
	}

L
Linus Torvalds 已提交
361 362 363
	return retval;
}

364
static const struct kset_uevent_ops device_uevent_ops = {
365 366 367
	.filter =	dev_uevent_filter,
	.name =		dev_uevent_name,
	.uevent =	dev_uevent,
L
Linus Torvalds 已提交
368 369
};

370
static ssize_t uevent_show(struct device *dev, struct device_attribute *attr,
371 372 373 374
			   char *buf)
{
	struct kobject *top_kobj;
	struct kset *kset;
375
	struct kobj_uevent_env *env = NULL;
376 377 378 379 380 381
	int i;
	size_t count = 0;
	int retval;

	/* search the kset, the device belongs to */
	top_kobj = &dev->kobj;
382 383
	while (!top_kobj->kset && top_kobj->parent)
		top_kobj = top_kobj->parent;
384 385
	if (!top_kobj->kset)
		goto out;
386

387 388 389 390 391 392 393 394 395
	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;

396 397
	env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
	if (!env)
398 399
		return -ENOMEM;

400
	/* let the kset specific function add its keys */
401
	retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
402 403 404 405
	if (retval)
		goto out;

	/* copy keys to file */
406 407
	for (i = 0; i < env->envp_idx; i++)
		count += sprintf(&buf[count], "%s\n", env->envp[i]);
408
out:
409
	kfree(env);
410 411 412
	return count;
}

413
static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,
414 415
			    const char *buf, size_t count)
{
416 417
	enum kobject_action action;

418
	if (kobject_action_type(buf, count, &action) == 0)
419
		kobject_uevent(&dev->kobj, action);
420 421
	else
		dev_err(dev, "uevent: unknown action-string\n");
422 423
	return count;
}
424
static DEVICE_ATTR_RW(uevent);
425

426
static ssize_t online_show(struct device *dev, struct device_attribute *attr,
427 428 429 430
			   char *buf)
{
	bool val;

431
	device_lock(dev);
432
	val = !dev->offline;
433
	device_unlock(dev);
434 435 436
	return sprintf(buf, "%u\n", val);
}

437
static ssize_t online_store(struct device *dev, struct device_attribute *attr,
438 439 440 441 442 443 444 445 446
			    const char *buf, size_t count)
{
	bool val;
	int ret;

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

447 448 449 450
	ret = lock_device_hotplug_sysfs();
	if (ret)
		return ret;

451 452 453 454
	ret = val ? device_online(dev) : device_offline(dev);
	unlock_device_hotplug();
	return ret < 0 ? ret : count;
}
455
static DEVICE_ATTR_RW(online);
456

457
int device_add_groups(struct device *dev, const struct attribute_group **groups)
458
{
459
	return sysfs_create_groups(&dev->kobj, groups);
460 461
}

462 463
void device_remove_groups(struct device *dev,
			  const struct attribute_group **groups)
464
{
465
	sysfs_remove_groups(&dev->kobj, groups);
466 467
}

468 469 470
static int device_add_attrs(struct device *dev)
{
	struct class *class = dev->class;
471
	const struct device_type *type = dev->type;
472
	int error;
473

474
	if (class) {
475
		error = device_add_groups(dev, class->dev_groups);
476
		if (error)
477
			return error;
478
	}
479

480 481
	if (type) {
		error = device_add_groups(dev, type->groups);
482
		if (error)
483
			goto err_remove_class_groups;
484 485
	}

486 487 488 489
	error = device_add_groups(dev, dev->groups);
	if (error)
		goto err_remove_type_groups;

490
	if (device_supports_offline(dev) && !dev->offline_disabled) {
491
		error = device_create_file(dev, &dev_attr_online);
492
		if (error)
493
			goto err_remove_dev_groups;
494 495
	}

496 497
	return 0;

498 499
 err_remove_dev_groups:
	device_remove_groups(dev, dev->groups);
500 501 502
 err_remove_type_groups:
	if (type)
		device_remove_groups(dev, type->groups);
503 504 505
 err_remove_class_groups:
	if (class)
		device_remove_groups(dev, class->dev_groups);
506

507 508 509 510 511 512
	return error;
}

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

515
	device_remove_file(dev, &dev_attr_online);
516
	device_remove_groups(dev, dev->groups);
517

518 519 520
	if (type)
		device_remove_groups(dev, type->groups);

521
	if (class)
522
		device_remove_groups(dev, class->dev_groups);
523 524
}

525
static ssize_t dev_show(struct device *dev, struct device_attribute *attr,
526 527 528 529
			char *buf)
{
	return print_dev_t(buf, dev->devt);
}
530
static DEVICE_ATTR_RO(dev);
531

532
/* /sys/devices/ */
533
struct kset *devices_kset;
L
Linus Torvalds 已提交
534 535

/**
536 537 538
 * device_create_file - create sysfs attribute file for device.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
539
 */
540 541
int device_create_file(struct device *dev,
		       const struct device_attribute *attr)
L
Linus Torvalds 已提交
542 543
{
	int error = 0;
544 545 546

	if (dev) {
		WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
547 548
			"Attribute %s: write permission without 'store'\n",
			attr->attr.name);
549
		WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
550 551
			"Attribute %s: read permission without 'show'\n",
			attr->attr.name);
L
Linus Torvalds 已提交
552
		error = sysfs_create_file(&dev->kobj, &attr->attr);
553 554
	}

L
Linus Torvalds 已提交
555 556
	return error;
}
557
EXPORT_SYMBOL_GPL(device_create_file);
L
Linus Torvalds 已提交
558 559

/**
560 561 562
 * device_remove_file - remove sysfs attribute file.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
563
 */
564 565
void device_remove_file(struct device *dev,
			const struct device_attribute *attr)
L
Linus Torvalds 已提交
566
{
567
	if (dev)
L
Linus Torvalds 已提交
568 569
		sysfs_remove_file(&dev->kobj, &attr->attr);
}
570
EXPORT_SYMBOL_GPL(device_remove_file);
L
Linus Torvalds 已提交
571

572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
/**
 * 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);

589 590 591 592 593
/**
 * device_create_bin_file - create sysfs binary attribute file for device.
 * @dev: device.
 * @attr: device binary attribute descriptor.
 */
594 595
int device_create_bin_file(struct device *dev,
			   const struct bin_attribute *attr)
596 597 598 599 600 601 602 603 604 605 606 607 608
{
	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.
 */
609 610
void device_remove_bin_file(struct device *dev,
			    const struct bin_attribute *attr)
611 612 613 614 615 616
{
	if (dev)
		sysfs_remove_bin_file(&dev->kobj, attr);
}
EXPORT_SYMBOL_GPL(device_remove_bin_file);

617 618
static void klist_children_get(struct klist_node *n)
{
619 620
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
621 622 623 624 625 626

	get_device(dev);
}

static void klist_children_put(struct klist_node *n)
{
627 628
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
629 630 631 632

	put_device(dev);
}

L
Linus Torvalds 已提交
633
/**
634 635
 * device_initialize - init device structure.
 * @dev: device.
L
Linus Torvalds 已提交
636
 *
637 638
 * This prepares the device for use by other layers by initializing
 * its fields.
639
 * It is the first half of device_register(), if called by
640 641 642 643 644
 * 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.
 *
645 646 647 648 649
 * 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.
 *
650 651
 * NOTE: Use put_device() to give up your reference instead of freeing
 * @dev directly once you have called this function.
L
Linus Torvalds 已提交
652 653 654
 */
void device_initialize(struct device *dev)
{
655
	dev->kobj.kset = devices_kset;
656
	kobject_init(&dev->kobj, &device_ktype);
L
Linus Torvalds 已提交
657
	INIT_LIST_HEAD(&dev->dma_pools);
658
	mutex_init(&dev->mutex);
659
	lockdep_set_novalidate_class(&dev->mutex);
T
Tejun Heo 已提交
660 661
	spin_lock_init(&dev->devres_lock);
	INIT_LIST_HEAD(&dev->devres_head);
662
	device_pm_init(dev);
663
	set_dev_node(dev, -1);
L
Linus Torvalds 已提交
664
}
665
EXPORT_SYMBOL_GPL(device_initialize);
L
Linus Torvalds 已提交
666

667
struct kobject *virtual_device_parent(struct device *dev)
668
{
669
	static struct kobject *virtual_dir = NULL;
670

671
	if (!virtual_dir)
672
		virtual_dir = kobject_create_and_add("virtual",
673
						     &devices_kset->kobj);
674

675
	return virtual_dir;
676 677
}

678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
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)
693
{
694 695 696 697 698 699 700 701 702 703 704 705 706 707
	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;
708 709
	int retval;

710 711 712 713 714 715 716
	dir = kzalloc(sizeof(*dir), GFP_KERNEL);
	if (!dir)
		return NULL;

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

717
	dir->kobj.kset = &class->p->glue_dirs;
718 719 720 721 722 723 724 725 726

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

727
static DEFINE_MUTEX(gdp_mutex);
728 729 730 731

static struct kobject *get_device_parent(struct device *dev,
					 struct device *parent)
{
732 733 734 735 736
	if (dev->class) {
		struct kobject *kobj = NULL;
		struct kobject *parent_kobj;
		struct kobject *k;

737
#ifdef CONFIG_BLOCK
738
		/* block disks show up in /sys/block */
739
		if (sysfs_deprecated && dev->class == &block_class) {
740 741
			if (parent && parent->class == &block_class)
				return &parent->kobj;
742
			return &block_class.p->subsys.kobj;
743
		}
744
#endif
745

746 747
		/*
		 * If we have no parent, we live in "virtual".
748 749
		 * Class-devices with a non class-device as parent, live
		 * in a "glue" directory to prevent namespace collisions.
750 751 752
		 */
		if (parent == NULL)
			parent_kobj = virtual_device_parent(dev);
753
		else if (parent->class && !dev->class->ns_type)
754 755 756 757
			return &parent->kobj;
		else
			parent_kobj = &parent->kobj;

758 759
		mutex_lock(&gdp_mutex);

760
		/* find our class-directory at the parent and reference it */
761 762
		spin_lock(&dev->class->p->glue_dirs.list_lock);
		list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
763 764 765 766
			if (k->parent == parent_kobj) {
				kobj = kobject_get(k);
				break;
			}
767
		spin_unlock(&dev->class->p->glue_dirs.list_lock);
768 769
		if (kobj) {
			mutex_unlock(&gdp_mutex);
770
			return kobj;
771
		}
772 773

		/* or create a new class-directory at the parent device */
774
		k = class_dir_create_and_add(dev->class, parent_kobj);
775
		/* do not emit an uevent for this simple "glue" directory */
776
		mutex_unlock(&gdp_mutex);
777
		return k;
778 779
	}

780 781 782 783
	/* subsystems can specify a default root directory for their devices */
	if (!parent && dev->bus && dev->bus->dev_root)
		return &dev->bus->dev_root->kobj;

784
	if (parent)
785 786 787
		return &parent->kobj;
	return NULL;
}
788

789
static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
790
{
791
	/* see if we live in a "glue" directory */
792
	if (!glue_dir || !dev->class ||
793
	    glue_dir->kset != &dev->class->p->glue_dirs)
794 795
		return;

796
	mutex_lock(&gdp_mutex);
797
	kobject_put(glue_dir);
798
	mutex_unlock(&gdp_mutex);
799
}
800 801 802 803 804

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

806 807 808 809 810 811
static int device_add_class_symlinks(struct device *dev)
{
	int error;

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

813
	error = sysfs_create_link(&dev->kobj,
814
				  &dev->class->p->subsys.kobj,
815 816 817
				  "subsystem");
	if (error)
		goto out;
818

819
	if (dev->parent && device_is_not_partition(dev)) {
820
		error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
821 822
					  "device");
		if (error)
823
			goto out_subsys;
824 825
	}

826
#ifdef CONFIG_BLOCK
827
	/* /sys/block has directories and does not need symlinks */
828
	if (sysfs_deprecated && dev->class == &block_class)
829
		return 0;
830
#endif
831

832
	/* link in the class directory pointing to the device */
833
	error = sysfs_create_link(&dev->class->p->subsys.kobj,
834
				  &dev->kobj, dev_name(dev));
835
	if (error)
836
		goto out_device;
837 838 839

	return 0;

840 841
out_device:
	sysfs_remove_link(&dev->kobj, "device");
842

843 844 845 846 847 848 849 850 851 852
out_subsys:
	sysfs_remove_link(&dev->kobj, "subsystem");
out:
	return error;
}

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

854
	if (dev->parent && device_is_not_partition(dev))
855
		sysfs_remove_link(&dev->kobj, "device");
856
	sysfs_remove_link(&dev->kobj, "subsystem");
857
#ifdef CONFIG_BLOCK
858
	if (sysfs_deprecated && dev->class == &block_class)
859
		return;
860
#endif
861
	sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
862 863
}

864 865 866
/**
 * dev_set_name - set a device name
 * @dev: device
867
 * @fmt: format string for the device's name
868 869 870 871
 */
int dev_set_name(struct device *dev, const char *fmt, ...)
{
	va_list vargs;
872
	int err;
873 874

	va_start(vargs, fmt);
875
	err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
876
	va_end(vargs);
877
	return err;
878 879 880
}
EXPORT_SYMBOL_GPL(dev_set_name);

881 882 883 884 885 886 887 888
/**
 * 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 已提交
889 890
 * device_remove_sys_dev_entry() will disagree about the presence of
 * the link.
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
 */
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);
	}
}

929 930 931 932 933 934 935 936
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);
937
	INIT_LIST_HEAD(&dev->p->deferred_probe);
938 939 940
	return 0;
}

L
Linus Torvalds 已提交
941
/**
942 943
 * device_add - add device to device hierarchy.
 * @dev: device.
L
Linus Torvalds 已提交
944
 *
945 946
 * This is part 2 of device_register(), though may be called
 * separately _iff_ device_initialize() has been called separately.
L
Linus Torvalds 已提交
947
 *
948
 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
949 950
 * to the global and sibling lists for the device, then
 * adds it to the other relevant subsystems of the driver model.
951
 *
952 953 954 955 956 957 958
 * 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.
 *
959 960 961
 * 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 已提交
962 963 964 965
 */
int device_add(struct device *dev)
{
	struct device *parent = NULL;
966
	struct kobject *kobj;
967
	struct class_interface *class_intf;
968
	int error = -EINVAL;
969

L
Linus Torvalds 已提交
970
	dev = get_device(dev);
971 972 973
	if (!dev)
		goto done;

974
	if (!dev->p) {
975 976 977
		error = device_private_init(dev);
		if (error)
			goto done;
978 979
	}

980 981 982 983 984 985
	/*
	 * 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) {
986
		dev_set_name(dev, "%s", dev->init_name);
987 988
		dev->init_name = NULL;
	}
989

990 991 992 993
	/* 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);

994 995
	if (!dev_name(dev)) {
		error = -EINVAL;
996
		goto name_error;
997
	}
L
Linus Torvalds 已提交
998

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

L
Linus Torvalds 已提交
1001
	parent = get_device(dev->parent);
1002 1003 1004
	kobj = get_device_parent(dev, parent);
	if (kobj)
		dev->kobj.parent = kobj;
L
Linus Torvalds 已提交
1005

1006 1007 1008 1009
	/* use parent numa_node */
	if (parent)
		set_dev_node(dev, dev_to_node(parent));

L
Linus Torvalds 已提交
1010
	/* first, register with generic layer. */
1011 1012
	/* we require the name to be set before, and pass NULL */
	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
1013
	if (error)
L
Linus Torvalds 已提交
1014
		goto Error;
1015

1016 1017 1018 1019
	/* notify platform of device entry */
	if (platform_notify)
		platform_notify(dev);

1020
	error = device_create_file(dev, &dev_attr_uevent);
1021 1022
	if (error)
		goto attrError;
1023

1024 1025 1026
	error = device_add_class_symlinks(dev);
	if (error)
		goto SymlinkError;
1027 1028
	error = device_add_attrs(dev);
	if (error)
1029
		goto AttrsError;
1030 1031
	error = bus_add_device(dev);
	if (error)
L
Linus Torvalds 已提交
1032
		goto BusError;
1033
	error = dpm_sysfs_add(dev);
1034
	if (error)
1035 1036
		goto DPMError;
	device_pm_add(dev);
1037

1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
	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);
	}

1050
	/* Notify clients of device addition.  This call must come
1051
	 * after dpm_sysfs_add() and before kobject_uevent().
1052 1053 1054 1055 1056
	 */
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_ADD_DEVICE, dev);

1057
	kobject_uevent(&dev->kobj, KOBJ_ADD);
1058
	bus_probe_device(dev);
L
Linus Torvalds 已提交
1059
	if (parent)
1060 1061
		klist_add_tail(&dev->p->knode_parent,
			       &parent->p->klist_children);
L
Linus Torvalds 已提交
1062

1063
	if (dev->class) {
1064
		mutex_lock(&dev->class->p->mutex);
1065
		/* tie the class to the device */
1066
		klist_add_tail(&dev->knode_class,
1067
			       &dev->class->p->klist_devices);
1068 1069

		/* notify any interfaces that the device is here */
1070
		list_for_each_entry(class_intf,
1071
				    &dev->class->p->interfaces, node)
1072 1073
			if (class_intf->add_dev)
				class_intf->add_dev(dev, class_intf);
1074
		mutex_unlock(&dev->class->p->mutex);
1075
	}
1076
done:
L
Linus Torvalds 已提交
1077 1078
	put_device(dev);
	return error;
1079 1080 1081 1082 1083 1084
 SysEntryError:
	if (MAJOR(dev->devt))
		device_remove_file(dev, &dev_attr_dev);
 DevAttrError:
	device_pm_remove(dev);
	dpm_sysfs_remove(dev);
1085
 DPMError:
1086 1087
	bus_remove_device(dev);
 BusError:
1088
	device_remove_attrs(dev);
1089
 AttrsError:
1090 1091
	device_remove_class_symlinks(dev);
 SymlinkError:
1092
	device_remove_file(dev, &dev_attr_uevent);
1093
 attrError:
1094
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
L
Linus Torvalds 已提交
1095 1096
	kobject_del(&dev->kobj);
 Error:
1097
	cleanup_device_parent(dev);
1098
	put_device(parent);
1099 1100 1101
name_error:
	kfree(dev->p);
	dev->p = NULL;
1102
	goto done;
L
Linus Torvalds 已提交
1103
}
1104
EXPORT_SYMBOL_GPL(device_add);
L
Linus Torvalds 已提交
1105 1106

/**
1107 1108
 * device_register - register a device with the system.
 * @dev: pointer to the device structure
L
Linus Torvalds 已提交
1109
 *
1110 1111 1112 1113 1114 1115
 * 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.
1116
 *
1117 1118 1119
 * For more information, see the kerneldoc for device_initialize()
 * and device_add().
 *
1120 1121 1122
 * 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 已提交
1123 1124 1125 1126 1127 1128
 */
int device_register(struct device *dev)
{
	device_initialize(dev);
	return device_add(dev);
}
1129
EXPORT_SYMBOL_GPL(device_register);
L
Linus Torvalds 已提交
1130 1131

/**
1132 1133
 * get_device - increment reference count for device.
 * @dev: device.
L
Linus Torvalds 已提交
1134
 *
1135 1136 1137
 * 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 已提交
1138
 */
1139
struct device *get_device(struct device *dev)
L
Linus Torvalds 已提交
1140
{
1141
	return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
L
Linus Torvalds 已提交
1142
}
1143
EXPORT_SYMBOL_GPL(get_device);
L
Linus Torvalds 已提交
1144 1145

/**
1146 1147
 * put_device - decrement reference count.
 * @dev: device in question.
L
Linus Torvalds 已提交
1148
 */
1149
void put_device(struct device *dev)
L
Linus Torvalds 已提交
1150
{
1151
	/* might_sleep(); */
L
Linus Torvalds 已提交
1152 1153 1154
	if (dev)
		kobject_put(&dev->kobj);
}
1155
EXPORT_SYMBOL_GPL(put_device);
L
Linus Torvalds 已提交
1156 1157

/**
1158 1159
 * device_del - delete device from system.
 * @dev: device.
L
Linus Torvalds 已提交
1160
 *
1161 1162 1163 1164 1165
 * 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 已提交
1166
 *
1167 1168
 * NOTE: this should be called manually _iff_ device_add() was
 * also called manually.
L
Linus Torvalds 已提交
1169
 */
1170
void device_del(struct device *dev)
L
Linus Torvalds 已提交
1171
{
1172
	struct device *parent = dev->parent;
1173
	struct class_interface *class_intf;
L
Linus Torvalds 已提交
1174

1175 1176 1177 1178 1179 1180
	/* 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);
1181
	dpm_sysfs_remove(dev);
L
Linus Torvalds 已提交
1182
	if (parent)
1183
		klist_del(&dev->p->knode_parent);
1184
	if (MAJOR(dev->devt)) {
1185
		devtmpfs_delete_node(dev);
1186
		device_remove_sys_dev_entry(dev);
1187
		device_remove_file(dev, &dev_attr_dev);
1188
	}
1189
	if (dev->class) {
1190
		device_remove_class_symlinks(dev);
1191

1192
		mutex_lock(&dev->class->p->mutex);
1193
		/* notify any interfaces that the device is now gone */
1194
		list_for_each_entry(class_intf,
1195
				    &dev->class->p->interfaces, node)
1196 1197 1198
			if (class_intf->remove_dev)
				class_intf->remove_dev(dev, class_intf);
		/* remove the device from the class list */
1199
		klist_del(&dev->knode_class);
1200
		mutex_unlock(&dev->class->p->mutex);
1201
	}
1202
	device_remove_file(dev, &dev_attr_uevent);
1203
	device_remove_attrs(dev);
1204
	bus_remove_device(dev);
1205
	device_pm_remove(dev);
1206
	driver_deferred_probe_del(dev);
L
Linus Torvalds 已提交
1207 1208 1209 1210 1211 1212

	/* Notify the platform of the removal, in case they
	 * need to do anything...
	 */
	if (platform_notify_remove)
		platform_notify_remove(dev);
1213 1214 1215
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_REMOVED_DEVICE, dev);
1216
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1217
	cleanup_device_parent(dev);
L
Linus Torvalds 已提交
1218
	kobject_del(&dev->kobj);
1219
	put_device(parent);
L
Linus Torvalds 已提交
1220
}
1221
EXPORT_SYMBOL_GPL(device_del);
L
Linus Torvalds 已提交
1222 1223

/**
1224 1225
 * device_unregister - unregister device from system.
 * @dev: device going away.
L
Linus Torvalds 已提交
1226
 *
1227 1228 1229 1230 1231 1232
 * 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 已提交
1233
 */
1234
void device_unregister(struct device *dev)
L
Linus Torvalds 已提交
1235
{
1236
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
L
Linus Torvalds 已提交
1237 1238 1239
	device_del(dev);
	put_device(dev);
}
1240
EXPORT_SYMBOL_GPL(device_unregister);
L
Linus Torvalds 已提交
1241

1242
static struct device *next_device(struct klist_iter *i)
1243
{
1244
	struct klist_node *n = klist_next(i);
1245 1246 1247 1248 1249 1250 1251 1252
	struct device *dev = NULL;
	struct device_private *p;

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

1255
/**
1256
 * device_get_devnode - path of device node file
1257
 * @dev: device
1258
 * @mode: returned file access mode
1259 1260
 * @uid: returned file owner
 * @gid: returned file group
1261 1262 1263 1264 1265 1266 1267
 * @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.
 */
1268
const char *device_get_devnode(struct device *dev,
1269
			       umode_t *mode, kuid_t *uid, kgid_t *gid,
1270
			       const char **tmp)
1271 1272 1273 1274 1275 1276
{
	char *s;

	*tmp = NULL;

	/* the device type may provide a specific name */
1277
	if (dev->type && dev->type->devnode)
1278
		*tmp = dev->type->devnode(dev, mode, uid, gid);
1279 1280 1281 1282
	if (*tmp)
		return *tmp;

	/* the class may provide a specific name */
1283 1284
	if (dev->class && dev->class->devnode)
		*tmp = dev->class->devnode(dev, mode);
1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
	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 已提交
1301
/**
1302 1303 1304
 * device_for_each_child - device child iterator.
 * @parent: parent struct device.
 * @fn: function to be called for each device.
1305
 * @data: data for the callback.
L
Linus Torvalds 已提交
1306
 *
1307 1308
 * Iterate over @parent's child devices, and call @fn for each,
 * passing it @data.
L
Linus Torvalds 已提交
1309
 *
1310 1311
 * 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 已提交
1312
 */
1313 1314
int device_for_each_child(struct device *parent, void *data,
			  int (*fn)(struct device *dev, void *data))
L
Linus Torvalds 已提交
1315
{
1316
	struct klist_iter i;
1317
	struct device *child;
L
Linus Torvalds 已提交
1318 1319
	int error = 0;

1320 1321 1322
	if (!parent->p)
		return 0;

1323
	klist_iter_init(&parent->p->klist_children, &i);
1324 1325 1326
	while ((child = next_device(&i)) && !error)
		error = fn(child, data);
	klist_iter_exit(&i);
L
Linus Torvalds 已提交
1327 1328
	return error;
}
1329
EXPORT_SYMBOL_GPL(device_for_each_child);
L
Linus Torvalds 已提交
1330

1331 1332 1333 1334
/**
 * device_find_child - device iterator for locating a particular device.
 * @parent: parent struct device
 * @match: Callback function to check device
1335
 * @data: Data to pass to match function
1336 1337 1338 1339 1340 1341 1342 1343 1344
 *
 * 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.
1345 1346
 *
 * NOTE: you will need to drop the reference with put_device() after use.
1347
 */
1348 1349
struct device *device_find_child(struct device *parent, void *data,
				 int (*match)(struct device *dev, void *data))
1350 1351 1352 1353 1354 1355 1356
{
	struct klist_iter i;
	struct device *child;

	if (!parent)
		return NULL;

1357
	klist_iter_init(&parent->p->klist_children, &i);
1358 1359 1360 1361 1362 1363
	while ((child = next_device(&i)))
		if (match(child, data) && get_device(child))
			break;
	klist_iter_exit(&i);
	return child;
}
1364
EXPORT_SYMBOL_GPL(device_find_child);
1365

L
Linus Torvalds 已提交
1366 1367
int __init devices_init(void)
{
1368 1369 1370
	devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
	if (!devices_kset)
		return -ENOMEM;
1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
	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;

1381
	return 0;
1382 1383 1384 1385 1386 1387 1388 1389

 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 已提交
1390 1391
}

1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472
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;
}

1473
struct root_device {
1474 1475 1476 1477
	struct device dev;
	struct module *owner;
};

1478
static inline struct root_device *to_root_device(struct device *d)
1479 1480 1481
{
	return container_of(d, struct root_device, dev);
}
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505

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.
 *
1506 1507
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
 * 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);

1519
	err = dev_set_name(&root->dev, "%s", name);
1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
	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);
	}

1533
#ifdef CONFIG_MODULES	/* gotta find a "cleaner" way to do this */
1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551
	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
1552
 * @dev: device going away
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
 *
 * 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);

1568 1569 1570

static void device_create_release(struct device *dev)
{
1571
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1572 1573 1574
	kfree(dev);
}

1575 1576 1577 1578 1579
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)
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592
{
	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;
	}

1593
	device_initialize(dev);
1594 1595 1596
	dev->devt = devt;
	dev->class = class;
	dev->parent = parent;
1597
	dev->groups = groups;
1598
	dev->release = device_create_release;
1599
	dev_set_drvdata(dev, drvdata);
1600

1601 1602 1603 1604
	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
	if (retval)
		goto error;

1605
	retval = device_add(dev);
1606 1607 1608 1609 1610 1611
	if (retval)
		goto error;

	return dev;

error:
1612
	put_device(dev);
1613 1614
	return ERR_PTR(retval);
}
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647

/**
 * 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);
}
1648 1649 1650
EXPORT_SYMBOL_GPL(device_create_vargs);

/**
1651
 * device_create - creates a device and registers it with sysfs
1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
 * @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.
 *
1669 1670
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
1671 1672 1673
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
1674 1675
struct device *device_create(struct class *class, struct device *parent,
			     dev_t devt, void *drvdata, const char *fmt, ...)
1676 1677 1678 1679 1680 1681 1682 1683 1684
{
	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;
}
1685
EXPORT_SYMBOL_GPL(device_create);
1686

1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
/**
 * 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);

1731
static int __match_devt(struct device *dev, const void *data)
1732
{
1733
	const dev_t *devt = data;
1734

1735
	return dev->devt == *devt;
1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
}

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

1750
	dev = class_find_device(class, NULL, &devt, __match_devt);
1751 1752
	if (dev) {
		put_device(dev);
1753
		device_unregister(dev);
1754
	}
1755 1756
}
EXPORT_SYMBOL_GPL(device_destroy);
1757 1758 1759 1760 1761

/**
 * device_rename - renames a device
 * @dev: the pointer to the struct device to be renamed
 * @new_name: the new name of the device
1762 1763 1764 1765 1766
 *
 * 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.
1767
 *
1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
 * 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. :)
1796
 */
1797
int device_rename(struct device *dev, const char *new_name)
1798
{
1799
	struct kobject *kobj = &dev->kobj;
1800
	char *old_device_name = NULL;
1801 1802 1803 1804 1805 1806
	int error;

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

1807
	dev_dbg(dev, "renaming to %s\n", new_name);
1808

1809
	old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1810 1811 1812
	if (!old_device_name) {
		error = -ENOMEM;
		goto out;
1813 1814
	}

1815
	if (dev->class) {
1816 1817 1818
		error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj,
					     kobj, old_device_name,
					     new_name, kobject_namespace(kobj));
1819 1820 1821
		if (error)
			goto out;
	}
1822

1823
	error = kobject_rename(kobj, new_name);
1824
	if (error)
1825
		goto out;
1826

1827
out:
1828 1829
	put_device(dev);

1830
	kfree(old_device_name);
1831 1832 1833

	return error;
}
1834
EXPORT_SYMBOL_GPL(device_rename);
1835 1836 1837 1838 1839

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

1842 1843 1844 1845 1846 1847
	if (old_parent)
		sysfs_remove_link(&dev->kobj, "device");
	if (new_parent)
		error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
					  "device");
	return error;
1848 1849 1850 1851 1852
}

/**
 * device_move - moves a device to a new parent
 * @dev: the pointer to the struct device to be moved
1853
 * @new_parent: the new parent of the device (can by NULL)
1854
 * @dpm_order: how to reorder the dpm_list
1855
 */
1856 1857
int device_move(struct device *dev, struct device *new_parent,
		enum dpm_order dpm_order)
1858 1859 1860
{
	int error;
	struct device *old_parent;
1861
	struct kobject *new_parent_kobj;
1862 1863 1864 1865 1866

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

1867
	device_pm_lock();
1868
	new_parent = get_device(new_parent);
1869
	new_parent_kobj = get_device_parent(dev, new_parent);
1870

1871 1872
	pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
		 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1873
	error = kobject_move(&dev->kobj, new_parent_kobj);
1874
	if (error) {
1875
		cleanup_glue_dir(dev, new_parent_kobj);
1876 1877 1878 1879 1880 1881
		put_device(new_parent);
		goto out;
	}
	old_parent = dev->parent;
	dev->parent = new_parent;
	if (old_parent)
1882
		klist_remove(&dev->p->knode_parent);
1883
	if (new_parent) {
1884 1885
		klist_add_tail(&dev->p->knode_parent,
			       &new_parent->p->klist_children);
1886 1887 1888
		set_dev_node(dev, dev_to_node(new_parent));
	}

1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902
	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));
				}
1903
			}
1904 1905 1906
			cleanup_glue_dir(dev, new_parent_kobj);
			put_device(new_parent);
			goto out;
1907 1908
		}
	}
1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
	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;
	}
1922

1923 1924
	put_device(old_parent);
out:
1925
	device_pm_unlock();
1926 1927 1928 1929
	put_device(dev);
	return error;
}
EXPORT_SYMBOL_GPL(device_move);
1930 1931 1932 1933 1934 1935

/**
 * device_shutdown - call ->shutdown() on each device to shutdown.
 */
void device_shutdown(void)
{
1936
	struct device *dev, *parent;
1937 1938 1939 1940 1941 1942 1943 1944 1945 1946

	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);
1947 1948 1949 1950 1951 1952

		/*
		 * hold reference count of device's parent to
		 * prevent it from being freed because parent's
		 * lock is to be held
		 */
1953
		parent = get_device(dev->parent);
1954 1955 1956 1957 1958 1959 1960
		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);
1961

1962
		/* hold lock to avoid race with probe/release */
1963 1964
		if (parent)
			device_lock(parent);
1965 1966
		device_lock(dev);

1967 1968 1969
		/* Don't allow any more runtime suspends */
		pm_runtime_get_noresume(dev);
		pm_runtime_barrier(dev);
1970 1971

		if (dev->bus && dev->bus->shutdown) {
1972 1973
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
1974 1975
			dev->bus->shutdown(dev);
		} else if (dev->driver && dev->driver->shutdown) {
1976 1977
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
1978 1979
			dev->driver->shutdown(dev);
		}
1980 1981

		device_unlock(dev);
1982 1983
		if (parent)
			device_unlock(parent);
1984

1985
		put_device(dev);
1986
		put_device(parent);
1987 1988

		spin_lock(&devices_kset->list_lock);
1989
	}
1990
	spin_unlock(&devices_kset->list_lock);
1991
}
1992 1993 1994 1995 1996 1997

/*
 * Device logging functions
 */

#ifdef CONFIG_PRINTK
1998 1999
static int
create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
2000
{
2001
	const char *subsys;
2002
	size_t pos = 0;
2003

2004 2005 2006 2007 2008
	if (dev->class)
		subsys = dev->class->name;
	else if (dev->bus)
		subsys = dev->bus->name;
	else
2009
		return 0;
2010

2011
	pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
2012 2013
	if (pos >= hdrlen)
		goto overflow;
2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028

	/*
	 * 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';
2029 2030 2031 2032
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=%c%u:%u",
				c, MAJOR(dev->devt), MINOR(dev->devt));
2033 2034 2035
	} else if (strcmp(subsys, "net") == 0) {
		struct net_device *net = to_net_dev(dev);

2036 2037 2038
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=n%u", net->ifindex);
2039
	} else {
2040 2041 2042
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=+%s:%s", subsys, dev_name(dev));
2043
	}
2044

2045 2046 2047
	if (pos >= hdrlen)
		goto overflow;

2048
	return pos;
2049 2050 2051 2052

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

2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
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);

2082
static void __dev_printk(const char *level, const struct device *dev,
2083 2084
			struct va_format *vaf)
{
2085 2086 2087 2088 2089
	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);
2090 2091
}

2092 2093
void dev_printk(const char *level, const struct device *dev,
		const char *fmt, ...)
2094 2095 2096 2097 2098 2099 2100 2101 2102
{
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);

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

2103
	__dev_printk(level, dev, &vaf);
2104

2105 2106 2107 2108 2109
	va_end(args);
}
EXPORT_SYMBOL(dev_printk);

#define define_dev_printk_level(func, kern_level)		\
2110
void func(const struct device *dev, const char *fmt, ...)	\
2111 2112 2113 2114 2115 2116 2117 2118 2119
{								\
	struct va_format vaf;					\
	va_list args;						\
								\
	va_start(args, fmt);					\
								\
	vaf.fmt = fmt;						\
	vaf.va = &args;						\
								\
2120
	__dev_printk(kern_level, dev, &vaf);			\
2121
								\
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134
	va_end(args);						\
}								\
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