linux/drivers/base/core.c
<<
>>
Prefs
   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
  36long sysfs_deprecated = 1;
  37#else
  38long sysfs_deprecated = 0;
  39#endif
  40static int __init sysfs_deprecated_setup(char *arg)
  41{
  42        return kstrtol(arg, 10, &sysfs_deprecated);
  43}
  44early_param("sysfs.deprecated", sysfs_deprecated_setup);
  45#endif
  46
  47int (*platform_notify)(struct device *dev) = NULL;
  48int (*platform_notify_remove)(struct device *dev) = NULL;
  49static struct kobject *dev_kobj;
  50struct kobject *sysfs_dev_char_kobj;
  51struct kobject *sysfs_dev_block_kobj;
  52
  53static DEFINE_MUTEX(device_hotplug_lock);
  54
  55void lock_device_hotplug(void)
  56{
  57        mutex_lock(&device_hotplug_lock);
  58}
  59
  60void unlock_device_hotplug(void)
  61{
  62        mutex_unlock(&device_hotplug_lock);
  63}
  64
  65int 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
  76static inline int device_is_not_partition(struct device *dev)
  77{
  78        return !(dev->type == &part_type);
  79}
  80#else
  81static 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 */
  96const 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}
 109EXPORT_SYMBOL(dev_driver_string);
 110
 111#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
 112
 113static 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
 129static 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
 141static 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
 148ssize_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}
 161EXPORT_SYMBOL_GPL(device_store_ulong);
 162
 163ssize_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}
 170EXPORT_SYMBOL_GPL(device_show_ulong);
 171
 172ssize_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}
 185EXPORT_SYMBOL_GPL(device_store_int);
 186
 187ssize_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}
 195EXPORT_SYMBOL_GPL(device_show_int);
 196
 197ssize_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}
 207EXPORT_SYMBOL_GPL(device_store_bool);
 208
 209ssize_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}
 216EXPORT_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 */
 226static 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
 255static 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
 266static struct kobj_type device_ktype = {
 267        .release        = device_release,
 268        .sysfs_ops      = &dev_sysfs_ops,
 269        .namespace      = device_namespace,
 270};
 271
 272
 273static 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
 287static 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
 298static 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
 365static const struct kset_uevent_ops device_uevent_ops = {
 366        .filter =       dev_uevent_filter,
 367        .name =         dev_uevent_name,
 368        .uevent =       dev_uevent,
 369};
 370
 371static 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]);
 409out:
 410        kfree(env);
 411        return count;
 412}
 413
 414static 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}
 425static DEVICE_ATTR_RW(uevent);
 426
 427static 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
 438static 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}
 456static DEVICE_ATTR_RW(online);
 457
 458int device_add_groups(struct device *dev, const struct attribute_group **groups)
 459{
 460        return sysfs_create_groups(&dev->kobj, groups);
 461}
 462
 463void device_remove_groups(struct device *dev,
 464                          const struct attribute_group **groups)
 465{
 466        sysfs_remove_groups(&dev->kobj, groups);
 467}
 468
 469static 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
 509static 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
 524static ssize_t dev_show(struct device *dev, struct device_attribute *attr,
 525                        char *buf)
 526{
 527        return print_dev_t(buf, dev->devt);
 528}
 529static DEVICE_ATTR_RO(dev);
 530
 531/* /sys/devices/ */
 532struct kset *devices_kset;
 533
 534/**
 535 * device_create_file - create sysfs attribute file for device.
 536 * @dev: device.
 537 * @attr: device attribute descriptor.
 538 */
 539int 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}
 556EXPORT_SYMBOL_GPL(device_create_file);
 557
 558/**
 559 * device_remove_file - remove sysfs attribute file.
 560 * @dev: device.
 561 * @attr: device attribute descriptor.
 562 */
 563void 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}
 569EXPORT_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 */
 576int 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}
 584EXPORT_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 */
 591void 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}
 597EXPORT_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 */
 624int 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}
 630EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
 631
 632static 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
 640static 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 */
 668void 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}
 680EXPORT_SYMBOL_GPL(device_initialize);
 681
 682struct 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
 693struct 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
 700static void class_dir_release(struct kobject *kobj)
 701{
 702        struct class_dir *dir = to_class_dir(kobj);
 703        kfree(dir);
 704}
 705
 706static const
 707struct 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
 713static 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
 719static struct kobject *
 720class_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
 743static 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
 804static 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
 814static void cleanup_device_parent(struct device *dev)
 815{
 816        cleanup_glue_dir(dev, dev->kobj.parent);
 817}
 818
 819static 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
 853out_device:
 854        sysfs_remove_link(&dev->kobj, "device");
 855
 856out_subsys:
 857        sysfs_remove_link(&dev->kobj, "subsystem");
 858out:
 859        return error;
 860}
 861
 862static 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 */
 882int 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}
 892EXPORT_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 */
 905static 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
 917static 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
 931static 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
 942int 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 */
 976int 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        }
1089done:
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);
1115name_error:
1116        kfree(dev->p);
1117        dev->p = NULL;
1118        goto done;
1119}
1120EXPORT_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 */
1140int device_register(struct device *dev)
1141{
1142        device_initialize(dev);
1143        return device_add(dev);
1144}
1145EXPORT_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 */
1155struct device *get_device(struct device *dev)
1156{
1157        return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
1158}
1159EXPORT_SYMBOL_GPL(get_device);
1160
1161/**
1162 * put_device - decrement reference count.
1163 * @dev: device in question.
1164 */
1165void put_device(struct device *dev)
1166{
1167        /* might_sleep(); */
1168        if (dev)
1169                kobject_put(&dev->kobj);
1170}
1171EXPORT_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 */
1186void 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}
1234EXPORT_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 */
1247void 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}
1253EXPORT_SYMBOL_GPL(device_unregister);
1254
1255static 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 */
1281const 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 */
1326int 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}
1342EXPORT_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 */
1361struct 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}
1377EXPORT_SYMBOL_GPL(device_find_child);
1378
1379int __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
1405static 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 */
1427int 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 */
1465int 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
1486struct root_device {
1487        struct device dev;
1488        struct module *owner;
1489};
1490
1491static inline struct root_device *to_root_device(struct device *d)
1492{
1493        return container_of(d, struct root_device, dev);
1494}
1495
1496static 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 */
1523struct 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}
1561EXPORT_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 */
1570void 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}
1579EXPORT_SYMBOL_GPL(root_device_unregister);
1580
1581
1582static void device_create_release(struct device *dev)
1583{
1584        pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1585        kfree(dev);
1586}
1587
1588static struct device *
1589device_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
1623error:
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 */
1653struct 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}
1660EXPORT_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 */
1686struct 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}
1697EXPORT_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 */
1726struct 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}
1741EXPORT_SYMBOL_GPL(device_create_with_groups);
1742
1743static 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 */
1758void 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}
1768EXPORT_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 */
1809int 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
1839out:
1840        put_device(dev);
1841
1842        kfree(old_device_name);
1843
1844        return error;
1845}
1846EXPORT_SYMBOL_GPL(device_rename);
1847
1848static 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 */
1868int 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);
1936out:
1937        device_pm_unlock();
1938        put_device(dev);
1939        return error;
1940}
1941EXPORT_SYMBOL_GPL(device_move);
1942
1943/**
1944 * device_shutdown - call ->shutdown() on each device to shutdown.
1945 */
1946void 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
2011static int
2012create_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}
2058EXPORT_SYMBOL(create_syslog_header);
2059
2060int 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}
2070EXPORT_SYMBOL(dev_vprintk_emit);
2071
2072int 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}
2085EXPORT_SYMBOL(dev_printk_emit);
2086
2087static 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
2098int 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}
2116EXPORT_SYMBOL(dev_printk);
2117
2118#define define_dev_printk_level(func, kern_level)               \
2119int 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}                                                               \
2136EXPORT_SYMBOL(func);
2137
2138define_dev_printk_level(dev_emerg, KERN_EMERG);
2139define_dev_printk_level(dev_alert, KERN_ALERT);
2140define_dev_printk_level(dev_crit, KERN_CRIT);
2141define_dev_printk_level(dev_err, KERN_ERR);
2142define_dev_printk_level(dev_warn, KERN_WARNING);
2143define_dev_printk_level(dev_notice, KERN_NOTICE);
2144define_dev_printk_level(_dev_info, KERN_INFO);
2145
2146#endif
2147