struct device {struct device        *parent;struct device_private    *p;struct kobject kobj;const char        *init_name; /* initial name of the device */const struct device_type *type;struct mutex        mutex;    /* mutex to synchronize calls to* its driver.*/struct bus_type    *bus;        /* type of bus device is on */struct device_driver *driver;    /* which driver has allocated thisdevice */void        *platform_data;    /* Platform specific data, devicecore doesn't touch it */void        *driver_data;    /* Driver data, set and get withdev_set/get_drvdata */struct dev_links_info    links;struct dev_pm_info    power;struct dev_pm_domain    *pm_domain;#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAINstruct irq_domain    *msi_domain;
#endif
#ifdef CONFIG_PINCTRLstruct dev_pin_info    *pins;
#endif
#ifdef CONFIG_GENERIC_MSI_IRQstruct list_head    msi_list;
#endif#ifdef CONFIG_NUMAint        numa_node;    /* NUMA node this device is close to */
#endifconst struct dma_map_ops *dma_ops;u64        *dma_mask;    /* dma mask (if dma'able device) */u64        coherent_dma_mask;/* Like dma_mask, but foralloc_coherent mappings asnot all hardware supports64 bit addresses for consistentallocations such descriptors. */unsigned long    dma_pfn_offset;struct device_dma_parameters *dma_parms;struct list_head    dma_pools;    /* dma pools (if dma'ble) */struct dma_coherent_mem    *dma_mem; /* internal for coherent memoverride */
#ifdef CONFIG_DMA_CMAstruct cma *cma_area;        /* contiguous memory area for dmaallocations */
#endif/* arch specific additions */struct dev_archdata    archdata;struct device_node    *of_node; /* associated device tree node */struct fwnode_handle    *fwnode; /* firmware device node */dev_t            devt;    /* dev_t, creates the sysfs "dev" */u32            id;    /* device instance */spinlock_t        devres_lock;struct list_head    devres_head;struct klist_node    knode_class;struct class        *class;const struct attribute_group **groups;    /* optional groups */void    (*release)(struct device *dev);struct iommu_group    *iommu_group;struct iommu_fwspec    *iommu_fwspec;bool            offline_disabled:1;bool            offline:1;bool            of_node_reused:1;
};

struct device_private {struct klist klist_children;struct klist_node knode_parent;struct klist_node knode_driver;struct klist_node knode_bus;struct list_head deferred_probe;struct device *device;
};

struct device_type {const char *name;const struct attribute_group **groups;int (*uevent)(struct device *dev, struct kobj_uevent_env *env);char *(*devnode)(struct device *dev, umode_t *mode,kuid_t *uid, kgid_t *gid);void (*release)(struct device *dev);const struct dev_pm_ops *pm;
};

/* interface for exporting device attributes */
struct device_attribute {struct attribute    attr;ssize_t (*show)(struct device *dev, struct device_attribute *attr,char *buf);ssize_t (*store)(struct device *dev, struct device_attribute *attr,const char *buf, size_t count);
};

int __init devices_init(void)
{devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);///sys/devices目录if (!devices_kset)return -ENOMEM;dev_kobj = kobject_create_and_add("dev", NULL);///sys/dev目录if (!dev_kobj)goto dev_kobj_err;sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);///sys/dev/block目录if (!sysfs_dev_block_kobj)goto block_kobj_err;sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);///sys/dev/char目录if (!sysfs_dev_char_kobj)goto char_kobj_err;return 0;char_kobj_err:kobject_put(sysfs_dev_block_kobj);block_kobj_err:kobject_put(dev_kobj);dev_kobj_err:kset_unregister(devices_kset);return -ENOMEM;
}

#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,char *buf)
{struct device_attribute *dev_attr = to_dev_attr(attr);struct device *dev = kobj_to_dev(kobj);ssize_t ret = -EIO;if (dev_attr->show)ret = dev_attr->show(dev, dev_attr, buf);if (ret >= (ssize_t)PAGE_SIZE) {print_symbol("dev_attr_show: %s returned bad count\n",(unsigned long)dev_attr->show);}return ret;
}static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,const char *buf, size_t count)
{struct device_attribute *dev_attr = to_dev_attr(attr);struct device *dev = kobj_to_dev(kobj);ssize_t ret = -EIO;if (dev_attr->store)ret = dev_attr->store(dev, dev_attr, buf, count);return ret;
}static const struct sysfs_ops dev_sysfs_ops = {.show    = dev_attr_show,.store    = dev_attr_store,
};

static void device_release(struct kobject *kobj)
{struct device *dev = kobj_to_dev(kobj);struct device_private *p = dev->p;/** Some platform devices are driven without driver attached* and managed resources may have been acquired.  Make sure* all resources are released.** Drivers still can add resources into device after device* is deleted but alive, so release devres here to avoid* possible memory leak.*/devres_release_all(dev);if (dev->release)dev->release(dev);else if (dev->type && dev->type->release)dev->type->release(dev);else if (dev->class && dev->class->dev_release)dev->class->dev_release(dev);elseWARN(1, KERN_ERR "Device '%s' does not have a release() ""function, it is broken and must be fixed.\n",dev_name(dev));kfree(p);
}static const void *device_namespace(struct kobject *kobj)
{struct device *dev = kobj_to_dev(kobj);const void *ns = NULL;if (dev->class && dev->class->ns_type)ns = dev->class->namespace(dev);return ns;
}static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
{struct device *dev = kobj_to_dev(kobj);if (dev->class && dev->class->get_ownership)dev->class->get_ownership(dev, uid, gid);
}static struct kobj_type device_ktype = {.release    = device_release,.sysfs_ops    = &dev_sysfs_ops,.namespace    = device_namespace,.get_ownership    = device_get_ownership,
};

static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
{struct kobj_type *ktype = get_ktype(kobj);if (ktype == &device_ktype) {struct device *dev = kobj_to_dev(kobj);if (dev->bus)return 1;if (dev->class)return 1;}return 0;
}static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
{struct device *dev = kobj_to_dev(kobj);if (dev->bus)return dev->bus->name;if (dev->class)return dev->class->name;return NULL;
}static int dev_uevent(struct kset *kset, struct kobject *kobj,struct kobj_uevent_env *env)
{struct device *dev = kobj_to_dev(kobj);int retval = 0;/* add device node properties if present */if (MAJOR(dev->devt)) {const char *tmp;const char *name;umode_t mode = 0;kuid_t uid = GLOBAL_ROOT_UID;kgid_t gid = GLOBAL_ROOT_GID;add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);if (name) {add_uevent_var(env, "DEVNAME=%s", name);if (mode)add_uevent_var(env, "DEVMODE=%#o", mode & 0777);if (!uid_eq(uid, GLOBAL_ROOT_UID))add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid));if (!gid_eq(gid, GLOBAL_ROOT_GID))add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid));kfree(tmp);}}if (dev->type && dev->type->name)add_uevent_var(env, "DEVTYPE=%s", dev->type->name);if (dev->driver)add_uevent_var(env, "DRIVER=%s", dev->driver->name);/* Add common DT information about the device */of_device_uevent(dev, env);/* have the bus specific function add its stuff */if (dev->bus && dev->bus->uevent) {retval = dev->bus->uevent(dev, env);if (retval)pr_debug("device: '%s': %s: bus uevent() returned %d\n",dev_name(dev), __func__, retval);}/* have the class specific function add its stuff */if (dev->class && dev->class->dev_uevent) {retval = dev->class->dev_uevent(dev, env);if (retval)pr_debug("device: '%s': %s: class uevent() ""returned %d\n", dev_name(dev),__func__, retval);}/* have the device type specific function add its stuff */if (dev->type && dev->type->uevent) {retval = dev->type->uevent(dev, env);if (retval)pr_debug("device: '%s': %s: dev_type uevent() ""returned %d\n", dev_name(dev),__func__, retval);}return retval;
}static const struct kset_uevent_ops device_uevent_ops = {.filter =    dev_uevent_filter,.name =        dev_uevent_name,.uevent =    dev_uevent,
};

static ssize_t uevent_show(struct device *dev, struct device_attribute *attr,char *buf)
{struct kobject *top_kobj;struct kset *kset;struct kobj_uevent_env *env = NULL;int i;size_t count = 0;int retval;/* search the kset, the device belongs to */top_kobj = &dev->kobj;while (!top_kobj->kset && top_kobj->parent)top_kobj = top_kobj->parent;if (!top_kobj->kset)goto out;kset = top_kobj->kset;if (!kset->uevent_ops || !kset->uevent_ops->uevent)goto out;/* respect filter */if (kset->uevent_ops && kset->uevent_ops->filter)if (!kset->uevent_ops->filter(kset, &dev->kobj))goto out;env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);if (!env)return -ENOMEM;/* let the kset specific function add its keys */retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);if (retval)goto out;/* copy keys to file */for (i = 0; i < env->envp_idx; i++)count += sprintf(&buf[count], "%s\n", env->envp[i]);
out:kfree(env);return count;
}static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,const char *buf, size_t count)
{if (kobject_synth_uevent(&dev->kobj, buf, count))dev_err(dev, "uevent: failed to send synthetic uevent\n");return count;
}
static DEVICE_ATTR_RW(uevent);

static int device_add_attrs(struct device *dev)
{struct class *class = dev->class;const struct device_type *type = dev->type;int error;if (class) {error = device_add_groups(dev, class->dev_groups);if (error)return error;}if (type) {error = device_add_groups(dev, type->groups);if (error)goto err_remove_class_groups;}error = device_add_groups(dev, dev->groups);if (error)goto err_remove_type_groups;if (device_supports_offline(dev) && !dev->offline_disabled) {error = device_create_file(dev, &dev_attr_online);if (error)goto err_remove_dev_groups;}return 0;err_remove_dev_groups:device_remove_groups(dev, dev->groups);err_remove_type_groups:if (type)device_remove_groups(dev, type->groups);err_remove_class_groups:if (class)device_remove_groups(dev, class->dev_groups);return error;
}static void device_remove_attrs(struct device *dev)
{struct class *class = dev->class;const struct device_type *type = dev->type;device_remove_file(dev, &dev_attr_online);device_remove_groups(dev, dev->groups);if (type)device_remove_groups(dev, type->groups);if (class)device_remove_groups(dev, class->dev_groups);
}

static ssize_t dev_show(struct device *dev, struct device_attribute *attr,char *buf)
{return print_dev_t(buf, dev->devt);
}
static DEVICE_ATTR_RO(dev);

/*** device_create_file - create sysfs attribute file for device.* @dev: device.* @attr: device attribute descriptor.*/
int device_create_file(struct device *dev,const struct device_attribute *attr)
{int error = 0;if (dev) {WARN(((attr->attr.mode & S_IWUGO) && !attr->store),"Attribute %s: write permission without 'store'\n",attr->attr.name);WARN(((attr->attr.mode & S_IRUGO) && !attr->show),"Attribute %s: read permission without 'show'\n",attr->attr.name);error = sysfs_create_file(&dev->kobj, &attr->attr);}return error;
}/*** device_remove_file - remove sysfs attribute file.* @dev: device.* @attr: device attribute descriptor.*/
void device_remove_file(struct device *dev,const struct device_attribute *attr)
{if (dev)sysfs_remove_file(&dev->kobj, &attr->attr);
}/*** device_create_bin_file - create sysfs binary attribute file for device.* @dev: device.* @attr: device binary attribute descriptor.*/
int device_create_bin_file(struct device *dev,const struct bin_attribute *attr)
{int error = -EINVAL;if (dev)error = sysfs_create_bin_file(&dev->kobj, attr);return error;
}/*** device_remove_bin_file - remove sysfs binary attribute file* @dev: device.* @attr: device binary attribute descriptor.*/
void device_remove_bin_file(struct device *dev,const struct bin_attribute *attr)
{if (dev)sysfs_remove_bin_file(&dev->kobj, attr);
}

static void klist_children_get(struct klist_node *n)
{struct device_private *p = to_device_private_parent(n);struct device *dev = p->device;get_device(dev);
}static void klist_children_put(struct klist_node *n)
{struct device_private *p = to_device_private_parent(n);struct device *dev = p->device;put_device(dev);
}

/*** get_device - increment reference count for device.* @dev: device.** This simply forwards the call to kobject_get(), though* we do take care to provide for the case that we get a NULL* pointer passed in.*/
struct device *get_device(struct device *dev)
{return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
}/*** put_device - decrement reference count.* @dev: device in question.*/
void put_device(struct device *dev)
{/* might_sleep(); */if (dev)kobject_put(&dev->kobj);
}

void device_initialize(struct device *dev)
{dev->kobj.kset = devices_kset;kobject_init(&dev->kobj, &device_ktype);INIT_LIST_HEAD(&dev->dma_pools);mutex_init(&dev->mutex);lockdep_set_novalidate_class(&dev->mutex);spin_lock_init(&dev->devres_lock);INIT_LIST_HEAD(&dev->devres_head);device_pm_init(dev);set_dev_node(dev, -1);
#ifdef CONFIG_GENERIC_MSI_IRQINIT_LIST_HEAD(&dev->msi_list);
#endifINIT_LIST_HEAD(&dev->links.consumers);INIT_LIST_HEAD(&dev->links.suppliers);dev->links.status = DL_DEV_NO_DRIVER;
}

static struct kobject *get_device_parent(struct device *dev,struct device *parent)
{if (dev->class) {struct kobject *kobj = NULL;struct kobject *parent_kobj;struct kobject *k;#ifdef CONFIG_BLOCK/* block disks show up in /sys/block */if (sysfs_deprecated && dev->class == &block_class) {if (parent && parent->class == &block_class)return &parent->kobj;return &block_class.p->subsys.kobj;}
#endif/** If we have no parent, we live in "virtual".* Class-devices with a non class-device as parent, live* in a "glue" directory to prevent namespace collisions.*/if (parent == NULL)parent_kobj = virtual_device_parent(dev);else if (parent->class && !dev->class->ns_type)return &parent->kobj;elseparent_kobj = &parent->kobj;mutex_lock(&gdp_mutex);/* find our class-directory at the parent and reference it */spin_lock(&dev->class->p->glue_dirs.list_lock);list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)if (k->parent == parent_kobj) {kobj = kobject_get(k);break;}spin_unlock(&dev->class->p->glue_dirs.list_lock);if (kobj) {mutex_unlock(&gdp_mutex);return kobj;}/* or create a new class-directory at the parent device */k = class_dir_create_and_add(dev->class, parent_kobj);/* do not emit an uevent for this simple "glue" directory */mutex_unlock(&gdp_mutex);return k;}/* subsystems can specify a default root directory for their devices */if (!parent && dev->bus && dev->bus->dev_root)return &dev->bus->dev_root->kobj;if (parent)return &parent->kobj;return NULL;
}

static int device_add_class_symlinks(struct device *dev)
{struct device_node *of_node = dev_of_node(dev);int error;if (of_node) {error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node");if (error)dev_warn(dev, "Error %d creating of_node link\n",error);/* An error here doesn't warrant bringing down the device */}if (!dev->class)return 0;error = sysfs_create_link(&dev->kobj,&dev->class->p->subsys.kobj,"subsystem");if (error)goto out_devnode;if (dev->parent && device_is_not_partition(dev)) {error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,"device");if (error)goto out_subsys;}#ifdef CONFIG_BLOCK/* /sys/block has directories and does not need symlinks */if (sysfs_deprecated && dev->class == &block_class)return 0;
#endif/* link in the class directory pointing to the device */error = sysfs_create_link(&dev->class->p->subsys.kobj,&dev->kobj, dev_name(dev));if (error)goto out_device;return 0;out_device:sysfs_remove_link(&dev->kobj, "device");out_subsys:sysfs_remove_link(&dev->kobj, "subsystem");
out_devnode:sysfs_remove_link(&dev->kobj, "of_node");return error;
}

static void device_remove_class_symlinks(struct device *dev)
{if (dev_of_node(dev))sysfs_remove_link(&dev->kobj, "of_node");if (!dev->class)return;if (dev->parent && device_is_not_partition(dev))sysfs_remove_link(&dev->kobj, "device");sysfs_remove_link(&dev->kobj, "subsystem");
#ifdef CONFIG_BLOCKif (sysfs_deprecated && dev->class == &block_class)return;
#endifsysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
}

/*** dev_set_name - set a device name* @dev: device* @fmt: format string for the device's name*/
int dev_set_name(struct device *dev, const char *fmt, ...)
{va_list vargs;int err;va_start(vargs, fmt);err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);va_end(vargs);return err;
}

static struct kobject *device_to_dev_kobj(struct device *dev)
{struct kobject *kobj;if (dev->class)kobj = dev->class->dev_kobj;elsekobj = sysfs_dev_char_kobj;return kobj;
}

#define format_dev_t(buffer, dev)                    \({                                \sprintf(buffer, "%u:%u", MAJOR(dev), MINOR(dev));    \buffer;                            \})static int device_create_sys_dev_entry(struct device *dev)
{struct kobject *kobj = device_to_dev_kobj(dev);int error = 0;char devt_str[15];if (kobj) {format_dev_t(devt_str, dev->devt);error = sysfs_create_link(kobj, &dev->kobj, devt_str);}return error;
}static void device_remove_sys_dev_entry(struct device *dev)
{struct kobject *kobj = device_to_dev_kobj(dev);char devt_str[15];if (kobj) {format_dev_t(devt_str, dev->devt);sysfs_remove_link(kobj, devt_str);}
}

int device_private_init(struct device *dev)
{dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);if (!dev->p)return -ENOMEM;dev->p->device = dev;klist_init(&dev->p->klist_children, klist_children_get,klist_children_put);INIT_LIST_HEAD(&dev->p->deferred_probe);return 0;
}

/*** device_register - register a device with the system.* @dev: pointer to the device structure** This happens in two clean steps - initialize the device* and add it to the system. The two steps can be called* separately, but this is the easiest and most common.* I.e. you should only call the two helpers separately if* have a clearly defined need to use and refcount the device* before it is added to the hierarchy.** For more information, see the kerneldoc for device_initialize()* and device_add().** NOTE: _Never_ directly free @dev after calling this function, even* if it returned an error! Always use put_device() to give up the* reference initialized in this function instead.*/
int device_register(struct device *dev)
{device_initialize(dev);return device_add(dev);
}

/*** device_add - add device to device hierarchy.* @dev: device.** This is part 2 of device_register(), though may be called* separately _iff_ device_initialize() has been called separately.** This adds @dev to the kobject hierarchy via kobject_add(), adds it* to the global and sibling lists for the device, then* adds it to the other relevant subsystems of the driver model.** Do not call this routine or device_register() more than once for* any device structure.  The driver model core is not designed to work* with devices that get unregistered and then spring back to life.* (Among other things, it's very hard to guarantee that all references* to the previous incarnation of @dev have been dropped.)  Allocate* and register a fresh new struct device instead.** NOTE: _Never_ directly free @dev after calling this function, even* if it returned an error! Always use put_device() to give up your* reference instead.*/
int device_add(struct device *dev)
{struct device *parent;struct kobject *kobj;struct class_interface *class_intf;int error = -EINVAL;struct kobject *glue_dir = NULL;dev = get_device(dev);    //增加device的引用计数if (!dev)goto done;if (!dev->p) {error = device_private_init(dev);    //分配和初始化dev->pif (error)goto done;}/** for statically allocated devices, which should all be converted* some day, we need to initialize the name. We prevent reading back* the name, and force the use of dev_name()*/if (dev->init_name) {dev_set_name(dev, "%s", dev->init_name);    //设置设备的名称dev->init_name = NULL;}/* subsystems can specify simple device enumeration */if (!dev_name(dev) && dev->bus && dev->bus->dev_name)dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);if (!dev_name(dev)) {error = -EINVAL;goto name_error;}pr_debug("device: '%s': %s\n", dev_name(dev), __func__);parent = get_device(dev->parent);    //增加对parent的引用计数，无parent时返回NULLkobj = get_device_parent(dev, parent);    //获取父kobjectif (IS_ERR(kobj)) {error = PTR_ERR(kobj);goto parent_error;}if (kobj)dev->kobj.parent = kobj;    //设置dev->kobj的父kobject/* use parent numa_node */if (parent && (dev_to_node(dev) == NUMA_NO_NODE))set_dev_node(dev, dev_to_node(parent));/* first, register with generic layer. *//* we require the name to be set before, and pass NULL */error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);    //将device内嵌的kobj加入到kobject层次结构中if (error) {glue_dir = get_glue_dir(dev);goto Error;}/* notify platform of device entry */if (platform_notify)platform_notify(dev);error = device_create_file(dev, &dev_attr_uevent);    //添加uevent属性文件if (error)goto attrError;error = device_add_class_symlinks(dev);    //dev与class软链接创建if (error)goto SymlinkError;error = device_add_attrs(dev);    //添加属性if (error)goto AttrsError;error = bus_add_device(dev);    //将设备添加到总线上，创建dev与bus间的软链接if (error)goto BusError;error = dpm_sysfs_add(dev);        //增加dev下的power属性集合if (error)goto DPMError;device_pm_add(dev);if (MAJOR(dev->devt)) {        //主设备号存在error = device_create_file(dev, &dev_attr_dev);    //添加dev属性if (error)goto DevAttrError;error = device_create_sys_dev_entry(dev);    //在/sys/dev下添加相应的软链接if (error)goto SysEntryError;devtmpfs_create_node(dev);    //在/dev下添加相应的设备节点
    }/* Notify clients of device addition.  This call must come* after dpm_sysfs_add() and before kobject_uevent().*/if (dev->bus)blocking_notifier_call_chain(&dev->bus->p->bus_notifier,BUS_NOTIFY_ADD_DEVICE, dev);kobject_uevent(&dev->kobj, KOBJ_ADD);    //kobject发布KOBJ_ADD消息到用户空间bus_probe_device(dev);        //为device寻找合适的驱动if (parent)klist_add_tail(&dev->p->knode_parent,&parent->p->klist_children);    //如果父节点存在，将挂入到klist_children链表if (dev->class) {    //如果device所属的class存在mutex_lock(&dev->class->p->mutex);/* tie the class to the device */klist_add_tail(&dev->knode_class,&dev->class->p->klist_devices);    //节点插入链表/* notify any interfaces that the device is here */list_for_each_entry(class_intf,&dev->class->p->interfaces, node)if (class_intf->add_dev)class_intf->add_dev(dev, class_intf);mutex_unlock(&dev->class->p->mutex);}
done:put_device(dev);    //减少device的引用计数return error;SysEntryError:if (MAJOR(dev->devt))device_remove_file(dev, &dev_attr_dev);DevAttrError:device_pm_remove(dev);dpm_sysfs_remove(dev);DPMError:bus_remove_device(dev);BusError:device_remove_attrs(dev);AttrsError:device_remove_class_symlinks(dev);SymlinkError:device_remove_file(dev, &dev_attr_uevent);attrError:kobject_uevent(&dev->kobj, KOBJ_REMOVE);glue_dir = get_glue_dir(dev);kobject_del(&dev->kobj);Error:cleanup_glue_dir(dev, glue_dir);
parent_error:put_device(parent);
name_error:kfree(dev->p);dev->p = NULL;goto done;
}

/*** device_unregister - unregister device from system.* @dev: device going away.** We do this in two parts, like we do device_register(). First,* we remove it from all the subsystems with device_del(), then* we decrement the reference count via put_device(). If that* is the final reference count, the device will be cleaned up* via device_release() above. Otherwise, the structure will* stick around until the final reference to the device is dropped.*/
void device_unregister(struct device *dev)
{pr_debug("device: '%s': %s\n", dev_name(dev), __func__);device_del(dev);put_device(dev);
}

/*** device_del - delete device from system.* @dev: device.** This is the first part of the device unregistration* sequence. This removes the device from the lists we control* from here, has it removed from the other driver model* subsystems it was added to in device_add(), and removes it* from the kobject hierarchy.** NOTE: this should be called manually _iff_ device_add() was* also called manually.*/
void device_del(struct device *dev)
{struct device *parent = dev->parent;struct kobject *glue_dir = NULL;struct class_interface *class_intf;/* Notify clients of device removal.  This call must come* before dpm_sysfs_remove().*/if (dev->bus)blocking_notifier_call_chain(&dev->bus->p->bus_notifier,BUS_NOTIFY_DEL_DEVICE, dev);dpm_sysfs_remove(dev);    //将sysfs下的power属性集合移除if (parent)            //如果存在父节点klist_del(&dev->p->knode_parent);    //将设备节点从父节点链表中移除if (MAJOR(dev->devt)) {            //如果分配了主设备号devtmpfs_delete_node(dev);        //将/dev下的设备节点文件移除device_remove_sys_dev_entry(dev);    ///sys/dev下的软链接取消device_remove_file(dev, &dev_attr_dev);    //将属性文件移除
    }if (dev->class) {device_remove_class_symlinks(dev);mutex_lock(&dev->class->p->mutex);/* notify any interfaces that the device is now gone */list_for_each_entry(class_intf,&dev->class->p->interfaces, node)if (class_intf->remove_dev)class_intf->remove_dev(dev, class_intf);/* remove the device from the class list */klist_del(&dev->knode_class);mutex_unlock(&dev->class->p->mutex);}device_remove_file(dev, &dev_attr_uevent);    //移除uevent属性文件device_remove_attrs(dev);    //属性及属性集合移除bus_remove_device(dev);        //总线上移除设备device_pm_remove(dev);        //将dev从dpm_list中移除driver_deferred_probe_del(dev);        //驱动移除
    device_remove_properties(dev);device_links_purge(dev);/* Notify the platform of the removal, in case they* need to do anything...*/if (platform_notify_remove)platform_notify_remove(dev);if (dev->bus)blocking_notifier_call_chain(&dev->bus->p->bus_notifier,BUS_NOTIFY_REMOVED_DEVICE, dev);kobject_uevent(&dev->kobj, KOBJ_REMOVE);    //kobject发布KOBJ_REMOVE消息到用户空间glue_dir = get_glue_dir(dev);kobject_del(&dev->kobj);    //将内嵌的kobj从层次结构中移除
    cleanup_glue_dir(dev, glue_dir);put_device(parent);        //父节点引用计数减1操作
}

static struct device *prev_device(struct klist_iter *i)    //返回前一个设备
{struct klist_node *n = klist_prev(i);struct device *dev = NULL;struct device_private *p;if (n) {p = to_device_private_parent(n);//返回device_private结构体的首地址dev = p->device;//将struct device结构体地址返回
    }return dev;
}static struct device *next_device(struct klist_iter *i)
{struct klist_node *n = klist_next(i);struct device *dev = NULL;struct device_private *p;if (n) {p = to_device_private_parent(n);dev = p->device;}return dev;
}

/*** device_get_devnode - path of device node file* @dev: device* @mode: returned file access mode* @uid: returned file owner* @gid: returned file group* @tmp: possibly allocated string** Return the relative path of a possible device node.* Non-default names may need to allocate a memory to compose* a name. This memory is returned in tmp and needs to be* freed by the caller.*/
const char *device_get_devnode(struct device *dev,umode_t *mode, kuid_t *uid, kgid_t *gid,const char **tmp)
{char *s;*tmp = NULL;/* the device type may provide a specific name */if (dev->type && dev->type->devnode)*tmp = dev->type->devnode(dev, mode, uid, gid);if (*tmp)return *tmp;/* the class may provide a specific name */if (dev->class && dev->class->devnode)*tmp = dev->class->devnode(dev, mode);if (*tmp)return *tmp;/* return name without allocation, tmp == NULL */if (strchr(dev_name(dev), '!') == NULL)return dev_name(dev);/* replace '!' in the name with '/' */s = kstrdup(dev_name(dev), GFP_KERNEL);if (!s)return NULL;strreplace(s, '!', '/');return *tmp = s;
}

/*** device_for_each_child - device child iterator.* @parent: parent struct device.* @fn: function to be called for each device.* @data: data for the callback.** Iterate over @parent's child devices, and call @fn for each,* passing it @data.** We check the return of @fn each time. If it returns anything* other than 0, we break out and return that value.*/
int device_for_each_child(struct device *parent, void *data,int (*fn)(struct device *dev, void *data))
{struct klist_iter i;struct device *child;int error = 0;if (!parent->p)return 0;klist_iter_init(&parent->p->klist_children, &i);//迭代器初始化，从链表头开始while ((child = next_device(&i)) && !error)    //正序遍历klist_children链表error = fn(child, data);klist_iter_exit(&i);return error;
}int device_for_each_child_reverse(struct device *parent, void *data,int (*fn)(struct device *dev, void *data))
{struct klist_iter i;struct device *child;int error = 0;if (!parent->p)return 0;klist_iter_init(&parent->p->klist_children, &i);while ((child = prev_device(&i)) && !error)    //逆序遍历klist_children链表error = fn(child, data);klist_iter_exit(&i);return error;
}struct device *device_find_child(struct device *parent, void *data,int (*match)(struct device *dev, void *data))
{struct klist_iter i;struct device *child;if (!parent)return NULL;klist_iter_init(&parent->p->klist_children, &i);while ((child = next_device(&i)))if (match(child, data) && get_device(child))break;klist_iter_exit(&i);return child;
}

static void device_create_release(struct device *dev)
{pr_debug("device: '%s': %s\n", dev_name(dev), __func__);kfree(dev);
}static struct device *
device_create_groups_vargs(struct class *class, struct device *parent,dev_t devt, void *drvdata,const struct attribute_group **groups,const char *fmt, va_list args)
{struct device *dev = NULL;int retval = -ENODEV;if (class == NULL || IS_ERR(class))//判断class指针是否有效goto error;dev = kzalloc(sizeof(*dev), GFP_KERNEL);//为dev动态分配内存if (!dev) {retval = -ENOMEM;goto error;}device_initialize(dev);//设备初始化dev->devt = devt;dev->class = class;dev->parent = parent;dev->groups = groups;dev->release = device_create_release;dev_set_drvdata(dev, drvdata);retval = kobject_set_name_vargs(&dev->kobj, fmt, args);//设置kobject的nameif (retval)goto error;retval = device_add(dev);//将设备添加到sysfs层次系统if (retval)goto error;return dev;error:put_device(dev);return ERR_PTR(retval);//将异常指针返回
}/*** device_create_vargs - creates a device and registers it with sysfs* @class: pointer to the struct class that this device should be registered to* @parent: pointer to the parent struct device of this new device, if any* @devt: the dev_t for the char device to be added* @drvdata: the data to be added to the device for callbacks* @fmt: string for the device's name* @args: va_list for the device's name** This function can be used by char device classes.  A struct device* will be created in sysfs, registered to the specified class.** A "dev" file will be created, showing the dev_t for the device, if* the dev_t is not 0,0.* If a pointer to a parent struct device is passed in, the newly created* struct device will be a child of that device in sysfs.* The pointer to the struct device will be returned from the call.* Any further sysfs files that might be required can be created using this* pointer.** Returns &struct device pointer on success, or ERR_PTR() on error.** Note: the struct class passed to this function must have previously* been created with a call to class_create().*/
struct device *device_create_vargs(struct class *class, struct device *parent,dev_t devt, void *drvdata, const char *fmt,va_list args)
{return device_create_groups_vargs(class, parent, devt, drvdata, NULL,fmt, args);
}struct device *device_create(struct class *class, struct device *parent,dev_t devt, void *drvdata, const char *fmt, ...)
{va_list vargs;struct device *dev;va_start(vargs, fmt);dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);va_end(vargs);return dev;
}struct device *device_create_with_groups(struct class *class,struct device *parent, dev_t devt,void *drvdata,const struct attribute_group **groups,const char *fmt, ...)
{va_list vargs;struct device *dev;va_start(vargs, fmt);dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,fmt, vargs);va_end(vargs);return dev;
}

static int __match_devt(struct device *dev, const void *data)
{const dev_t *devt = data;return dev->devt == *devt;//设备号匹配
}/*** device_destroy - removes a device that was created with device_create()* @class: pointer to the struct class that this device was registered with* @devt: the dev_t of the device that was previously registered** This call unregisters and cleans up a device that was created with a* call to device_create().*/
void device_destroy(struct class *class, dev_t devt)
{struct device *dev;dev = class_find_device(class, NULL, &devt, __match_devt);//在class下寻找设备if (dev) {put_device(dev);//减少引用计数device_unregister(dev);//注销设备
    }
}

int device_rename(struct device *dev, const char *new_name)
{struct kobject *kobj = &dev->kobj;char *old_device_name = NULL;int error;dev = get_device(dev);if (!dev)return -EINVAL;dev_dbg(dev, "renaming to %s\n", new_name);old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);if (!old_device_name) {error = -ENOMEM;goto out;}if (dev->class) {error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj,kobj, old_device_name,new_name, kobject_namespace(kobj));if (error)goto out;}error = kobject_rename(kobj, new_name);if (error)goto out;out:put_device(dev);kfree(old_device_name);return error;
}

/*** device_shutdown - call ->shutdown() on each device to shutdown.*/
void device_shutdown(void)
{struct device *dev, *parent;spin_lock(&devices_kset->list_lock);/** Walk the devices list backward, shutting down each in turn.* Beware that device unplug events may also start pulling* devices offline, even as the system is shutting down.*/while (!list_empty(&devices_kset->list)) {dev = list_entry(devices_kset->list.prev, struct device,kobj.entry);/** hold reference count of device's parent to* prevent it from being freed because parent's* lock is to be held*/parent = get_device(dev->parent);get_device(dev);/** Make sure the device is off the kset list, in the* event that dev->*->shutdown() doesn't remove it.*/list_del_init(&dev->kobj.entry);spin_unlock(&devices_kset->list_lock);/* hold lock to avoid race with probe/release */if (parent)device_lock(parent);device_lock(dev);/* Don't allow any more runtime suspends */pm_runtime_get_noresume(dev);pm_runtime_barrier(dev);if (dev->class && dev->class->shutdown_pre) {if (initcall_debug)dev_info(dev, "shutdown_pre\n");dev->class->shutdown_pre(dev);}if (dev->bus && dev->bus->shutdown) {if (initcall_debug)dev_info(dev, "shutdown\n");dev->bus->shutdown(dev);} else if (dev->driver && dev->driver->shutdown) {if (initcall_debug)dev_info(dev, "shutdown\n");dev->driver->shutdown(dev);}device_unlock(dev);if (parent)device_unlock(parent);put_device(dev);put_device(parent);spin_lock(&devices_kset->list_lock);}spin_unlock(&devices_kset->list_lock);
}