1 /* 2 * drivers/base/core.c - core driver model code (device registration, etc) 3 * 4 * Copyright (c) 2002-3 Patrick Mochel 5 * Copyright (c) 2002-3 Open Source Development Labs 6 * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de> 7 * Copyright (c) 2006 Novell, Inc. 8 * 9 * This file is released under the GPLv2 10 * 11 */ 12 13 #include <linux/device.h> 14 #include <linux/err.h> 15 #include <linux/init.h> 16 #include <linux/module.h> 17 #include <linux/slab.h> 18 #include <linux/string.h> 19 #include <linux/kdev_t.h> 20 #include <linux/notifier.h> 21 #include <linux/of.h> 22 #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> 29 #include <linux/sysfs.h> 30 31 #include "base.h" 32 #include "power/power.h" 33 34 #ifdef CONFIG_SYSFS_DEPRECATED 35 #ifdef CONFIG_SYSFS_DEPRECATED_V2 36 long sysfs_deprecated = 1; 37 #else 38 long sysfs_deprecated = 0; 39 #endif 40 static int __init sysfs_deprecated_setup(char *arg) 41 { 42 return kstrtol(arg, 10, &sysfs_deprecated); 43 } 44 early_param("sysfs.deprecated", sysfs_deprecated_setup); 45 #endif 46 47 int (*platform_notify)(struct device *dev) = NULL; 48 int (*platform_notify_remove)(struct device *dev) = NULL; 49 static struct kobject *dev_kobj; 50 struct kobject *sysfs_dev_char_kobj; 51 struct kobject *sysfs_dev_block_kobj; 52 53 static DEFINE_MUTEX(device_hotplug_lock); 54 55 void lock_device_hotplug(void) 56 { 57 mutex_lock(&device_hotplug_lock); 58 } 59 60 void unlock_device_hotplug(void) 61 { 62 mutex_unlock(&device_hotplug_lock); 63 } 64 65 int lock_device_hotplug_sysfs(void) 66 { 67 if (mutex_trylock(&device_hotplug_lock)) 68 return 0; 69 70 /* Avoid busy looping (5 ms of sleep should do). */ 71 msleep(5); 72 return restart_syscall(); 73 } 74 75 #ifdef CONFIG_BLOCK 76 static inline int device_is_not_partition(struct device *dev) 77 { 78 return !(dev->type == &part_type); 79 } 80 #else 81 static inline int device_is_not_partition(struct device *dev) 82 { 83 return 1; 84 } 85 #endif 86 87 /** 88 * dev_driver_string - Return a device's driver name, if at all possible 89 * @dev: struct device to get the name of 90 * 91 * Will return the device's driver's name if it is bound to a device. If 92 * the device is not bound to a driver, it will return the name of the bus 93 * it is attached to. If it is not attached to a bus either, an empty 94 * string will be returned. 95 */ 96 const char *dev_driver_string(const struct device *dev) 97 { 98 struct device_driver *drv; 99 100 /* dev->driver can change to NULL underneath us because of unbinding, 101 * so be careful about accessing it. dev->bus and dev->class should 102 * never change once they are set, so they don't need special care. 103 */ 104 drv = ACCESS_ONCE(dev->driver); 105 return drv ? drv->name : 106 (dev->bus ? dev->bus->name : 107 (dev->class ? dev->class->name : "")); 108 } 109 EXPORT_SYMBOL(dev_driver_string); 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, 114 char *buf) 115 { 116 struct device_attribute *dev_attr = to_dev_attr(attr); 117 struct device *dev = kobj_to_dev(kobj); 118 ssize_t ret = -EIO; 119 120 if (dev_attr->show) 121 ret = dev_attr->show(dev, dev_attr, buf); 122 if (ret >= (ssize_t)PAGE_SIZE) { 123 print_symbol("dev_attr_show: %s returned bad count\n", 124 (unsigned long)dev_attr->show); 125 } 126 return ret; 127 } 128 129 static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 130 const char *buf, size_t count) 131 { 132 struct device_attribute *dev_attr = to_dev_attr(attr); 133 struct device *dev = kobj_to_dev(kobj); 134 ssize_t ret = -EIO; 135 136 if (dev_attr->store) 137 ret = dev_attr->store(dev, dev_attr, buf, count); 138 return ret; 139 } 140 141 static const struct sysfs_ops dev_sysfs_ops = { 142 .show = dev_attr_show, 143 .store = dev_attr_store, 144 }; 145 146 #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 147 148 ssize_t device_store_ulong(struct device *dev, 149 struct device_attribute *attr, 150 const char *buf, size_t size) 151 { 152 struct dev_ext_attribute *ea = to_ext_attr(attr); 153 char *end; 154 unsigned long new = simple_strtoul(buf, &end, 0); 155 if (end == buf) 156 return -EINVAL; 157 *(unsigned long *)(ea->var) = new; 158 /* Always return full write size even if we didn't consume all */ 159 return size; 160 } 161 EXPORT_SYMBOL_GPL(device_store_ulong); 162 163 ssize_t device_show_ulong(struct device *dev, 164 struct device_attribute *attr, 165 char *buf) 166 { 167 struct dev_ext_attribute *ea = to_ext_attr(attr); 168 return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 169 } 170 EXPORT_SYMBOL_GPL(device_show_ulong); 171 172 ssize_t device_store_int(struct device *dev, 173 struct device_attribute *attr, 174 const char *buf, size_t size) 175 { 176 struct dev_ext_attribute *ea = to_ext_attr(attr); 177 char *end; 178 long new = simple_strtol(buf, &end, 0); 179 if (end == buf || new > INT_MAX || new < INT_MIN) 180 return -EINVAL; 181 *(int *)(ea->var) = new; 182 /* Always return full write size even if we didn't consume all */ 183 return size; 184 } 185 EXPORT_SYMBOL_GPL(device_store_int); 186 187 ssize_t device_show_int(struct device *dev, 188 struct device_attribute *attr, 189 char *buf) 190 { 191 struct dev_ext_attribute *ea = to_ext_attr(attr); 192 193 return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 194 } 195 EXPORT_SYMBOL_GPL(device_show_int); 196 197 ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 198 const char *buf, size_t size) 199 { 200 struct dev_ext_attribute *ea = to_ext_attr(attr); 201 202 if (strtobool(buf, ea->var) < 0) 203 return -EINVAL; 204 205 return size; 206 } 207 EXPORT_SYMBOL_GPL(device_store_bool); 208 209 ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 210 char *buf) 211 { 212 struct dev_ext_attribute *ea = to_ext_attr(attr); 213 214 return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 215 } 216 EXPORT_SYMBOL_GPL(device_show_bool); 217 218 /** 219 * device_release - free device structure. 220 * @kobj: device's kobject. 221 * 222 * This is called once the reference count for the object 223 * reaches 0. We forward the call to the device's release 224 * method, which should handle actually freeing the structure. 225 */ 226 static void device_release(struct kobject *kobj) 227 { 228 struct device *dev = kobj_to_dev(kobj); 229 struct device_private *p = dev->p; 230 231 /* 232 * Some platform devices are driven without driver attached 233 * and managed resources may have been acquired. Make sure 234 * all resources are released. 235 * 236 * Drivers still can add resources into device after device 237 * is deleted but alive, so release devres here to avoid 238 * possible memory leak. 239 */ 240 devres_release_all(dev); 241 242 if (dev->release) 243 dev->release(dev); 244 else if (dev->type && dev->type->release) 245 dev->type->release(dev); 246 else if (dev->class && dev->class->dev_release) 247 dev->class->dev_release(dev); 248 else 249 WARN(1, KERN_ERR "Device '%s' does not have a release() " 250 "function, it is broken and must be fixed.\n", 251 dev_name(dev)); 252 kfree(p); 253 } 254 255 static const void *device_namespace(struct kobject *kobj) 256 { 257 struct device *dev = kobj_to_dev(kobj); 258 const void *ns = NULL; 259 260 if (dev->class && dev->class->ns_type) 261 ns = dev->class->namespace(dev); 262 263 return ns; 264 } 265 266 static struct kobj_type device_ktype = { 267 .release = device_release, 268 .sysfs_ops = &dev_sysfs_ops, 269 .namespace = device_namespace, 270 }; 271 272 273 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 274 { 275 struct kobj_type *ktype = get_ktype(kobj); 276 277 if (ktype == &device_ktype) { 278 struct device *dev = kobj_to_dev(kobj); 279 if (dev->bus) 280 return 1; 281 if (dev->class) 282 return 1; 283 } 284 return 0; 285 } 286 287 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 288 { 289 struct device *dev = kobj_to_dev(kobj); 290 291 if (dev->bus) 292 return dev->bus->name; 293 if (dev->class) 294 return dev->class->name; 295 return NULL; 296 } 297 298 static int dev_uevent(struct kset *kset, struct kobject *kobj, 299 struct kobj_uevent_env *env) 300 { 301 struct device *dev = kobj_to_dev(kobj); 302 int retval = 0; 303 304 /* add device node properties if present */ 305 if (MAJOR(dev->devt)) { 306 const char *tmp; 307 const char *name; 308 umode_t mode = 0; 309 kuid_t uid = GLOBAL_ROOT_UID; 310 kgid_t gid = GLOBAL_ROOT_GID; 311 312 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 313 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 314 name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 315 if (name) { 316 add_uevent_var(env, "DEVNAME=%s", name); 317 if (mode) 318 add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 319 if (!uid_eq(uid, GLOBAL_ROOT_UID)) 320 add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 321 if (!gid_eq(gid, GLOBAL_ROOT_GID)) 322 add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 323 kfree(tmp); 324 } 325 } 326 327 if (dev->type && dev->type->name) 328 add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 329 330 if (dev->driver) 331 add_uevent_var(env, "DRIVER=%s", dev->driver->name); 332 333 /* Add common DT information about the device */ 334 of_device_uevent(dev, env); 335 336 /* have the bus specific function add its stuff */ 337 if (dev->bus && dev->bus->uevent) { 338 retval = dev->bus->uevent(dev, env); 339 if (retval) 340 pr_debug("device: '%s': %s: bus uevent() returned %d\n", 341 dev_name(dev), __func__, retval); 342 } 343 344 /* have the class specific function add its stuff */ 345 if (dev->class && dev->class->dev_uevent) { 346 retval = dev->class->dev_uevent(dev, env); 347 if (retval) 348 pr_debug("device: '%s': %s: class uevent() " 349 "returned %d\n", dev_name(dev), 350 __func__, retval); 351 } 352 353 /* have the device type specific function add its stuff */ 354 if (dev->type && dev->type->uevent) { 355 retval = dev->type->uevent(dev, env); 356 if (retval) 357 pr_debug("device: '%s': %s: dev_type uevent() " 358 "returned %d\n", dev_name(dev), 359 __func__, retval); 360 } 361 362 return retval; 363 } 364 365 static const struct kset_uevent_ops device_uevent_ops = { 366 .filter = dev_uevent_filter, 367 .name = dev_uevent_name, 368 .uevent = dev_uevent, 369 }; 370 371 static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 372 char *buf) 373 { 374 struct kobject *top_kobj; 375 struct kset *kset; 376 struct kobj_uevent_env *env = NULL; 377 int i; 378 size_t count = 0; 379 int retval; 380 381 /* search the kset, the device belongs to */ 382 top_kobj = &dev->kobj; 383 while (!top_kobj->kset && top_kobj->parent) 384 top_kobj = top_kobj->parent; 385 if (!top_kobj->kset) 386 goto out; 387 388 kset = top_kobj->kset; 389 if (!kset->uevent_ops || !kset->uevent_ops->uevent) 390 goto out; 391 392 /* respect filter */ 393 if (kset->uevent_ops && kset->uevent_ops->filter) 394 if (!kset->uevent_ops->filter(kset, &dev->kobj)) 395 goto out; 396 397 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 398 if (!env) 399 return -ENOMEM; 400 401 /* let the kset specific function add its keys */ 402 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 403 if (retval) 404 goto out; 405 406 /* copy keys to file */ 407 for (i = 0; i < env->envp_idx; i++) 408 count += sprintf(&buf[count], "%s\n", env->envp[i]); 409 out: 410 kfree(env); 411 return count; 412 } 413 414 static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 415 const char *buf, size_t count) 416 { 417 enum kobject_action action; 418 419 if (kobject_action_type(buf, count, &action) == 0) 420 kobject_uevent(&dev->kobj, action); 421 else 422 dev_err(dev, "uevent: unknown action-string\n"); 423 return count; 424 } 425 static DEVICE_ATTR_RW(uevent); 426 427 static ssize_t online_show(struct device *dev, struct device_attribute *attr, 428 char *buf) 429 { 430 bool val; 431 432 device_lock(dev); 433 val = !dev->offline; 434 device_unlock(dev); 435 return sprintf(buf, "%u\n", val); 436 } 437 438 static ssize_t online_store(struct device *dev, struct device_attribute *attr, 439 const char *buf, size_t count) 440 { 441 bool val; 442 int ret; 443 444 ret = strtobool(buf, &val); 445 if (ret < 0) 446 return ret; 447 448 ret = lock_device_hotplug_sysfs(); 449 if (ret) 450 return ret; 451 452 ret = val ? device_online(dev) : device_offline(dev); 453 unlock_device_hotplug(); 454 return ret < 0 ? ret : count; 455 } 456 static DEVICE_ATTR_RW(online); 457 458 int device_add_groups(struct device *dev, const struct attribute_group **groups) 459 { 460 return sysfs_create_groups(&dev->kobj, groups); 461 } 462 463 void device_remove_groups(struct device *dev, 464 const struct attribute_group **groups) 465 { 466 sysfs_remove_groups(&dev->kobj, groups); 467 } 468 469 static int device_add_attrs(struct device *dev) 470 { 471 struct class *class = dev->class; 472 const struct device_type *type = dev->type; 473 int error; 474 475 if (class) { 476 error = device_add_groups(dev, class->dev_groups); 477 if (error) 478 return error; 479 } 480 481 if (type) { 482 error = device_add_groups(dev, type->groups); 483 if (error) 484 goto err_remove_class_groups; 485 } 486 487 error = device_add_groups(dev, dev->groups); 488 if (error) 489 goto err_remove_type_groups; 490 491 if (device_supports_offline(dev) && !dev->offline_disabled) { 492 error = device_create_file(dev, &dev_attr_online); 493 if (error) 494 goto err_remove_type_groups; 495 } 496 497 return 0; 498 499 err_remove_type_groups: 500 if (type) 501 device_remove_groups(dev, type->groups); 502 err_remove_class_groups: 503 if (class) 504 device_remove_groups(dev, class->dev_groups); 505 506 return error; 507 } 508 509 static void device_remove_attrs(struct device *dev) 510 { 511 struct class *class = dev->class; 512 const struct device_type *type = dev->type; 513 514 device_remove_file(dev, &dev_attr_online); 515 device_remove_groups(dev, dev->groups); 516 517 if (type) 518 device_remove_groups(dev, type->groups); 519 520 if (class) 521 device_remove_groups(dev, class->dev_groups); 522 } 523 524 static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 525 char *buf) 526 { 527 return print_dev_t(buf, dev->devt); 528 } 529 static DEVICE_ATTR_RO(dev); 530 531 /* /sys/devices/ */ 532 struct kset *devices_kset; 533 534 /** 535 * device_create_file - create sysfs attribute file for device. 536 * @dev: device. 537 * @attr: device attribute descriptor. 538 */ 539 int device_create_file(struct device *dev, 540 const struct device_attribute *attr) 541 { 542 int error = 0; 543 544 if (dev) { 545 WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 546 "Attribute %s: write permission without 'store'\n", 547 attr->attr.name); 548 WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 549 "Attribute %s: read permission without 'show'\n", 550 attr->attr.name); 551 error = sysfs_create_file(&dev->kobj, &attr->attr); 552 } 553 554 return error; 555 } 556 EXPORT_SYMBOL_GPL(device_create_file); 557 558 /** 559 * device_remove_file - remove sysfs attribute file. 560 * @dev: device. 561 * @attr: device attribute descriptor. 562 */ 563 void device_remove_file(struct device *dev, 564 const struct device_attribute *attr) 565 { 566 if (dev) 567 sysfs_remove_file(&dev->kobj, &attr->attr); 568 } 569 EXPORT_SYMBOL_GPL(device_remove_file); 570 571 /** 572 * device_create_bin_file - create sysfs binary attribute file for device. 573 * @dev: device. 574 * @attr: device binary attribute descriptor. 575 */ 576 int device_create_bin_file(struct device *dev, 577 const struct bin_attribute *attr) 578 { 579 int error = -EINVAL; 580 if (dev) 581 error = sysfs_create_bin_file(&dev->kobj, attr); 582 return error; 583 } 584 EXPORT_SYMBOL_GPL(device_create_bin_file); 585 586 /** 587 * device_remove_bin_file - remove sysfs binary attribute file 588 * @dev: device. 589 * @attr: device binary attribute descriptor. 590 */ 591 void device_remove_bin_file(struct device *dev, 592 const struct bin_attribute *attr) 593 { 594 if (dev) 595 sysfs_remove_bin_file(&dev->kobj, attr); 596 } 597 EXPORT_SYMBOL_GPL(device_remove_bin_file); 598 599 /** 600 * device_schedule_callback_owner - helper to schedule a callback for a device 601 * @dev: device. 602 * @func: callback function to invoke later. 603 * @owner: module owning the callback routine 604 * 605 * Attribute methods must not unregister themselves or their parent device 606 * (which would amount to the same thing). Attempts to do so will deadlock, 607 * since unregistration is mutually exclusive with driver callbacks. 608 * 609 * Instead methods can call this routine, which will attempt to allocate 610 * and schedule a workqueue request to call back @func with @dev as its 611 * argument in the workqueue's process context. @dev will be pinned until 612 * @func returns. 613 * 614 * This routine is usually called via the inline device_schedule_callback(), 615 * which automatically sets @owner to THIS_MODULE. 616 * 617 * Returns 0 if the request was submitted, -ENOMEM if storage could not 618 * be allocated, -ENODEV if a reference to @owner isn't available. 619 * 620 * NOTE: This routine won't work if CONFIG_SYSFS isn't set! It uses an 621 * underlying sysfs routine (since it is intended for use by attribute 622 * methods), and if sysfs isn't available you'll get nothing but -ENOSYS. 623 */ 624 int device_schedule_callback_owner(struct device *dev, 625 void (*func)(struct device *), struct module *owner) 626 { 627 return sysfs_schedule_callback(&dev->kobj, 628 (void (*)(void *)) func, dev, owner); 629 } 630 EXPORT_SYMBOL_GPL(device_schedule_callback_owner); 631 632 static void klist_children_get(struct klist_node *n) 633 { 634 struct device_private *p = to_device_private_parent(n); 635 struct device *dev = p->device; 636 637 get_device(dev); 638 } 639 640 static void klist_children_put(struct klist_node *n) 641 { 642 struct device_private *p = to_device_private_parent(n); 643 struct device *dev = p->device; 644 645 put_device(dev); 646 } 647 648 /** 649 * device_initialize - init device structure. 650 * @dev: device. 651 * 652 * This prepares the device for use by other layers by initializing 653 * its fields. 654 * It is the first half of device_register(), if called by 655 * that function, though it can also be called separately, so one 656 * may use @dev's fields. In particular, get_device()/put_device() 657 * may be used for reference counting of @dev after calling this 658 * function. 659 * 660 * All fields in @dev must be initialized by the caller to 0, except 661 * for those explicitly set to some other value. The simplest 662 * approach is to use kzalloc() to allocate the structure containing 663 * @dev. 664 * 665 * NOTE: Use put_device() to give up your reference instead of freeing 666 * @dev directly once you have called this function. 667 */ 668 void device_initialize(struct device *dev) 669 { 670 dev->kobj.kset = devices_kset; 671 kobject_init(&dev->kobj, &device_ktype); 672 INIT_LIST_HEAD(&dev->dma_pools); 673 mutex_init(&dev->mutex); 674 lockdep_set_novalidate_class(&dev->mutex); 675 spin_lock_init(&dev->devres_lock); 676 INIT_LIST_HEAD(&dev->devres_head); 677 device_pm_init(dev); 678 set_dev_node(dev, -1); 679 } 680 EXPORT_SYMBOL_GPL(device_initialize); 681 682 struct kobject *virtual_device_parent(struct device *dev) 683 { 684 static struct kobject *virtual_dir = NULL; 685 686 if (!virtual_dir) 687 virtual_dir = kobject_create_and_add("virtual", 688 &devices_kset->kobj); 689 690 return virtual_dir; 691 } 692 693 struct class_dir { 694 struct kobject kobj; 695 struct class *class; 696 }; 697 698 #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 699 700 static void class_dir_release(struct kobject *kobj) 701 { 702 struct class_dir *dir = to_class_dir(kobj); 703 kfree(dir); 704 } 705 706 static const 707 struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 708 { 709 struct class_dir *dir = to_class_dir(kobj); 710 return dir->class->ns_type; 711 } 712 713 static struct kobj_type class_dir_ktype = { 714 .release = class_dir_release, 715 .sysfs_ops = &kobj_sysfs_ops, 716 .child_ns_type = class_dir_child_ns_type 717 }; 718 719 static struct kobject * 720 class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 721 { 722 struct class_dir *dir; 723 int retval; 724 725 dir = kzalloc(sizeof(*dir), GFP_KERNEL); 726 if (!dir) 727 return NULL; 728 729 dir->class = class; 730 kobject_init(&dir->kobj, &class_dir_ktype); 731 732 dir->kobj.kset = &class->p->glue_dirs; 733 734 retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 735 if (retval < 0) { 736 kobject_put(&dir->kobj); 737 return NULL; 738 } 739 return &dir->kobj; 740 } 741 742 743 static struct kobject *get_device_parent(struct device *dev, 744 struct device *parent) 745 { 746 if (dev->class) { 747 static DEFINE_MUTEX(gdp_mutex); 748 struct kobject *kobj = NULL; 749 struct kobject *parent_kobj; 750 struct kobject *k; 751 752 #ifdef CONFIG_BLOCK 753 /* block disks show up in /sys/block */ 754 if (sysfs_deprecated && dev->class == &block_class) { 755 if (parent && parent->class == &block_class) 756 return &parent->kobj; 757 return &block_class.p->subsys.kobj; 758 } 759 #endif 760 761 /* 762 * If we have no parent, we live in "virtual". 763 * Class-devices with a non class-device as parent, live 764 * in a "glue" directory to prevent namespace collisions. 765 */ 766 if (parent == NULL) 767 parent_kobj = virtual_device_parent(dev); 768 else if (parent->class && !dev->class->ns_type) 769 return &parent->kobj; 770 else 771 parent_kobj = &parent->kobj; 772 773 mutex_lock(&gdp_mutex); 774 775 /* find our class-directory at the parent and reference it */ 776 spin_lock(&dev->class->p->glue_dirs.list_lock); 777 list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 778 if (k->parent == parent_kobj) { 779 kobj = kobject_get(k); 780 break; 781 } 782 spin_unlock(&dev->class->p->glue_dirs.list_lock); 783 if (kobj) { 784 mutex_unlock(&gdp_mutex); 785 return kobj; 786 } 787 788 /* or create a new class-directory at the parent device */ 789 k = class_dir_create_and_add(dev->class, parent_kobj); 790 /* do not emit an uevent for this simple "glue" directory */ 791 mutex_unlock(&gdp_mutex); 792 return k; 793 } 794 795 /* subsystems can specify a default root directory for their devices */ 796 if (!parent && dev->bus && dev->bus->dev_root) 797 return &dev->bus->dev_root->kobj; 798 799 if (parent) 800 return &parent->kobj; 801 return NULL; 802 } 803 804 static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 805 { 806 /* see if we live in a "glue" directory */ 807 if (!glue_dir || !dev->class || 808 glue_dir->kset != &dev->class->p->glue_dirs) 809 return; 810 811 kobject_put(glue_dir); 812 } 813 814 static void cleanup_device_parent(struct device *dev) 815 { 816 cleanup_glue_dir(dev, dev->kobj.parent); 817 } 818 819 static int device_add_class_symlinks(struct device *dev) 820 { 821 int error; 822 823 if (!dev->class) 824 return 0; 825 826 error = sysfs_create_link(&dev->kobj, 827 &dev->class->p->subsys.kobj, 828 "subsystem"); 829 if (error) 830 goto out; 831 832 if (dev->parent && device_is_not_partition(dev)) { 833 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 834 "device"); 835 if (error) 836 goto out_subsys; 837 } 838 839 #ifdef CONFIG_BLOCK 840 /* /sys/block has directories and does not need symlinks */ 841 if (sysfs_deprecated && dev->class == &block_class) 842 return 0; 843 #endif 844 845 /* link in the class directory pointing to the device */ 846 error = sysfs_create_link(&dev->class->p->subsys.kobj, 847 &dev->kobj, dev_name(dev)); 848 if (error) 849 goto out_device; 850 851 return 0; 852 853 out_device: 854 sysfs_remove_link(&dev->kobj, "device"); 855 856 out_subsys: 857 sysfs_remove_link(&dev->kobj, "subsystem"); 858 out: 859 return error; 860 } 861 862 static void device_remove_class_symlinks(struct device *dev) 863 { 864 if (!dev->class) 865 return; 866 867 if (dev->parent && device_is_not_partition(dev)) 868 sysfs_remove_link(&dev->kobj, "device"); 869 sysfs_remove_link(&dev->kobj, "subsystem"); 870 #ifdef CONFIG_BLOCK 871 if (sysfs_deprecated && dev->class == &block_class) 872 return; 873 #endif 874 sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 875 } 876 877 /** 878 * dev_set_name - set a device name 879 * @dev: device 880 * @fmt: format string for the device's name 881 */ 882 int dev_set_name(struct device *dev, const char *fmt, ...) 883 { 884 va_list vargs; 885 int err; 886 887 va_start(vargs, fmt); 888 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 889 va_end(vargs); 890 return err; 891 } 892 EXPORT_SYMBOL_GPL(dev_set_name); 893 894 /** 895 * device_to_dev_kobj - select a /sys/dev/ directory for the device 896 * @dev: device 897 * 898 * By default we select char/ for new entries. Setting class->dev_obj 899 * to NULL prevents an entry from being created. class->dev_kobj must 900 * be set (or cleared) before any devices are registered to the class 901 * otherwise device_create_sys_dev_entry() and 902 * device_remove_sys_dev_entry() will disagree about the presence of 903 * the link. 904 */ 905 static struct kobject *device_to_dev_kobj(struct device *dev) 906 { 907 struct kobject *kobj; 908 909 if (dev->class) 910 kobj = dev->class->dev_kobj; 911 else 912 kobj = sysfs_dev_char_kobj; 913 914 return kobj; 915 } 916 917 static int device_create_sys_dev_entry(struct device *dev) 918 { 919 struct kobject *kobj = device_to_dev_kobj(dev); 920 int error = 0; 921 char devt_str[15]; 922 923 if (kobj) { 924 format_dev_t(devt_str, dev->devt); 925 error = sysfs_create_link(kobj, &dev->kobj, devt_str); 926 } 927 928 return error; 929 } 930 931 static void device_remove_sys_dev_entry(struct device *dev) 932 { 933 struct kobject *kobj = device_to_dev_kobj(dev); 934 char devt_str[15]; 935 936 if (kobj) { 937 format_dev_t(devt_str, dev->devt); 938 sysfs_remove_link(kobj, devt_str); 939 } 940 } 941 942 int device_private_init(struct device *dev) 943 { 944 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 945 if (!dev->p) 946 return -ENOMEM; 947 dev->p->device = dev; 948 klist_init(&dev->p->klist_children, klist_children_get, 949 klist_children_put); 950 INIT_LIST_HEAD(&dev->p->deferred_probe); 951 return 0; 952 } 953 954 /** 955 * device_add - add device to device hierarchy. 956 * @dev: device. 957 * 958 * This is part 2 of device_register(), though may be called 959 * separately _iff_ device_initialize() has been called separately. 960 * 961 * This adds @dev to the kobject hierarchy via kobject_add(), adds it 962 * to the global and sibling lists for the device, then 963 * adds it to the other relevant subsystems of the driver model. 964 * 965 * Do not call this routine or device_register() more than once for 966 * any device structure. The driver model core is not designed to work 967 * with devices that get unregistered and then spring back to life. 968 * (Among other things, it's very hard to guarantee that all references 969 * to the previous incarnation of @dev have been dropped.) Allocate 970 * and register a fresh new struct device instead. 971 * 972 * NOTE: _Never_ directly free @dev after calling this function, even 973 * if it returned an error! Always use put_device() to give up your 974 * reference instead. 975 */ 976 int device_add(struct device *dev) 977 { 978 struct device *parent = NULL; 979 struct kobject *kobj; 980 struct class_interface *class_intf; 981 int error = -EINVAL; 982 983 dev = get_device(dev); 984 if (!dev) 985 goto done; 986 987 if (!dev->p) { 988 error = device_private_init(dev); 989 if (error) 990 goto done; 991 } 992 993 /* 994 * for statically allocated devices, which should all be converted 995 * some day, we need to initialize the name. We prevent reading back 996 * the name, and force the use of dev_name() 997 */ 998 if (dev->init_name) { 999 dev_set_name(dev, "%s", dev->init_name); 1000 dev->init_name = NULL; 1001 } 1002 1003 /* subsystems can specify simple device enumeration */ 1004 if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 1005 dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 1006 1007 if (!dev_name(dev)) { 1008 error = -EINVAL; 1009 goto name_error; 1010 } 1011 1012 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1013 1014 parent = get_device(dev->parent); 1015 kobj = get_device_parent(dev, parent); 1016 if (kobj) 1017 dev->kobj.parent = kobj; 1018 1019 /* use parent numa_node */ 1020 if (parent) 1021 set_dev_node(dev, dev_to_node(parent)); 1022 1023 /* first, register with generic layer. */ 1024 /* we require the name to be set before, and pass NULL */ 1025 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 1026 if (error) 1027 goto Error; 1028 1029 /* notify platform of device entry */ 1030 if (platform_notify) 1031 platform_notify(dev); 1032 1033 error = device_create_file(dev, &dev_attr_uevent); 1034 if (error) 1035 goto attrError; 1036 1037 if (MAJOR(dev->devt)) { 1038 error = device_create_file(dev, &dev_attr_dev); 1039 if (error) 1040 goto ueventattrError; 1041 1042 error = device_create_sys_dev_entry(dev); 1043 if (error) 1044 goto devtattrError; 1045 1046 devtmpfs_create_node(dev); 1047 } 1048 1049 error = device_add_class_symlinks(dev); 1050 if (error) 1051 goto SymlinkError; 1052 error = device_add_attrs(dev); 1053 if (error) 1054 goto AttrsError; 1055 error = bus_add_device(dev); 1056 if (error) 1057 goto BusError; 1058 error = dpm_sysfs_add(dev); 1059 if (error) 1060 goto DPMError; 1061 device_pm_add(dev); 1062 1063 /* Notify clients of device addition. This call must come 1064 * after dpm_sysfs_add() and before kobject_uevent(). 1065 */ 1066 if (dev->bus) 1067 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1068 BUS_NOTIFY_ADD_DEVICE, dev); 1069 1070 kobject_uevent(&dev->kobj, KOBJ_ADD); 1071 bus_probe_device(dev); 1072 if (parent) 1073 klist_add_tail(&dev->p->knode_parent, 1074 &parent->p->klist_children); 1075 1076 if (dev->class) { 1077 mutex_lock(&dev->class->p->mutex); 1078 /* tie the class to the device */ 1079 klist_add_tail(&dev->knode_class, 1080 &dev->class->p->klist_devices); 1081 1082 /* notify any interfaces that the device is here */ 1083 list_for_each_entry(class_intf, 1084 &dev->class->p->interfaces, node) 1085 if (class_intf->add_dev) 1086 class_intf->add_dev(dev, class_intf); 1087 mutex_unlock(&dev->class->p->mutex); 1088 } 1089 done: 1090 put_device(dev); 1091 return error; 1092 DPMError: 1093 bus_remove_device(dev); 1094 BusError: 1095 device_remove_attrs(dev); 1096 AttrsError: 1097 device_remove_class_symlinks(dev); 1098 SymlinkError: 1099 if (MAJOR(dev->devt)) 1100 devtmpfs_delete_node(dev); 1101 if (MAJOR(dev->devt)) 1102 device_remove_sys_dev_entry(dev); 1103 devtattrError: 1104 if (MAJOR(dev->devt)) 1105 device_remove_file(dev, &dev_attr_dev); 1106 ueventattrError: 1107 device_remove_file(dev, &dev_attr_uevent); 1108 attrError: 1109 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1110 kobject_del(&dev->kobj); 1111 Error: 1112 cleanup_device_parent(dev); 1113 if (parent) 1114 put_device(parent); 1115 name_error: 1116 kfree(dev->p); 1117 dev->p = NULL; 1118 goto done; 1119 } 1120 EXPORT_SYMBOL_GPL(device_add); 1121 1122 /** 1123 * device_register - register a device with the system. 1124 * @dev: pointer to the device structure 1125 * 1126 * This happens in two clean steps - initialize the device 1127 * and add it to the system. The two steps can be called 1128 * separately, but this is the easiest and most common. 1129 * I.e. you should only call the two helpers separately if 1130 * have a clearly defined need to use and refcount the device 1131 * before it is added to the hierarchy. 1132 * 1133 * For more information, see the kerneldoc for device_initialize() 1134 * and device_add(). 1135 * 1136 * NOTE: _Never_ directly free @dev after calling this function, even 1137 * if it returned an error! Always use put_device() to give up the 1138 * reference initialized in this function instead. 1139 */ 1140 int device_register(struct device *dev) 1141 { 1142 device_initialize(dev); 1143 return device_add(dev); 1144 } 1145 EXPORT_SYMBOL_GPL(device_register); 1146 1147 /** 1148 * get_device - increment reference count for device. 1149 * @dev: device. 1150 * 1151 * This simply forwards the call to kobject_get(), though 1152 * we do take care to provide for the case that we get a NULL 1153 * pointer passed in. 1154 */ 1155 struct device *get_device(struct device *dev) 1156 { 1157 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 1158 } 1159 EXPORT_SYMBOL_GPL(get_device); 1160 1161 /** 1162 * put_device - decrement reference count. 1163 * @dev: device in question. 1164 */ 1165 void put_device(struct device *dev) 1166 { 1167 /* might_sleep(); */ 1168 if (dev) 1169 kobject_put(&dev->kobj); 1170 } 1171 EXPORT_SYMBOL_GPL(put_device); 1172 1173 /** 1174 * device_del - delete device from system. 1175 * @dev: device. 1176 * 1177 * This is the first part of the device unregistration 1178 * sequence. This removes the device from the lists we control 1179 * from here, has it removed from the other driver model 1180 * subsystems it was added to in device_add(), and removes it 1181 * from the kobject hierarchy. 1182 * 1183 * NOTE: this should be called manually _iff_ device_add() was 1184 * also called manually. 1185 */ 1186 void device_del(struct device *dev) 1187 { 1188 struct device *parent = dev->parent; 1189 struct class_interface *class_intf; 1190 1191 /* Notify clients of device removal. This call must come 1192 * before dpm_sysfs_remove(). 1193 */ 1194 if (dev->bus) 1195 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1196 BUS_NOTIFY_DEL_DEVICE, dev); 1197 dpm_sysfs_remove(dev); 1198 if (parent) 1199 klist_del(&dev->p->knode_parent); 1200 if (MAJOR(dev->devt)) { 1201 devtmpfs_delete_node(dev); 1202 device_remove_sys_dev_entry(dev); 1203 device_remove_file(dev, &dev_attr_dev); 1204 } 1205 if (dev->class) { 1206 device_remove_class_symlinks(dev); 1207 1208 mutex_lock(&dev->class->p->mutex); 1209 /* notify any interfaces that the device is now gone */ 1210 list_for_each_entry(class_intf, 1211 &dev->class->p->interfaces, node) 1212 if (class_intf->remove_dev) 1213 class_intf->remove_dev(dev, class_intf); 1214 /* remove the device from the class list */ 1215 klist_del(&dev->knode_class); 1216 mutex_unlock(&dev->class->p->mutex); 1217 } 1218 device_remove_file(dev, &dev_attr_uevent); 1219 device_remove_attrs(dev); 1220 bus_remove_device(dev); 1221 device_pm_remove(dev); 1222 driver_deferred_probe_del(dev); 1223 1224 /* Notify the platform of the removal, in case they 1225 * need to do anything... 1226 */ 1227 if (platform_notify_remove) 1228 platform_notify_remove(dev); 1229 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1230 cleanup_device_parent(dev); 1231 kobject_del(&dev->kobj); 1232 put_device(parent); 1233 } 1234 EXPORT_SYMBOL_GPL(device_del); 1235 1236 /** 1237 * device_unregister - unregister device from system. 1238 * @dev: device going away. 1239 * 1240 * We do this in two parts, like we do device_register(). First, 1241 * we remove it from all the subsystems with device_del(), then 1242 * we decrement the reference count via put_device(). If that 1243 * is the final reference count, the device will be cleaned up 1244 * via device_release() above. Otherwise, the structure will 1245 * stick around until the final reference to the device is dropped. 1246 */ 1247 void device_unregister(struct device *dev) 1248 { 1249 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1250 device_del(dev); 1251 put_device(dev); 1252 } 1253 EXPORT_SYMBOL_GPL(device_unregister); 1254 1255 static struct device *next_device(struct klist_iter *i) 1256 { 1257 struct klist_node *n = klist_next(i); 1258 struct device *dev = NULL; 1259 struct device_private *p; 1260 1261 if (n) { 1262 p = to_device_private_parent(n); 1263 dev = p->device; 1264 } 1265 return dev; 1266 } 1267 1268 /** 1269 * device_get_devnode - path of device node file 1270 * @dev: device 1271 * @mode: returned file access mode 1272 * @uid: returned file owner 1273 * @gid: returned file group 1274 * @tmp: possibly allocated string 1275 * 1276 * Return the relative path of a possible device node. 1277 * Non-default names may need to allocate a memory to compose 1278 * a name. This memory is returned in tmp and needs to be 1279 * freed by the caller. 1280 */ 1281 const char *device_get_devnode(struct device *dev, 1282 umode_t *mode, kuid_t *uid, kgid_t *gid, 1283 const char **tmp) 1284 { 1285 char *s; 1286 1287 *tmp = NULL; 1288 1289 /* the device type may provide a specific name */ 1290 if (dev->type && dev->type->devnode) 1291 *tmp = dev->type->devnode(dev, mode, uid, gid); 1292 if (*tmp) 1293 return *tmp; 1294 1295 /* the class may provide a specific name */ 1296 if (dev->class && dev->class->devnode) 1297 *tmp = dev->class->devnode(dev, mode); 1298 if (*tmp) 1299 return *tmp; 1300 1301 /* return name without allocation, tmp == NULL */ 1302 if (strchr(dev_name(dev), '!') == NULL) 1303 return dev_name(dev); 1304 1305 /* replace '!' in the name with '/' */ 1306 *tmp = kstrdup(dev_name(dev), GFP_KERNEL); 1307 if (!*tmp) 1308 return NULL; 1309 while ((s = strchr(*tmp, '!'))) 1310 s[0] = '/'; 1311 return *tmp; 1312 } 1313 1314 /** 1315 * device_for_each_child - device child iterator. 1316 * @parent: parent struct device. 1317 * @fn: function to be called for each device. 1318 * @data: data for the callback. 1319 * 1320 * Iterate over @parent's child devices, and call @fn for each, 1321 * passing it @data. 1322 * 1323 * We check the return of @fn each time. If it returns anything 1324 * other than 0, we break out and return that value. 1325 */ 1326 int device_for_each_child(struct device *parent, void *data, 1327 int (*fn)(struct device *dev, void *data)) 1328 { 1329 struct klist_iter i; 1330 struct device *child; 1331 int error = 0; 1332 1333 if (!parent->p) 1334 return 0; 1335 1336 klist_iter_init(&parent->p->klist_children, &i); 1337 while ((child = next_device(&i)) && !error) 1338 error = fn(child, data); 1339 klist_iter_exit(&i); 1340 return error; 1341 } 1342 EXPORT_SYMBOL_GPL(device_for_each_child); 1343 1344 /** 1345 * device_find_child - device iterator for locating a particular device. 1346 * @parent: parent struct device 1347 * @match: Callback function to check device 1348 * @data: Data to pass to match function 1349 * 1350 * This is similar to the device_for_each_child() function above, but it 1351 * returns a reference to a device that is 'found' for later use, as 1352 * determined by the @match callback. 1353 * 1354 * The callback should return 0 if the device doesn't match and non-zero 1355 * if it does. If the callback returns non-zero and a reference to the 1356 * current device can be obtained, this function will return to the caller 1357 * and not iterate over any more devices. 1358 * 1359 * NOTE: you will need to drop the reference with put_device() after use. 1360 */ 1361 struct device *device_find_child(struct device *parent, void *data, 1362 int (*match)(struct device *dev, void *data)) 1363 { 1364 struct klist_iter i; 1365 struct device *child; 1366 1367 if (!parent) 1368 return NULL; 1369 1370 klist_iter_init(&parent->p->klist_children, &i); 1371 while ((child = next_device(&i))) 1372 if (match(child, data) && get_device(child)) 1373 break; 1374 klist_iter_exit(&i); 1375 return child; 1376 } 1377 EXPORT_SYMBOL_GPL(device_find_child); 1378 1379 int __init devices_init(void) 1380 { 1381 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 1382 if (!devices_kset) 1383 return -ENOMEM; 1384 dev_kobj = kobject_create_and_add("dev", NULL); 1385 if (!dev_kobj) 1386 goto dev_kobj_err; 1387 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 1388 if (!sysfs_dev_block_kobj) 1389 goto block_kobj_err; 1390 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 1391 if (!sysfs_dev_char_kobj) 1392 goto char_kobj_err; 1393 1394 return 0; 1395 1396 char_kobj_err: 1397 kobject_put(sysfs_dev_block_kobj); 1398 block_kobj_err: 1399 kobject_put(dev_kobj); 1400 dev_kobj_err: 1401 kset_unregister(devices_kset); 1402 return -ENOMEM; 1403 } 1404 1405 static int device_check_offline(struct device *dev, void *not_used) 1406 { 1407 int ret; 1408 1409 ret = device_for_each_child(dev, NULL, device_check_offline); 1410 if (ret) 1411 return ret; 1412 1413 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 1414 } 1415 1416 /** 1417 * device_offline - Prepare the device for hot-removal. 1418 * @dev: Device to be put offline. 1419 * 1420 * Execute the device bus type's .offline() callback, if present, to prepare 1421 * the device for a subsequent hot-removal. If that succeeds, the device must 1422 * not be used until either it is removed or its bus type's .online() callback 1423 * is executed. 1424 * 1425 * Call under device_hotplug_lock. 1426 */ 1427 int device_offline(struct device *dev) 1428 { 1429 int ret; 1430 1431 if (dev->offline_disabled) 1432 return -EPERM; 1433 1434 ret = device_for_each_child(dev, NULL, device_check_offline); 1435 if (ret) 1436 return ret; 1437 1438 device_lock(dev); 1439 if (device_supports_offline(dev)) { 1440 if (dev->offline) { 1441 ret = 1; 1442 } else { 1443 ret = dev->bus->offline(dev); 1444 if (!ret) { 1445 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 1446 dev->offline = true; 1447 } 1448 } 1449 } 1450 device_unlock(dev); 1451 1452 return ret; 1453 } 1454 1455 /** 1456 * device_online - Put the device back online after successful device_offline(). 1457 * @dev: Device to be put back online. 1458 * 1459 * If device_offline() has been successfully executed for @dev, but the device 1460 * has not been removed subsequently, execute its bus type's .online() callback 1461 * to indicate that the device can be used again. 1462 * 1463 * Call under device_hotplug_lock. 1464 */ 1465 int device_online(struct device *dev) 1466 { 1467 int ret = 0; 1468 1469 device_lock(dev); 1470 if (device_supports_offline(dev)) { 1471 if (dev->offline) { 1472 ret = dev->bus->online(dev); 1473 if (!ret) { 1474 kobject_uevent(&dev->kobj, KOBJ_ONLINE); 1475 dev->offline = false; 1476 } 1477 } else { 1478 ret = 1; 1479 } 1480 } 1481 device_unlock(dev); 1482 1483 return ret; 1484 } 1485 1486 struct root_device { 1487 struct device dev; 1488 struct module *owner; 1489 }; 1490 1491 static inline struct root_device *to_root_device(struct device *d) 1492 { 1493 return container_of(d, struct root_device, dev); 1494 } 1495 1496 static void root_device_release(struct device *dev) 1497 { 1498 kfree(to_root_device(dev)); 1499 } 1500 1501 /** 1502 * __root_device_register - allocate and register a root device 1503 * @name: root device name 1504 * @owner: owner module of the root device, usually THIS_MODULE 1505 * 1506 * This function allocates a root device and registers it 1507 * using device_register(). In order to free the returned 1508 * device, use root_device_unregister(). 1509 * 1510 * Root devices are dummy devices which allow other devices 1511 * to be grouped under /sys/devices. Use this function to 1512 * allocate a root device and then use it as the parent of 1513 * any device which should appear under /sys/devices/{name} 1514 * 1515 * The /sys/devices/{name} directory will also contain a 1516 * 'module' symlink which points to the @owner directory 1517 * in sysfs. 1518 * 1519 * Returns &struct device pointer on success, or ERR_PTR() on error. 1520 * 1521 * Note: You probably want to use root_device_register(). 1522 */ 1523 struct device *__root_device_register(const char *name, struct module *owner) 1524 { 1525 struct root_device *root; 1526 int err = -ENOMEM; 1527 1528 root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 1529 if (!root) 1530 return ERR_PTR(err); 1531 1532 err = dev_set_name(&root->dev, "%s", name); 1533 if (err) { 1534 kfree(root); 1535 return ERR_PTR(err); 1536 } 1537 1538 root->dev.release = root_device_release; 1539 1540 err = device_register(&root->dev); 1541 if (err) { 1542 put_device(&root->dev); 1543 return ERR_PTR(err); 1544 } 1545 1546 #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 1547 if (owner) { 1548 struct module_kobject *mk = &owner->mkobj; 1549 1550 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 1551 if (err) { 1552 device_unregister(&root->dev); 1553 return ERR_PTR(err); 1554 } 1555 root->owner = owner; 1556 } 1557 #endif 1558 1559 return &root->dev; 1560 } 1561 EXPORT_SYMBOL_GPL(__root_device_register); 1562 1563 /** 1564 * root_device_unregister - unregister and free a root device 1565 * @dev: device going away 1566 * 1567 * This function unregisters and cleans up a device that was created by 1568 * root_device_register(). 1569 */ 1570 void root_device_unregister(struct device *dev) 1571 { 1572 struct root_device *root = to_root_device(dev); 1573 1574 if (root->owner) 1575 sysfs_remove_link(&root->dev.kobj, "module"); 1576 1577 device_unregister(dev); 1578 } 1579 EXPORT_SYMBOL_GPL(root_device_unregister); 1580 1581 1582 static void device_create_release(struct device *dev) 1583 { 1584 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1585 kfree(dev); 1586 } 1587 1588 static struct device * 1589 device_create_groups_vargs(struct class *class, struct device *parent, 1590 dev_t devt, void *drvdata, 1591 const struct attribute_group **groups, 1592 const char *fmt, va_list args) 1593 { 1594 struct device *dev = NULL; 1595 int retval = -ENODEV; 1596 1597 if (class == NULL || IS_ERR(class)) 1598 goto error; 1599 1600 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1601 if (!dev) { 1602 retval = -ENOMEM; 1603 goto error; 1604 } 1605 1606 dev->devt = devt; 1607 dev->class = class; 1608 dev->parent = parent; 1609 dev->groups = groups; 1610 dev->release = device_create_release; 1611 dev_set_drvdata(dev, drvdata); 1612 1613 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 1614 if (retval) 1615 goto error; 1616 1617 retval = device_register(dev); 1618 if (retval) 1619 goto error; 1620 1621 return dev; 1622 1623 error: 1624 put_device(dev); 1625 return ERR_PTR(retval); 1626 } 1627 1628 /** 1629 * device_create_vargs - creates a device and registers it with sysfs 1630 * @class: pointer to the struct class that this device should be registered to 1631 * @parent: pointer to the parent struct device of this new device, if any 1632 * @devt: the dev_t for the char device to be added 1633 * @drvdata: the data to be added to the device for callbacks 1634 * @fmt: string for the device's name 1635 * @args: va_list for the device's name 1636 * 1637 * This function can be used by char device classes. A struct device 1638 * will be created in sysfs, registered to the specified class. 1639 * 1640 * A "dev" file will be created, showing the dev_t for the device, if 1641 * the dev_t is not 0,0. 1642 * If a pointer to a parent struct device is passed in, the newly created 1643 * struct device will be a child of that device in sysfs. 1644 * The pointer to the struct device will be returned from the call. 1645 * Any further sysfs files that might be required can be created using this 1646 * pointer. 1647 * 1648 * Returns &struct device pointer on success, or ERR_PTR() on error. 1649 * 1650 * Note: the struct class passed to this function must have previously 1651 * been created with a call to class_create(). 1652 */ 1653 struct device *device_create_vargs(struct class *class, struct device *parent, 1654 dev_t devt, void *drvdata, const char *fmt, 1655 va_list args) 1656 { 1657 return device_create_groups_vargs(class, parent, devt, drvdata, NULL, 1658 fmt, args); 1659 } 1660 EXPORT_SYMBOL_GPL(device_create_vargs); 1661 1662 /** 1663 * device_create - creates a device and registers it with sysfs 1664 * @class: pointer to the struct class that this device should be registered to 1665 * @parent: pointer to the parent struct device of this new device, if any 1666 * @devt: the dev_t for the char device to be added 1667 * @drvdata: the data to be added to the device for callbacks 1668 * @fmt: string for the device's name 1669 * 1670 * This function can be used by char device classes. A struct device 1671 * will be created in sysfs, registered to the specified class. 1672 * 1673 * A "dev" file will be created, showing the dev_t for the device, if 1674 * the dev_t is not 0,0. 1675 * If a pointer to a parent struct device is passed in, the newly created 1676 * struct device will be a child of that device in sysfs. 1677 * The pointer to the struct device will be returned from the call. 1678 * Any further sysfs files that might be required can be created using this 1679 * pointer. 1680 * 1681 * Returns &struct device pointer on success, or ERR_PTR() on error. 1682 * 1683 * Note: the struct class passed to this function must have previously 1684 * been created with a call to class_create(). 1685 */ 1686 struct device *device_create(struct class *class, struct device *parent, 1687 dev_t devt, void *drvdata, const char *fmt, ...) 1688 { 1689 va_list vargs; 1690 struct device *dev; 1691 1692 va_start(vargs, fmt); 1693 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 1694 va_end(vargs); 1695 return dev; 1696 } 1697 EXPORT_SYMBOL_GPL(device_create); 1698 1699 /** 1700 * device_create_with_groups - creates a device and registers it with sysfs 1701 * @class: pointer to the struct class that this device should be registered to 1702 * @parent: pointer to the parent struct device of this new device, if any 1703 * @devt: the dev_t for the char device to be added 1704 * @drvdata: the data to be added to the device for callbacks 1705 * @groups: NULL-terminated list of attribute groups to be created 1706 * @fmt: string for the device's name 1707 * 1708 * This function can be used by char device classes. A struct device 1709 * will be created in sysfs, registered to the specified class. 1710 * Additional attributes specified in the groups parameter will also 1711 * be created automatically. 1712 * 1713 * A "dev" file will be created, showing the dev_t for the device, if 1714 * the dev_t is not 0,0. 1715 * If a pointer to a parent struct device is passed in, the newly created 1716 * struct device will be a child of that device in sysfs. 1717 * The pointer to the struct device will be returned from the call. 1718 * Any further sysfs files that might be required can be created using this 1719 * pointer. 1720 * 1721 * Returns &struct device pointer on success, or ERR_PTR() on error. 1722 * 1723 * Note: the struct class passed to this function must have previously 1724 * been created with a call to class_create(). 1725 */ 1726 struct device *device_create_with_groups(struct class *class, 1727 struct device *parent, dev_t devt, 1728 void *drvdata, 1729 const struct attribute_group **groups, 1730 const char *fmt, ...) 1731 { 1732 va_list vargs; 1733 struct device *dev; 1734 1735 va_start(vargs, fmt); 1736 dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 1737 fmt, vargs); 1738 va_end(vargs); 1739 return dev; 1740 } 1741 EXPORT_SYMBOL_GPL(device_create_with_groups); 1742 1743 static int __match_devt(struct device *dev, const void *data) 1744 { 1745 const dev_t *devt = data; 1746 1747 return dev->devt == *devt; 1748 } 1749 1750 /** 1751 * device_destroy - removes a device that was created with device_create() 1752 * @class: pointer to the struct class that this device was registered with 1753 * @devt: the dev_t of the device that was previously registered 1754 * 1755 * This call unregisters and cleans up a device that was created with a 1756 * call to device_create(). 1757 */ 1758 void device_destroy(struct class *class, dev_t devt) 1759 { 1760 struct device *dev; 1761 1762 dev = class_find_device(class, NULL, &devt, __match_devt); 1763 if (dev) { 1764 put_device(dev); 1765 device_unregister(dev); 1766 } 1767 } 1768 EXPORT_SYMBOL_GPL(device_destroy); 1769 1770 /** 1771 * device_rename - renames a device 1772 * @dev: the pointer to the struct device to be renamed 1773 * @new_name: the new name of the device 1774 * 1775 * It is the responsibility of the caller to provide mutual 1776 * exclusion between two different calls of device_rename 1777 * on the same device to ensure that new_name is valid and 1778 * won't conflict with other devices. 1779 * 1780 * Note: Don't call this function. Currently, the networking layer calls this 1781 * function, but that will change. The following text from Kay Sievers offers 1782 * some insight: 1783 * 1784 * Renaming devices is racy at many levels, symlinks and other stuff are not 1785 * replaced atomically, and you get a "move" uevent, but it's not easy to 1786 * connect the event to the old and new device. Device nodes are not renamed at 1787 * all, there isn't even support for that in the kernel now. 1788 * 1789 * In the meantime, during renaming, your target name might be taken by another 1790 * driver, creating conflicts. Or the old name is taken directly after you 1791 * renamed it -- then you get events for the same DEVPATH, before you even see 1792 * the "move" event. It's just a mess, and nothing new should ever rely on 1793 * kernel device renaming. Besides that, it's not even implemented now for 1794 * other things than (driver-core wise very simple) network devices. 1795 * 1796 * We are currently about to change network renaming in udev to completely 1797 * disallow renaming of devices in the same namespace as the kernel uses, 1798 * because we can't solve the problems properly, that arise with swapping names 1799 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 1800 * be allowed to some other name than eth[0-9]*, for the aforementioned 1801 * reasons. 1802 * 1803 * Make up a "real" name in the driver before you register anything, or add 1804 * some other attributes for userspace to find the device, or use udev to add 1805 * symlinks -- but never rename kernel devices later, it's a complete mess. We 1806 * don't even want to get into that and try to implement the missing pieces in 1807 * the core. We really have other pieces to fix in the driver core mess. :) 1808 */ 1809 int device_rename(struct device *dev, const char *new_name) 1810 { 1811 struct kobject *kobj = &dev->kobj; 1812 char *old_device_name = NULL; 1813 int error; 1814 1815 dev = get_device(dev); 1816 if (!dev) 1817 return -EINVAL; 1818 1819 dev_dbg(dev, "renaming to %s\n", new_name); 1820 1821 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 1822 if (!old_device_name) { 1823 error = -ENOMEM; 1824 goto out; 1825 } 1826 1827 if (dev->class) { 1828 error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 1829 kobj, old_device_name, 1830 new_name, kobject_namespace(kobj)); 1831 if (error) 1832 goto out; 1833 } 1834 1835 error = kobject_rename(kobj, new_name); 1836 if (error) 1837 goto out; 1838 1839 out: 1840 put_device(dev); 1841 1842 kfree(old_device_name); 1843 1844 return error; 1845 } 1846 EXPORT_SYMBOL_GPL(device_rename); 1847 1848 static int device_move_class_links(struct device *dev, 1849 struct device *old_parent, 1850 struct device *new_parent) 1851 { 1852 int error = 0; 1853 1854 if (old_parent) 1855 sysfs_remove_link(&dev->kobj, "device"); 1856 if (new_parent) 1857 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 1858 "device"); 1859 return error; 1860 } 1861 1862 /** 1863 * device_move - moves a device to a new parent 1864 * @dev: the pointer to the struct device to be moved 1865 * @new_parent: the new parent of the device (can by NULL) 1866 * @dpm_order: how to reorder the dpm_list 1867 */ 1868 int device_move(struct device *dev, struct device *new_parent, 1869 enum dpm_order dpm_order) 1870 { 1871 int error; 1872 struct device *old_parent; 1873 struct kobject *new_parent_kobj; 1874 1875 dev = get_device(dev); 1876 if (!dev) 1877 return -EINVAL; 1878 1879 device_pm_lock(); 1880 new_parent = get_device(new_parent); 1881 new_parent_kobj = get_device_parent(dev, new_parent); 1882 1883 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 1884 __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 1885 error = kobject_move(&dev->kobj, new_parent_kobj); 1886 if (error) { 1887 cleanup_glue_dir(dev, new_parent_kobj); 1888 put_device(new_parent); 1889 goto out; 1890 } 1891 old_parent = dev->parent; 1892 dev->parent = new_parent; 1893 if (old_parent) 1894 klist_remove(&dev->p->knode_parent); 1895 if (new_parent) { 1896 klist_add_tail(&dev->p->knode_parent, 1897 &new_parent->p->klist_children); 1898 set_dev_node(dev, dev_to_node(new_parent)); 1899 } 1900 1901 if (dev->class) { 1902 error = device_move_class_links(dev, old_parent, new_parent); 1903 if (error) { 1904 /* We ignore errors on cleanup since we're hosed anyway... */ 1905 device_move_class_links(dev, new_parent, old_parent); 1906 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 1907 if (new_parent) 1908 klist_remove(&dev->p->knode_parent); 1909 dev->parent = old_parent; 1910 if (old_parent) { 1911 klist_add_tail(&dev->p->knode_parent, 1912 &old_parent->p->klist_children); 1913 set_dev_node(dev, dev_to_node(old_parent)); 1914 } 1915 } 1916 cleanup_glue_dir(dev, new_parent_kobj); 1917 put_device(new_parent); 1918 goto out; 1919 } 1920 } 1921 switch (dpm_order) { 1922 case DPM_ORDER_NONE: 1923 break; 1924 case DPM_ORDER_DEV_AFTER_PARENT: 1925 device_pm_move_after(dev, new_parent); 1926 break; 1927 case DPM_ORDER_PARENT_BEFORE_DEV: 1928 device_pm_move_before(new_parent, dev); 1929 break; 1930 case DPM_ORDER_DEV_LAST: 1931 device_pm_move_last(dev); 1932 break; 1933 } 1934 1935 put_device(old_parent); 1936 out: 1937 device_pm_unlock(); 1938 put_device(dev); 1939 return error; 1940 } 1941 EXPORT_SYMBOL_GPL(device_move); 1942 1943 /** 1944 * device_shutdown - call ->shutdown() on each device to shutdown. 1945 */ 1946 void device_shutdown(void) 1947 { 1948 struct device *dev, *parent; 1949 1950 spin_lock(&devices_kset->list_lock); 1951 /* 1952 * Walk the devices list backward, shutting down each in turn. 1953 * Beware that device unplug events may also start pulling 1954 * devices offline, even as the system is shutting down. 1955 */ 1956 while (!list_empty(&devices_kset->list)) { 1957 dev = list_entry(devices_kset->list.prev, struct device, 1958 kobj.entry); 1959 1960 /* 1961 * hold reference count of device's parent to 1962 * prevent it from being freed because parent's 1963 * lock is to be held 1964 */ 1965 parent = get_device(dev->parent); 1966 get_device(dev); 1967 /* 1968 * Make sure the device is off the kset list, in the 1969 * event that dev->*->shutdown() doesn't remove it. 1970 */ 1971 list_del_init(&dev->kobj.entry); 1972 spin_unlock(&devices_kset->list_lock); 1973 1974 /* hold lock to avoid race with probe/release */ 1975 if (parent) 1976 device_lock(parent); 1977 device_lock(dev); 1978 1979 /* Don't allow any more runtime suspends */ 1980 pm_runtime_get_noresume(dev); 1981 pm_runtime_barrier(dev); 1982 1983 if (dev->bus && dev->bus->shutdown) { 1984 if (initcall_debug) 1985 dev_info(dev, "shutdown\n"); 1986 dev->bus->shutdown(dev); 1987 } else if (dev->driver && dev->driver->shutdown) { 1988 if (initcall_debug) 1989 dev_info(dev, "shutdown\n"); 1990 dev->driver->shutdown(dev); 1991 } 1992 1993 device_unlock(dev); 1994 if (parent) 1995 device_unlock(parent); 1996 1997 put_device(dev); 1998 put_device(parent); 1999 2000 spin_lock(&devices_kset->list_lock); 2001 } 2002 spin_unlock(&devices_kset->list_lock); 2003 async_synchronize_full(); 2004 } 2005 2006 /* 2007 * Device logging functions 2008 */ 2009 2010 #ifdef CONFIG_PRINTK 2011 static int 2012 create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 2013 { 2014 const char *subsys; 2015 size_t pos = 0; 2016 2017 if (dev->class) 2018 subsys = dev->class->name; 2019 else if (dev->bus) 2020 subsys = dev->bus->name; 2021 else 2022 return 0; 2023 2024 pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 2025 2026 /* 2027 * Add device identifier DEVICE=: 2028 * b12:8 block dev_t 2029 * c127:3 char dev_t 2030 * n8 netdev ifindex 2031 * +sound:card0 subsystem:devname 2032 */ 2033 if (MAJOR(dev->devt)) { 2034 char c; 2035 2036 if (strcmp(subsys, "block") == 0) 2037 c = 'b'; 2038 else 2039 c = 'c'; 2040 pos++; 2041 pos += snprintf(hdr + pos, hdrlen - pos, 2042 "DEVICE=%c%u:%u", 2043 c, MAJOR(dev->devt), MINOR(dev->devt)); 2044 } else if (strcmp(subsys, "net") == 0) { 2045 struct net_device *net = to_net_dev(dev); 2046 2047 pos++; 2048 pos += snprintf(hdr + pos, hdrlen - pos, 2049 "DEVICE=n%u", net->ifindex); 2050 } else { 2051 pos++; 2052 pos += snprintf(hdr + pos, hdrlen - pos, 2053 "DEVICE=+%s:%s", subsys, dev_name(dev)); 2054 } 2055 2056 return pos; 2057 } 2058 EXPORT_SYMBOL(create_syslog_header); 2059 2060 int dev_vprintk_emit(int level, const struct device *dev, 2061 const char *fmt, va_list args) 2062 { 2063 char hdr[128]; 2064 size_t hdrlen; 2065 2066 hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 2067 2068 return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 2069 } 2070 EXPORT_SYMBOL(dev_vprintk_emit); 2071 2072 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 2073 { 2074 va_list args; 2075 int r; 2076 2077 va_start(args, fmt); 2078 2079 r = dev_vprintk_emit(level, dev, fmt, args); 2080 2081 va_end(args); 2082 2083 return r; 2084 } 2085 EXPORT_SYMBOL(dev_printk_emit); 2086 2087 static int __dev_printk(const char *level, const struct device *dev, 2088 struct va_format *vaf) 2089 { 2090 if (!dev) 2091 return printk("%s(NULL device *): %pV", level, vaf); 2092 2093 return dev_printk_emit(level[1] - '0', dev, 2094 "%s %s: %pV", 2095 dev_driver_string(dev), dev_name(dev), vaf); 2096 } 2097 2098 int dev_printk(const char *level, const struct device *dev, 2099 const char *fmt, ...) 2100 { 2101 struct va_format vaf; 2102 va_list args; 2103 int r; 2104 2105 va_start(args, fmt); 2106 2107 vaf.fmt = fmt; 2108 vaf.va = &args; 2109 2110 r = __dev_printk(level, dev, &vaf); 2111 2112 va_end(args); 2113 2114 return r; 2115 } 2116 EXPORT_SYMBOL(dev_printk); 2117 2118 #define define_dev_printk_level(func, kern_level) \ 2119 int func(const struct device *dev, const char *fmt, ...) \ 2120 { \ 2121 struct va_format vaf; \ 2122 va_list args; \ 2123 int r; \ 2124 \ 2125 va_start(args, fmt); \ 2126 \ 2127 vaf.fmt = fmt; \ 2128 vaf.va = &args; \ 2129 \ 2130 r = __dev_printk(kern_level, dev, &vaf); \ 2131 \ 2132 va_end(args); \ 2133 \ 2134 return r; \ 2135 } \ 2136 EXPORT_SYMBOL(func); 2137 2138 define_dev_printk_level(dev_emerg, KERN_EMERG); 2139 define_dev_printk_level(dev_alert, KERN_ALERT); 2140 define_dev_printk_level(dev_crit, KERN_CRIT); 2141 define_dev_printk_level(dev_err, KERN_ERR); 2142 define_dev_printk_level(dev_warn, KERN_WARNING); 2143 define_dev_printk_level(dev_notice, KERN_NOTICE); 2144 define_dev_printk_level(_dev_info, KERN_INFO); 2145 2146 #endif 2147