zoukankan      html  css  js  c++  java

  • linux driver module

    本文将对Linux系统中的sysfs进行简单的分析，要分析sysfs就必须分析内核的driver-model（驱动模型），两者是紧密联系的。在分析过程中，本文将以platform总线和spi主控制器的platform驱动为例来进行讲解。其实，platform机制是基于driver-model的，通过本文，也会对platform机制有个简单的了解。

    内核版本：2.6.30

    1. What is sysfs？

      个人理解：sysfs向用户空间展示了驱动设备的层次结构。我们都知道设备和对应的驱动都是由内核管理的，这些对于用户空间是不可见的。现在通过sysfs，可以在用户空间直观的了解设备驱动的层次结构。

      我们来看看sysfs的文件结构：

    [root@yj423 /sys]#ls
    block     class     devices   fs        module
    bus       dev       firmware  kernel    power

    block：块设备

    bus：系统中的总线

    class： 设备类型，比如输入设备

    dev：系统中已注册的设备节点的视图,有两个子目录char和block。

    devices：系统中所有设备拓扑结构视图

    fireware：固件

    fs：文件系统

    kernel：内核配置选项和状态信息

    module：模块

    power：系统的电源管理数据

    2. kobject ,kset和ktype

      要分析sysfs，首先就要分析kobject和kset，因为驱动设备的层次结构的构成就是由这两个东东来完成的。

    2.1 kobject

      kobject是一个对象的抽象，它用于管理对象。每个kobject对应着sysfs中的一个目录。

      kobject用struct kobject来描述。

    1. struct kobject {  
    2.     const char        *name;            /*在sysfs建立目录的名字*/  
    3.     struct list_head    entry;        /*用于连接到所属kset的链表中*/  
    4.     struct kobject        *parent;    /*父对象*/  
    5.     struct kset        *kset;            /*属于哪个kset*/  
    6.     struct kobj_type    *ktype;        /*类型*/  
    7.     struct sysfs_dirent    *sd;        /*sysfs中与该对象对应的文件节点*/  
    8.     struct kref        kref;            /*对象的应用计数*/  
    9.     unsigned int state_initialized:1;  
    10.     unsigned int state_in_sysfs:1;  
    11.     unsigned int state_add_uevent_sent:1;  
    12.     unsigned int state_remove_uevent_sent:1;  
    13.     unsigned int uevent_suppress:1;  
    14. };  

    2.2 kset

      kset是一些kobject的集合，这些kobject可以有相同的ktype，也可以不同。同时，kset自己也包含一个kobject。在sysfs中，kset也是对应这一个目录，但是目录下面包含着其他的kojbect。

      kset使用struct kset来描述。

    1. /** 
    2.  * struct kset - a set of kobjects of a specific type, belonging to a specific subsystem. 
    3.  * 
    4.  * A kset defines a group of kobjects.  They can be individually 
    5.  * different "types" but overall these kobjects all want to be grouped 
    6.  * together and operated on in the same manner.  ksets are used to 
    7.  * define the attribute callbacks and other common events that happen to 
    8.  * a kobject. 
    9.  * 
    10.  * @list: the list of all kobjects for this kset 
    11.  * @list_lock: a lock for iterating over the kobjects 
    12.  * @kobj: the embedded kobject for this kset (recursion, isn't it fun...) 
    13.  * @uevent_ops: the set of uevent operations for this kset.  These are 
    14.  * called whenever a kobject has something happen to it so that the kset 
    15.  * can add new environment variables, or filter out the uevents if so 
    16.  * desired. 
    17.  */  
    18. struct kset {  
    19.     struct list_head list;      /*属于该kset的kobject链表*/  
    20.     spinlock_t list_lock;     
    21.     struct kobject kobj;    /*该kset内嵌的kobj*/  
    22.   
    23.     struct kset_uevent_ops *uevent_ops;  
    24. };  

    2.3 ktype

    每个kobject对象都内嵌有一个ktype，该结构定义了kobject在创建和删除时所采取的行为。

    1. struct kobj_type {  
    2.     void (*release)(struct kobject *kobj);  
    3.     struct sysfs_ops *sysfs_ops;  
    4.     struct attribute **default_attrs;  
    5. };  
    6.   
    7. struct sysfs_ops {  
    8.     ssize_t    (*show)(struct kobject *, struct attribute *,char *);  
    9.     ssize_t    (*store)(struct kobject *,struct attribute *,const char *, size_t);  
    10. };  
    11.   
    12. /* FIXME 
    13.  * The *owner field is no longer used. 
    14.  * x86 tree has been cleaned up. The owner 
    15.  * attribute is still left for other arches. 
    16.  */  
    17. struct attribute {  
    18.     const char        *name;  
    19.     struct module        *owner;  
    20.     mode_t            mode;  
    21. };  

    当kobject的引用计数为0时，通过release方法来释放相关的资源。

    attribute为属性，每个属性在sysfs中都有对应的属性文件。

    sysfs_op的两个方法用于实现读取和写入属性文件时应该采取的行为。

    2.4 kobject与kset的关系

      下面这张图非常经典。最下面的kobj都属于一个kset，同时这些kobj的父对象就是kset内嵌的kobj。通过链表，kset可以获取所有属于它的kobj。

       从sysfs角度而言，kset代表一个文件夹，而下面的kobj就是这个文件夹里面的内容，而内容有可能是文件也有可能是文件夹。

    3.举例

    在上一节中，我们知道sys下有一个bus目录，这一将分析如何通过kobject创建bus目录。

    下面代码位于drivers/base/bus.c

    1. int __init buses_init(void)  
    2. {  
    3.     bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);  
    4.     if (!bus_kset)  
    5.         return -ENOMEM;  
    6.     return 0;  
    7. }  
    8.   
    9. static struct kset_uevent_ops bus_uevent_ops = {  
    10.     .filter = bus_uevent_filter,  
    11. };  
    12.   
    13. static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)  
    14. {  
    15.     struct kobj_type *ktype = get_ktype(kobj);  
    16.   
    17.     if (ktype == &bus_ktype)  
    18.         return 1;  
    19.     return 0;  
    20. }  

    这里直接调用kset_create_and_add，第一个参数为要创建的目录的名字，而第三个参数表示没有父对象。

    下面代码位于drivers/base/kobject.c

    1. /** 
    2.  * kset_create_and_add - create a struct kset dynamically and add it to sysfs 
    3.  * 
    4.  * @name: the name for the kset 
    5.  * @uevent_ops: a struct kset_uevent_ops for the kset 
    6.  * @parent_kobj: the parent kobject of this kset, if any. 
    7.  * 
    8.  * This function creates a kset structure dynamically and registers it 
    9.  * with sysfs.  When you are finished with this structure, call 
    10.  * kset_unregister() and the structure will be dynamically freed when it 
    11.  * is no longer being used. 
    12.  * 
    13.  * If the kset was not able to be created, NULL will be returned. 
    14.  */  
    15. struct kset *kset_create_and_add(const char *name,  
    16.                  struct kset_uevent_ops *uevent_ops,  
    17.                  struct kobject *parent_kobj)  
    18. {  
    19.     struct kset *kset;  
    20.     int error;  
    21.   
    22.     kset = kset_create(name, uevent_ops, parent_kobj);  /*建立kset，设置某些字段*/  
    23.     if (!kset)  
    24.         return NULL;  
    25.     error = kset_register(kset);    /*添加kset到sysfs*/  
    26.     if (error) {  
    27.         kfree(kset);  
    28.         return NULL;  
    29.     }  
    30.     return kset;  
    31. }  

    这里主要调用了两个函数，接下分别来看下。

    3.1 kset_create函数

    下面代码位于drivers/base/kobject.c

    1. /** 
    2.  * kset_create - create a struct kset dynamically 
    3.  * 
    4.  * @name: the name for the kset 
    5.  * @uevent_ops: a struct kset_uevent_ops for the kset 
    6.  * @parent_kobj: the parent kobject of this kset, if any. 
    7.  * 
    8.  * This function creates a kset structure dynamically.  This structure can 
    9.  * then be registered with the system and show up in sysfs with a call to 
    10.  * kset_register().  When you are finished with this structure, if 
    11.  * kset_register() has been called, call kset_unregister() and the 
    12.  * structure will be dynamically freed when it is no longer being used. 
    13.  * 
    14.  * If the kset was not able to be created, NULL will be returned. 
    15.  */  
    16. static struct kset *kset_create(const char *name,  
    17.                 struct kset_uevent_ops *uevent_ops,  
    18.                 struct kobject *parent_kobj)  
    19. {  
    20.     struct kset *kset;  
    21.   
    22.     kset = kzalloc(sizeof(*kset), GFP_KERNEL);/*分配kset*/  
    23.     if (!kset)  
    24.         return NULL;  
    25.     kobject_set_name(&kset->kobj, name);/*设置kobj->name*/  
    26.     kset->uevent_ops = uevent_ops;  
    27.     kset->kobj.parent = parent_kobj; /*设置父对象*/  
    28.   
    29.     /* 
    30.      * The kobject of this kset will have a type of kset_ktype and belong to 
    31.      * no kset itself.  That way we can properly free it when it is 
    32.      * finished being used. 
    33.      */  
    34.     kset->kobj.ktype = &kset_ktype;  
    35.     kset->kobj.kset = NULL;          /*本keset不属于任何kset*/  
    36.   
    37.     return kset;  
    38. }  

    这个函数中，动态分配了kset结构，调用kobject_set_name设置kset->kobj->name为bus，也就是我们要创建的目录bus。同时这里kset->kobj.parent为NULL，

    也就是没有父对象。因为要创建的bus目录是在sysfs所在的根目录创建的，自然没有父对象。

    随后简要看下由kobject_set_name函数调用引发的一系列调用。

    1. /** 
    2.  * kobject_set_name - Set the name of a kobject 
    3.  * @kobj: struct kobject to set the name of 
    4.  * @fmt: format string used to build the name 
    5.  * 
    6.  * This sets the name of the kobject.  If you have already added the 
    7.  * kobject to the system, you must call kobject_rename() in order to 
    8.  * change the name of the kobject. 
    9.  */  
    10. int kobject_set_name(struct kobject *kobj, const char *fmt, ...)  
    11. {  
    12.     va_list vargs;  
    13.     int retval;  
    14.   
    15.     va_start(vargs, fmt);  
    16.     retval = kobject_set_name_vargs(kobj, fmt, vargs);  
    17.     va_end(vargs);  
    18.   
    19.     return retval;  
    20. }  
    21.   
    22. /** 
    23.  * kobject_set_name_vargs - Set the name of an kobject 
    24.  * @kobj: struct kobject to set the name of 
    25.  * @fmt: format string used to build the name 
    26.  * @vargs: vargs to format the string. 
    27.  */  
    28. int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,  
    29.                   va_list vargs)  
    30. {  
    31.     const char *old_name = kobj->name;  
    32.     char *s;  
    33.   
    34.     if (kobj->name && !fmt)  
    35.         return 0;  
    36.   
    37.     kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs);  
    38.     if (!kobj->name)  
    39.         return -ENOMEM;  
    40.   
    41.     /* ewww... some of these buggers have '/' in the name ... */  
    42.     while ((s = strchr(kobj->name, '/')))  
    43.         s[0] = '!';  
    44.   
    45.     kfree(old_name);  
    46.     return 0;  
    47. }  
    48.   
    49. /* Simplified asprintf. */  
    50. char *kvasprintf(gfp_t gfp, const char *fmt, va_list ap)  
    51. {  
    52.     unsigned int len;  
    53.     char *p;  
    54.     va_list aq;  
    55.   
    56.     va_copy(aq, ap);  
    57.     len = vsnprintf(NULL, 0, fmt, aq);  
    58.     va_end(aq);  
    59.   
    60.     p = kmalloc(len+1, gfp);  
    61.     if (!p)  
    62.         return NULL;  
    63.   
    64.     vsnprintf(p, len+1, fmt, ap);  
    65.   
    66.     return p;  
    67. }  

    3.2 kset_register

    下面代码位于drivers/base/kobject.c。

    1. /** 
    2.  * kset_register - initialize and add a kset. 
    3.  * @k: kset. 
    4.  */  
    5. int kset_register(struct kset *k)  
    6. {  
    7.     int err;  
    8.   
    9.     if (!k)  
    10.         return -EINVAL;  
    11.   
    12.     kset_init(k);           /*初始化kset*/  
    13.     err = kobject_add_internal(&k->kobj);  /*在sysfs中建立目录*/  
    14.     if (err)  
    15.         return err;  
    16.     kobject_uevent(&k->kobj, KOBJ_ADD);  
    17.     return 0;  
    18. }  

    这里面调用了3个函数。这里先介绍前两个函数。

    3.2.1 kset_init

      该函数用于初始化kset。

      下面代码位于drivers/base/kobject.c。

    1. /** 
    2.  * kset_init - initialize a kset for use 
    3.  * @k: kset 
    4.  */  
    5. void kset_init(struct kset *k)  
    6. {  
    7.     kobject_init_internal(&k->kobj);/*初始化kobject的某些字段*/  
    8.     INIT_LIST_HEAD(&k->list);    /*初始化链表头*/  
    9.     spin_lock_init(&k->list_lock);   /*初始化自旋锁*/  
    10. }  
    11.   
    12. static void kobject_init_internal(struct kobject *kobj)  
    13. {  
    14.     if (!kobj)  
    15.         return;  
    16.     kref_init(&kobj->kref);           /*初始化引用基计数*/  
    17.     INIT_LIST_HEAD(&kobj->entry);    /*初始化链表头*/  
    18.     kobj->state_in_sysfs = 0;  
    19.     kobj->state_add_uevent_sent = 0;  
    20.     kobj->state_remove_uevent_sent = 0;  
    21.     kobj->state_initialized = 1;  
    22. }  

    3.2.2 kobject_add_internal

      该函数将在sysfs中建立目录。

     下面代码位于drivers/base/kobject.c。

    1. static int kobject_add_internal(struct kobject *kobj)  
    2. {  
    3.     int error = 0;  
    4.     struct kobject *parent;  
    5.   
    6.     if (!kobj)  
    7.         return -ENOENT;  
    8.     /*检查name字段是否存在*/  
    9.     if (!kobj->name || !kobj->name[0]) {  
    10.         WARN(1, "kobject: (%p): attempted to be registered with empty "  
    11.              "name! ", kobj);  
    12.         return -EINVAL;  
    13.     }  
    14.   
    15.     parent = kobject_get(kobj->parent);  /*有父对象则增加父对象引用计数*/  
    16.   
    17.     /* join kset if set, use it as parent if we do not already have one */  
    18.     if (kobj->kset) {      
    19.         if (!parent)  
    20.             /*kobj属于某个kset，但是该kobj没有父对象，则以kset的kobj作为父对象*/  
    21.             parent = kobject_get(&kobj->kset->kobj);  
    22.         kobj_kset_join(kobj);       /*将kojbect添加到kset结构中的链表当中*/  
    23.         kobj->parent = parent;  
    24.     }  
    25.   
    26.     pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s' ",  
    27.          kobject_name(kobj), kobj, __func__,  
    28.          parent ? kobject_name(parent) : "<NULL>",  
    29.          kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");  
    30.   
    31.     error = create_dir(kobj);   /*根据kobj->name在sys中建立目录*/  
    32.     if (error) {  
    33.         kobj_kset_leave(kobj);  /*删除链表项*/  
    34.         kobject_put(parent);    /*减少引用计数*/  
    35.         kobj->parent = NULL;  
    36.   
    37.         /* be noisy on error issues */  
    38.         if (error == -EEXIST)  
    39.             printk(KERN_ERR "%s failed for %s with "  
    40.                    "-EEXIST, don't try to register things with "  
    41.                    "the same name in the same directory. ",  
    42.                    __func__, kobject_name(kobj));  
    43.         else  
    44.             printk(KERN_ERR "%s failed for %s (%d) ",  
    45.                    __func__, kobject_name(kobj), error);  
    46.         dump_stack();  
    47.     } else  
    48.         kobj->state_in_sysfs = 1;  
    49.   
    50.     return error;  
    51. }  

    在上面的kset_create中有kset->kobj.kset = NULL，因此if (kobj->kset)条件不满足。因此在这个函数中，对name进行了必要的检查之后，调用了create_dir在sysfs中创建目录。

    在create_dir执行完成以后会在sysfs的根目录（/sys/）建立文件夹bus。该函数的详细分析将在后面给出。

    至此，对bus目录的建立有了简单而直观的了解。我们可以看出kset其实就是表示一个文件夹，而kset本身也含有一个kobject，而该kobject的name字段即为该目录的名字，本例中为bus。

    4. driver model

    第2节所介绍的是最底层，最核心的内容。下面开始将描述较为高层的内容。

    Linux设备模型使用了三个数据结构分别来描述总线、设备和驱动。所有的设备和对应的驱动都必须挂载在某一个总线上，通过总线，可以绑定设备和驱动。

    这个属于分离的思想，将设备和驱动分开管理。

    同时驱动程序可以了解到所有它所支持的设备，同样的，设备也能知道它对应驱动程序。

    4.1 bus

    总线是处理器与一个设备或者多个设备之间的通道。在设备模型中，所有的设备都挂载在某一个总线上。总线使用struct bus_type来表述。

    下列代码位于include/linux/device.h。

    1. <strong><span style="font-family:System;font-size:12px;">struct bus_type {  
    2.     const char        *name;  
    3.     struct bus_attribute    *bus_attrs;  
    4.     struct device_attribute    *dev_attrs;  
    5.     struct driver_attribute    *drv_attrs;  
    6.   
    7.     int (*match)(struct device *dev, struct device_driver *drv);  
    8.     int (*uevent)(struct device *dev, struct kobj_uevent_env *env);  
    9.     int (*probe)(struct device *dev);  
    10.     int (*remove)(struct device *dev);  
    11.     void (*shutdown)(struct device *dev);  
    12.   
    13.     int (*suspend)(struct device *dev, pm_message_t state);  
    14.     int (*suspend_late)(struct device *dev, pm_message_t state);  
    15.     int (*resume_early)(struct device *dev);  
    16.     int (*resume)(struct device *dev);  
    17.   
    18.     struct dev_pm_ops *pm;  
    19.   
    20.     struct bus_type_private *p;  
    21. };  
    22.   
    23. /** 
    24.  * struct bus_type_private - structure to hold the private to the driver core portions of the bus_type structure. 
    25.  * 
    26.  * @subsys - the struct kset that defines this bus.  This is the main kobject 
    27.  * @drivers_kset - the list of drivers associated with this bus 
    28.  * @devices_kset - the list of devices associated with this bus 
    29.  * @klist_devices - the klist to iterate over the @devices_kset 
    30.  * @klist_drivers - the klist to iterate over the @drivers_kset 
    31.  * @bus_notifier - the bus notifier list for anything that cares about things 
    32.  * on this bus. 
    33.  * @bus - pointer back to the struct bus_type that this structure is associated 
    34.  * with. 
    35.  * 
    36.  * This structure is the one that is the actual kobject allowing struct 
    37.  * bus_type to be statically allocated safely.  Nothing outside of the driver 
    38.  * core should ever touch these fields. 
    39.  */  
    40. struct bus_type_private {  
    41.     struct kset subsys;  
    42.     struct kset *drivers_kset;  
    43.     struct kset *devices_kset;  
    44.     struct klist klist_devices;  
    45.     struct klist klist_drivers;  
    46.     struct blocking_notifier_head bus_notifier;  
    47.     unsigned int drivers_autoprobe:1;  
    48.     struct bus_type *bus;  
    49. }；</span></strong>  

    我们看到每个bus_type都包含一个kset对象subsys，该kset在/sys/bus/目录下有着对应的一个目录，目录名即为字段name。后面我们将看到platform总线的建立。

    drivers_kset和devices_kset对应着两个目录，该两个目录下将包含该总线上的设备和相应的驱动程序。

    同时总线上的设备和驱动将分别保存在两个链表中：klist_devices和klist_drivers。

    4.2 device

    设备对象在driver-model中使用struct device来表示。

    下列代码位于include/linux/device.h。

    1. struct device {  
    2.     struct device       *parent;  
    3.   
    4.     struct device_private   *p;  
    5.   
    6.     struct kobject kobj;  
    7.     const char      *init_name; /* initial name of the device */  
    8.     struct device_type  *type;  
    9.   
    10.     struct semaphore    sem;    /* semaphore to synchronize calls to 
    11.                      * its driver. 
    12.                      */  
    13.   
    14.     struct bus_type *bus;       /* type of bus device is on */  
    15.     struct device_driver *driver;   /* which driver has allocated this 
    16.                        device */  
    17.     void        *driver_data;   /* data private to the driver */  
    18.     void        *platform_data; /* Platform specific data, device 
    19.                        core doesn't touch it */  
    20.     struct dev_pm_info  power;  
    21.   
    22. #ifdef CONFIG_NUMA  
    23.     int     numa_node;  /* NUMA node this device is close to */  
    24. #endif  
    25.     u64     *dma_mask;  /* dma mask (if dma'able device) */  
    26.     u64     coherent_dma_mask;/* Like dma_mask, but for 
    27.                          alloc_coherent mappings as 
    28.                          not all hardware supports 
    29.                          64 bit addresses for consistent 
    30.                          allocations such descriptors. */  
    31.   
    32.     struct device_dma_parameters *dma_parms;  
    33.   
    34.     struct list_head    dma_pools;  /* dma pools (if dma'ble) */  
    35.   
    36.     struct dma_coherent_mem *dma_mem; /* internal for coherent mem 
    37.                          override */  
    38.     /* arch specific additions */  
    39.     struct dev_archdata archdata;  
    40.   
    41.     dev_t           devt;   /* dev_t, creates the sysfs "dev" */  
    42.   
    43.     spinlock_t      devres_lock;  
    44.     struct list_head    devres_head;  
    45.   
    46.     struct klist_node   knode_class;  
    47.     struct class        *class;  
    48.     struct attribute_group  **groups;   /* optional groups */  
    49.   
    50.     void    (*release)(struct device *dev);  
    51. };  
    52.   
    53. /** 
    54.  * struct device_private - structure to hold the private to the driver core portions of the device structure. 
    55.  * 
    56.  * @klist_children - klist containing all children of this device 
    57.  * @knode_parent - node in sibling list 
    58.  * @knode_driver - node in driver list 
    59.  * @knode_bus - node in bus list 
    60.  * @device - pointer back to the struct class that this structure is 
    61.  * associated with. 
    62.  * 
    63.  * Nothing outside of the driver core should ever touch these fields. 
    64.  */  
    65. struct device_private {  
    66.     struct klist klist_children;  
    67.     struct klist_node knode_parent;  
    68.     struct klist_node knode_driver;  
    69.     struct klist_node knode_bus;  
    70.     struct device *device;  
    71. };  

    device本身包含一个kobject，也就是说这个device在sysfs的某个地方有着一个对应的目录。

    该device所挂载的bus由knode_bus指定。

    该device所对应的设备驱动由knode_driver指定。

    4.3 driver

    设备设备对象在driver-model中使用struct device_driver来表示。

    下列代码位于include/linux/device.h。

    1. struct device_driver {  
    2.     const char      *name;  
    3.     struct bus_type     *bus;  
    4.   
    5.     struct module       *owner;  
    6.     const char      *mod_name;  /* used for built-in modules */  
    7.   
    8.     int (*probe) (struct device *dev);  
    9.     int (*remove) (struct device *dev);  
    10.     void (*shutdown) (struct device *dev);  
    11.     int (*suspend) (struct device *dev, pm_message_t state);  
    12.     int (*resume) (struct device *dev);  
    13.     struct attribute_group **groups;  
    14.   
    15.     struct dev_pm_ops *pm;  
    16.   
    17.     struct driver_private *p;  
    18. };  
    19.   
    20. struct driver_private {  
    21.     struct kobject kobj;  
    22.     struct klist klist_devices;  
    23.     struct klist_node knode_bus;  
    24.     struct module_kobject *mkobj;  
    25.     struct device_driver *driver;  
    26. };   

    device_driver本身包含一个kobject，也就是说这个device_driver在sysfs的某个地方有着一个对应的目录。

    该设备驱动所支持的设备由klist_devices指定。

    该设备驱动所挂载的总线由knode_bus制定。

    5. Bus举例

    本节我们将以platform总线为例，来看看，/sys/bus/platform是如何建立的。

    platform总线的注册是由platform_bus_init函数完成的。该函数在内核启动阶段被调用，我们来简单看下调用过程：

    start_kernel() -> rest_init() ->kernel_init() -> do_basic_setup() -> driver_init() -> platform_bus_init()。

    注：kernel_init()是在rest_init函数中创建内核线程来执行的。

    1. int __init platform_bus_init(void)  
    2. {  
    3.     int error;  
    4.   
    5.     early_platform_cleanup();  
    6.   
    7.     error = device_register(&platform_bus);  
    8.     if (error)  
    9.         return error;  
    10.     error =  bus_register(&platform_bus_type);  
    11.     if (error)  
    12.         device_unregister(&platform_bus);  
    13.     return error;  
    14. }  
    15. struct bus_type platform_bus_type = {  
    16.     .name       = "platform",  
    17.     .dev_attrs  = platform_dev_attrs,  
    18.     .match      = platform_match,  
    19.     .uevent     = platform_uevent,  
    20.     .pm     = PLATFORM_PM_OPS_PTR,  
    21. };  
    22. EXPORT_SYMBOL_GPL(platform_bus_type);  

    从bus_type，我们看到该总线的名字为platform。

    调用了两个函数，我们只关注bus_register函数。

    1. /** 
    2.  * bus_register - register a bus with the system. 
    3.  * @bus: bus. 
    4.  * 
    5.  * Once we have that, we registered the bus with the kobject 
    6.  * infrastructure, then register the children subsystems it has: 
    7.  * the devices and drivers that belong to the bus. 
    8.  */  
    9. int bus_register(struct bus_type *bus)  
    10. {  
    11.     int retval;  
    12.     struct bus_type_private *priv;  
    13.   
    14.     priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL);  
    15.     if (!priv)  
    16.         return -ENOMEM;  
    17.     /*互相保存*/  
    18.     priv->bus = bus;  
    19.     bus->p = priv;  
    20.   
    21.     BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);  
    22.     /*设定kobject->name*/  
    23.     retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);  
    24.     if (retval)  
    25.         goto out;  
    26.   
    27.     priv->subsys.kobj.kset = bus_kset;  
    28.     priv->subsys.kobj.ktype = &bus_ktype;  
    29.     priv->drivers_autoprobe = 1;  
    30.   
    31.     /*注册kset,在bus/建立目录XXX，XXX为bus->name*/  
    32.     retval = kset_register(&priv->subsys);     
    33.     if (retval)  
    34.         goto out;  
    35.   
    36.     /*创建属性，在bus/XXX/建立文件uevent*/  
    37.     retval = bus_create_file(bus, &bus_attr_uevent);  
    38.     if (retval)  
    39.         goto bus_uevent_fail;  
    40.   
    41.     /*创建kset，在bus/XXX/建立目录devices*/  
    42.     priv->devices_kset = kset_create_and_add("devices", NULL,  
    43.                          &priv->subsys.kobj);  
    44.     if (!priv->devices_kset) {  
    45.         retval = -ENOMEM;  
    46.         goto bus_devices_fail;  
    47.     }  
    48.   
    49.     /*创建kset,在bus/XXX/建立目录drivers*/  
    50.     priv->drivers_kset = kset_create_and_add("drivers", NULL,  
    51.                          &priv->subsys.kobj);  
    52.     if (!priv->drivers_kset) {  
    53.         retval = -ENOMEM;  
    54.         goto bus_drivers_fail;  
    55.     }  
    56.     /*初始化2个内核链表,*/  
    57.     klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);  
    58.     klist_init(&priv->klist_drivers, NULL, NULL);  
    59.   
    60.     /*创建属性,在bus/XXX/建立文件drivers_autoprobe和drivers_probe*/  
    61.     retval = add_probe_files(bus);  
    62.     if (retval)  
    63.         goto bus_probe_files_fail;  
    64.     /*根据bus->bus_attribute创建属性，在bus/XXX/下建立相应的文件d*/  
    65.     retval = bus_add_attrs(bus);  
    66.     if (retval)  
    67.         goto bus_attrs_fail;  
    68.   
    69.     pr_debug("bus: '%s': registered ", bus->name);  
    70.     return 0;  
    71.   
    72. bus_attrs_fail:  
    73.     remove_probe_files(bus);  
    74. bus_probe_files_fail:  
    75.     kset_unregister(bus->p->drivers_kset);  
    76. bus_drivers_fail:  
    77.     kset_unregister(bus->p->devices_kset);  
    78. bus_devices_fail:  
    79.     bus_remove_file(bus, &bus_attr_uevent);  
    80. bus_uevent_fail:  
    81.     kset_unregister(&bus->p->subsys);  
    82.     kfree(bus->p);  
    83. out:  
    84.     bus->p = NULL;  
    85.     return retval;  
    86. }  
    87. EXPORT_SYMBOL_GPL(bus_register);  


    函数中，首先调用kobject_set_name设置了bus对象的subsys.kobject->name 为 platform，也就是说会建立一个名为platform的目录。kobject_set_name函数在3.1小节中已经给出。

    在这里还用到了bus_kset这个变量，这个变量就是在第3节buses_init函数中建立bus目录所对应的kset对象。

    接着，priv->subsys.kobj.kset = bus_kset，设置subsys的kobj在bus_kset对象包含的集合中，也就是说bus目录下将包含subsys对象所对应的目录，即platform。

    紧接着调用了kset_register，参数为&priv->subsys。该函数在3.2节中以给出。在该函数的调用过程中，将调用kobj_kset_join函数，该函数将kobject添加到kobject->kset的链表中。

    1. /* add the kobject to its kset's list */  
    2. static void kobj_kset_join(struct kobject *kobj)  
    3. {  
    4.     if (!kobj->kset)  
    5.         return;  
    6.   
    7.     kset_get(kobj->kset);    /*增加kset引用计数*/  
    8.     spin_lock(&kobj->kset->list_lock);  
    9.     list_add_tail(&kobj->entry, &kobj->kset->list);    /*将kojbect添加到kset结构中的链表当中*/  
    10.     spin_unlock(&kobj->kset->list_lock);  
    11. }  

    kset_register函数执行完成后，将在/sys/bus/下建立目录platform。此刻，我们先来看下kset和kobject之间的关系。

    然后，调用了bus_create_file函数在/sys/bus/platform/下建立文件uevent。

    1. int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)  
    2. {  
    3.     int error;  
    4.     if (bus_get(bus)) {  
    5.         error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);  
    6.         bus_put(bus);  
    7.     } else  
    8.         error = -EINVAL;  
    9.     return error;  
    10. }  
    11. EXPORT_SYMBOL_GPL(bus_create_file);  

    有关底层的sysfs将在后面叙述，这里只要关注参数&bus->p->subsys.kobj，表示在该kset下建立文件，也就是platform下建立。

    接着调用了2次kset_create_and_add，分别在/sys/bus/platform/下建立了文件夹devices和drivers。该函数位于第3节开始处。

    这里和第3节调用kset_create_and_add时的最主要一个区别就是：此时的parent参数不为NULL，而是&priv->subsys.kobj。

    也就是说，将要创建的kset的kobject->parent = &priv->subsys.kobj，也即新建的kset被包含在platform文件夹对应的kset中。

    我们来看下关系图：

    随后，调用了add_probe_files创建了属性文件drivers_autoprobe和drivers_probe。

    1. static int add_probe_files(struct bus_type *bus)  
    2. {  
    3.     int retval;  
    4.   
    5.     retval = bus_create_file(bus, &bus_attr_drivers_probe);  
    6.     if (retval)  
    7.         goto out;  
    8.   
    9.     retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);  
    10.     if (retval)  
    11.         bus_remove_file(bus, &bus_attr_drivers_probe);  
    12. out:  
    13.     return retval;  
    14. }  

    该函数只是简单的调用了两次bus_create_file，该函数已在前面叙述过。

    最后调用bus_add_attrs创建总线相关的属性文件。

    1. /** 
    2.  * bus_add_attrs - Add default attributes for this bus. 
    3.  * @bus: Bus that has just been registered. 
    4.  */  
    5.   
    6. static int bus_add_attrs(struct bus_type *bus)  
    7. {  
    8.     int error = 0;  
    9.     int i;  
    10.   
    11.     if (bus->bus_attrs) {  
    12.         for (i = 0; attr_name(bus->bus_attrs[i]); i++) {  
    13.             error = bus_create_file(bus, &bus->bus_attrs[i]);  
    14.             if (error)  
    15.                 goto err;  
    16.         }  
    17.     }  
    18. done:  
    19.     return error;  
    20. err:  
    21.     while (--i >= 0)  
    22.         bus_remove_file(bus, &bus->bus_attrs[i]);  
    23.     goto done;  
    24. }  

    我们可以看到这个函数将根据bus_type->bus_arrts来创建属性文件。不过，在本例中，bus_arrts从未给出定义，因此次函数不做任何工作。

    好了，整个bus_register调用完成了，我们来看下sysfs中实际的情况。

    [root@yj423 platform]#pwd
    /sys/bus/platform
    [root@yj423 platform]#ls
    devices            drivers            drivers_autoprobe  drivers_probe      uevent

    最后，我们对整个bus_register的过程进行一个小结。

    6. device举例

    本节将首先讲述如何在/sys/devices下建立虚拟的platform设备，然后再讲述如何在/sys/devices/platform/下建立子设备。

    6.1 虚拟的platform设备

    之所以叫虚拟是因为这个platform并不代表任何实际存在的设备，但是platform将是所有具体设备的父设备。

    在第5节，platform_bus_init函数中还调用了device_register，现在对其做出分析。

    1. int __init platform_bus_init(void)  
    2. {  
    3.     int error;  
    4.   
    5.     early_platform_cleanup();  
    6.   
    7.     error = device_register(&platform_bus);  
    8.     if (error)  
    9.         return error;  
    10.     error =  bus_register(&platform_bus_type);  
    11.     if (error)  
    12.         device_unregister(&platform_bus);  
    13.     return error;  
    14. }  
    15.   
    16. struct device platform_bus = {  
    17.     .init_name    = "platform",  
    18. };  
    19. EXPORT_SYMBOL_GPL(platform_bus)  

    下列函数位于drivers/base/core.c。

    1. /** 
    2.  * device_register - register a device with the system. 
    3.  * @dev: pointer to the device structure 
    4.  * 
    5.  * This happens in two clean steps - initialize the device 
    6.  * and add it to the system. The two steps can be called 
    7.  * separately, but this is the easiest and most common. 
    8.  * I.e. you should only call the two helpers separately if 
    9.  * have a clearly defined need to use and refcount the device 
    10.  * before it is added to the hierarchy. 
    11.  * 
    12.  * NOTE: _Never_ directly free @dev after calling this function, even 
    13.  * if it returned an error! Always use put_device() to give up the 
    14.  * reference initialized in this function instead. 
    15.  */  
    16. int device_register(struct device *dev)  
    17. {  
    18.     device_initialize(dev); /*初始化dev的某些字段*/  
    19.     return device_add(dev); /*将设备添加到系统中*/  
    20. }  

    一个设备的注册分成两部，每步通过调用一个函数函数。首先先看第一步：

    下列函数位于drivers/base/core.c。

    1. /** 
    2.  * device_initialize - init device structure. 
    3.  * @dev: device. 
    4.  * 
    5.  * This prepares the device for use by other layers by initializing 
    6.  * its fields. 
    7.  * It is the first half of device_register(), if called by 
    8.  * that function, though it can also be called separately, so one 
    9.  * may use @dev's fields. In particular, get_device()/put_device() 
    10.  * may be used for reference counting of @dev after calling this 
    11.  * function. 
    12.  * 
    13.  * NOTE: Use put_device() to give up your reference instead of freeing 
    14.  * @dev directly once you have called this function. 
    15.  */  
    16. void device_initialize(struct device *dev)  
    17. {  
    18.     dev->kobj.kset = devices_kset;        /*设置kobj属于哪个kset，/sys/devices/*/  
    19.     kobject_init(&dev->kobj, &device_ktype);/*初始化dev->kobj*/  
    20.     INIT_LIST_HEAD(&dev->dma_pools);    /*初始化链表头*/  
    21.     init_MUTEX(&dev->sem);                /*初始化互斥体*/  
    22.     spin_lock_init(&dev->devres_lock);    /*初始化自旋锁*/  
    23.     INIT_LIST_HEAD(&dev->devres_head);    /*初始化链表头*/  
    24.     device_init_wakeup(dev, 0);            /*设置该device不能唤醒*/  
    25.     device_pm_init(dev);                /*设置该device可操作*/  
    26.     set_dev_node(dev, -1);                /*设置NUMA节点*/  
    27. }  

    6.1.1 有关devices_kset

    首先其中用到了devices_kset对象，这个对象和第3节当中的bus_kset是同样的性质，也就是说该对象表示一个目录。

    该对象的建立是在devices_init函数中完成的。

    1. int __init devices_init(void)  
    2. {  
    3.     devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);  
    4.     if (!devices_kset)  
    5.         return -ENOMEM;  
    6.     dev_kobj = kobject_create_and_add("dev", NULL);  
    7.     if (!dev_kobj)  
    8.         goto dev_kobj_err;  
    9.     sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);  
    10.     if (!sysfs_dev_block_kobj)  
    11.         goto block_kobj_err;  
    12.     sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);  
    13.     if (!sysfs_dev_char_kobj)  
    14.         goto char_kobj_err;  
    15.   
    16.     return 0;  
    17.   
    18.  char_kobj_err:  
    19.     kobject_put(sysfs_dev_block_kobj);  
    20.  block_kobj_err:  
    21.     kobject_put(dev_kobj);  
    22.  dev_kobj_err:  
    23.     kset_unregister(devices_kset);  
    24.     return -ENOMEM;  
    25. }  

    由此可见，devices_kset对象表示的目录为/sys下的devices目录。

    6.1.2 kobject_init

    下列函数位于lib/kojbect.c。

    1. /** 
    2.  * kobject_init - initialize a kobject structure 
    3.  * @kobj: pointer to the kobject to initialize 
    4.  * @ktype: pointer to the ktype for this kobject. 
    5.  * 
    6.  * This function will properly initialize a kobject such that it can then 
    7.  * be passed to the kobject_add() call. 
    8.  * 
    9.  * After this function is called, the kobject MUST be cleaned up by a call 
    10.  * to kobject_put(), not by a call to kfree directly to ensure that all of 
    11.  * the memory is cleaned up properly. 
    12.  */  
    13. void kobject_init(struct kobject *kobj, struct kobj_type *ktype)  
    14. {  
    15.     char *err_str;  
    16.   
    17.     if (!kobj) {  
    18.         err_str = "invalid kobject pointer!";  
    19.         goto error;  
    20.     }  
    21.     if (!ktype) {  
    22.         err_str = "must have a ktype to be initialized properly! ";  
    23.         goto error;  
    24.     }  
    25.     if (kobj->state_initialized) {  
    26.         /* do not error out as sometimes we can recover */  
    27.         printk(KERN_ERR "kobject (%p): tried to init an initialized "  
    28.                "object, something is seriously wrong. ", kobj);  
    29.         dump_stack();  
    30.     }  
    31.   
    32.     kobject_init_internal(kobj);  
    33.     kobj->ktype = ktype;  
    34.     return;  
    35.   
    36. error:  
    37.     printk(KERN_ERR "kobject (%p): %s ", kobj, err_str);  
    38.     dump_stack();  
    39. }  
    40. EXPORT_SYMBOL(kobject_init);  
    41.   
    42. static void kobject_init_internal(struct kobject *kobj)  
    43. {  
    44.     if (!kobj)  
    45.         return;  
    46.     kref_init(&kobj->kref);            /*初始化引用基计数*/  
    47.     INIT_LIST_HEAD(&kobj->entry);    /*初始化链表头*/  
    48.     kobj->state_in_sysfs = 0;  
    49.     kobj->state_add_uevent_sent = 0;  
    50.     kobj->state_remove_uevent_sent = 0;  
    51.     kobj->state_initialized = 1;  
    52. }  

    该函数在做了一系列的必要检查后，调用kobject_init_internal初始化了kobject的某些字段。

    6.1.3 device_init_wakeup

    参数val为0，设置该device不能够唤醒。

    1. #ifdef CONFIG_PM  
    2.   
    3. /* changes to device_may_wakeup take effect on the next pm state change. 
    4.  * by default, devices should wakeup if they can. 
    5.  */  
    6. static inline void device_init_wakeup(struct device *dev, int val)  
    7. {  
    8.     dev->power.can_wakeup = dev->power.should_wakeup = !!val;  
    9. }  
    10. 。。。。。。  
    11. #else /* !CONFIG_PM */  
    12.   
    13. /* For some reason the next two routines work even without CONFIG_PM */  
    14. static inline void device_init_wakeup(struct device *dev, int val)  
    15. {  
    16.     dev->power.can_wakeup = !!val;  
    17. }  
    18. 。。。。。。  
    19. #endif  

    6.1.4 device_pm_init

    设置电源的状态。

    1. static inline void device_pm_init(struct device *dev)  
    2. {  
    3.     dev->power.status = DPM_ON;    /*该device被认为可操作*/  
    4. }  

    6.1.5 set_dev_node

    如果使用NUMA，则设置NUMA节点。

    1. #ifdef CONFIG_NUMA  
    2. 。。。。。。  
    3. static inline void set_dev_node(struct device *dev, int node)  
    4. {  
    5.     dev->numa_node = node;  
    6. }  
    7. #else  
    8. 。。。。。。  
    9. static inline void set_dev_node(struct device *dev, int node)  
    10. {  
    11. }  
    12. #endif  

    6.2 device_add

    接下来是注册的第二步：调用device_add。

    1. /** 
    2.  * device_add - add device to device hierarchy. 
    3.  * @dev: device. 
    4.  * 
    5.  * This is part 2 of device_register(), though may be called 
    6.  * separately _iff_ device_initialize() has been called separately. 
    7.  * 
    8.  * This adds @dev to the kobject hierarchy via kobject_add(), adds it 
    9.  * to the global and sibling lists for the device, then 
    10.  * adds it to the other relevant subsystems of the driver model. 
    11.  * 
    12.  * NOTE: _Never_ directly free @dev after calling this function, even 
    13.  * if it returned an error! Always use put_device() to give up your 
    14.  * reference instead. 
    15.  */  
    16. int device_add(struct device *dev)  
    17. {  
    18.     struct device *parent = NULL;  
    19.     struct class_interface *class_intf;  
    20.     int error = -EINVAL;  
    21.   
    22.     dev = get_device(dev);  /*增加引用计数*/  
    23.     if (!dev)  
    24.         goto done;  
    25.   
    26.     dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);    /*分配device_private结构*/  
    27.     if (!dev->p) {  
    28.         error = -ENOMEM;  
    29.         goto done;  
    30.     }  
    31.     dev->p->device = dev; /*保存dev*/  
    32.     klist_init(&dev->p->klist_children, klist_children_get,   /*初始化内核链表*/  
    33.            klist_children_put);  
    34.   
    35.     /* 
    36.      * for statically allocated devices, which should all be converted 
    37.      * some day, we need to initialize the name. We prevent reading back 
    38.      * the name, and force the use of dev_name() 
    39.      */  
    40.     if (dev->init_name) {  
    41.         dev_set_name(dev, dev->init_name);   /*dev->kobject->name = dev->init_name*/  
    42.         dev->init_name = NULL;  
    43.     }  
    44.   
    45.     if (!dev_name(dev)) /*检查dev->kobject->name*/  
    46.         goto name_error;  
    47.   
    48.     pr_debug("device: '%s': %s ", dev_name(dev), __func__);  
    49.   
    50.     parent = get_device(dev->parent);    /*增加父设备引用计数*/  
    51.     setup_parent(dev, parent);          /*设置dev->kobject->parent*/  
    52.   
    53.     /* use parent numa_node */  
    54.     if (parent)  
    55.         set_dev_node(dev, dev_to_node(parent));  
    56.   
    57.     /* first, register with generic layer. */  
    58.     /* we require the name to be set before, and pass NULL */  
    59.     /* 执行完以后，将在/sys/devices/下建立目录XXX，目录名XXX为dev->kobj->name*/  
    60.     error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);    
    61.     if (error)  
    62.         goto Error;  
    63.   
    64.     /* notify platform of device entry */  
    65.     if (platform_notify)  
    66.         platform_notify(dev);  
    67.   
    68.     /*在XXX下建立文件uevent*/  
    69.     error = device_create_file(dev, &uevent_attr);  
    70.     if (error)  
    71.         goto attrError;  
    72.   
    73.     if (MAJOR(dev->devt)) {/*主设备号不为0*/  
    74.         error = device_create_file(dev, &devt_attr);/*创建属性文件dev*/  
    75.         if (error)  
    76.             goto ueventattrError;  
    77.   
    78.         /* 在sys/dev/char/下建立symlink，名字为主设备号:次设备号，该链接指向XXX */  
    79.         error = device_create_sys_dev_entry(dev);   
    80.         if (error)  
    81.             goto devtattrError;  
    82.     }  
    83.   
    84.     error = device_add_class_symlinks(dev);  
    85.     if (error)  
    86.         goto SymlinkError;  
    87.     error = device_add_attrs(dev);  /*添加类设备属型文件和属性组*/  
    88.     if (error)  
    89.         goto AttrsError;  
    90.     error = bus_add_device(dev);    /*添加3个symlink*/  
    91.     if (error)  
    92.         goto BusError;  
    93.     error = dpm_sysfs_add(dev);     /*创建power子目录，并在其下添加电源管理的属性组文件*/  
    94.     if (error)  
    95.         goto DPMError;  
    96.     device_pm_add(dev);             /*将该device添加到电源管理链表中*/  
    97.   
    98.     /* Notify clients of device addition.  This call must come 
    99.      * after dpm_sysf_add() and before kobject_uevent(). 
    100.      */  
    101.     if (dev->bus)  
    102.         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,  
    103.                          BUS_NOTIFY_ADD_DEVICE, dev);  
    104.   
    105.     kobject_uevent(&dev->kobj, KOBJ_ADD);    /*通知用户层*/  
    106.     bus_attach_device(dev);                 /*将设备添加到总线的设备链表中，并尝试获取驱动*/  
    107.     if (parent)  
    108.         klist_add_tail(&dev->p->knode_parent, /*有父设备，则将该设备添加到父设备的儿子链表中*/  
    109.                    &parent->p->klist_children);  
    110.   
    111.     if (dev->class) {                        /*该设备属于某个设备类*/  
    112.         mutex_lock(&dev->class->p->class_mutex);  
    113.         /* tie the class to the device */  
    114.         klist_add_tail(&dev->knode_class,    /*将device添加到class的类设备链表中*/  
    115.                    &dev->class->p->class_devices);  
    116.   
    117.         /* notify any interfaces that the device is here */  
    118.         list_for_each_entry(class_intf,  
    119.                     &dev->class->p->class_interfaces, node)  
    120.             if (class_intf->add_dev)  
    121.                 class_intf->add_dev(dev, class_intf);  
    122.         mutex_unlock(&dev->class->p->class_mutex);  
    123.     }  
    124. done:  
    125.     put_device(dev);  
    126.     return error;  
    127.  DPMError:  
    128.     bus_remove_device(dev);  
    129.  BusError:  
    130.     device_remove_attrs(dev);  
    131.  AttrsError:  
    132.     device_remove_class_symlinks(dev);  
    133.  SymlinkError:  
    134.     if (MAJOR(dev->devt))  
    135.         device_remove_sys_dev_entry(dev);  
    136.  devtattrError:  
    137.     if (MAJOR(dev->devt))  
    138.         device_remove_file(dev, &devt_attr);  
    139.  ueventattrError:  
    140.     device_remove_file(dev, &uevent_attr);  
    141.  attrError:  
    142.     kobject_uevent(&dev->kobj, KOBJ_REMOVE);  
    143.     kobject_del(&dev->kobj);  
    144.  Error:  
    145.     cleanup_device_parent(dev);  
    146.     if (parent)  
    147.         put_device(parent);  
    148. name_error:  
    149.     kfree(dev->p);  
    150.     dev->p = NULL;  
    151.     goto done;  
    152. }  


    该函数调用了非常多的其他函数，接下来对主要的函数做出分析。

    6.2.1 setup_parent函数

    下列代码位于drivers/base/core.c。

    1. static void setup_parent(struct device *dev, struct device *parent)  
    2. {  
    3.     struct kobject *kobj;  
    4.     kobj = get_device_parent(dev, parent);  
    5.     if (kobj)  
    6.         dev->kobj.parent = kobj;  
    7. }  
    8.   
    9. static struct kobject *get_device_parent(struct device *dev,  
    10.                      struct device *parent)  
    11. {  
    12.     /* class devices without a parent live in /sys/class/<classname>/ */  
    13.     if (dev->class && (!parent || parent->class != dev->class))  
    14.         return &dev->class->p->class_subsys.kobj;  
    15.     /* all other devices keep their parent */  
    16.     else if (parent)  
    17.         return &parent->kobj;  
    18.   
    19.     return NULL;  
    20. }  

    该函数将设置dev对象的parent。在这里实际传入的parent为NULL，同时dev->class也没有定义过。因此这个函数什么都没有做。

    6.2.2 kobject_add函数

    下列代码位于lib/kobject.c。

    1. /** 
    2.  * kobject_add - the main kobject add function 
    3.  * @kobj: the kobject to add 
    4.  * @parent: pointer to the parent of the kobject. 
    5.  * @fmt: format to name the kobject with. 
    6.  * 
    7.  * The kobject name is set and added to the kobject hierarchy in this 
    8.  * function. 
    9.  * 
    10.  * If @parent is set, then the parent of the @kobj will be set to it. 
    11.  * If @parent is NULL, then the parent of the @kobj will be set to the 
    12.  * kobject associted with the kset assigned to this kobject.  If no kset 
    13.  * is assigned to the kobject, then the kobject will be located in the 
    14.  * root of the sysfs tree. 
    15.  * 
    16.  * If this function returns an error, kobject_put() must be called to 
    17.  * properly clean up the memory associated with the object. 
    18.  * Under no instance should the kobject that is passed to this function 
    19.  * be directly freed with a call to kfree(), that can leak memory. 
    20.  * 
    21.  * Note, no "add" uevent will be created with this call, the caller should set 
    22.  * up all of the necessary sysfs files for the object and then call 
    23.  * kobject_uevent() with the UEVENT_ADD parameter to ensure that 
    24.  * userspace is properly notified of this kobject's creation. 
    25.  */  
    26. int kobject_add(struct kobject *kobj, struct kobject *parent,  
    27.         const char *fmt, ...)  
    28. {  
    29.     va_list args;  
    30.     int retval;  
    31.   
    32.     if (!kobj)  
    33.         return -EINVAL;  
    34.   
    35.     if (!kobj->state_initialized) {  
    36.         printk(KERN_ERR "kobject '%s' (%p): tried to add an "  
    37.                "uninitialized object, something is seriously wrong. ",  
    38.                kobject_name(kobj), kobj);  
    39.         dump_stack();  
    40.         return -EINVAL;  
    41.     }  
    42.     va_start(args, fmt);  
    43.     retval = kobject_add_varg(kobj, parent, fmt, args);  
    44.     va_end(args);  
    45.   
    46.     return retval;  
    47. }  
    48. EXPORT_SYMBOL(kobject_add);  
    49.   
    50. static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,  
    51.                 const char *fmt, va_list vargs)  
    52. {  
    53.     int retval;  
    54.   
    55.     retval = kobject_set_name_vargs(kobj, fmt, vargs);  
    56.     if (retval) {  
    57.         printk(KERN_ERR "kobject: can not set name properly! ");  
    58.         return retval;  
    59.     }  
    60.     kobj->parent = parent;  
    61.     return kobject_add_internal(kobj);  
    62. }  
    63.   
    64. static int kobject_add_internal(struct kobject *kobj)  
    65. {  
    66.     int error = 0;  
    67.     struct kobject *parent;  
    68.   
    69.     if (!kobj)  
    70.         return -ENOENT;  
    71.     /*检查name字段是否存在*/  
    72.     if (!kobj->name || !kobj->name[0]) {  
    73.         WARN(1, "kobject: (%p): attempted to be registered with empty "  
    74.              "name! ", kobj);  
    75.         return -EINVAL;  
    76.     }  
    77.   
    78.     parent = kobject_get(kobj->parent);    /*有父对象则增加父对象引用计数*/  
    79.   
    80.     /* join kset if set, use it as parent if we do not already have one */  
    81.     if (kobj->kset) {      
    82.         if (!parent)  
    83.             /*kobj属于某个kset，但是该kobj没有父对象，则以kset的kobj作为父对象*/  
    84.             parent = kobject_get(&kobj->kset->kobj);  
    85.         kobj_kset_join(kobj);        /*将kojbect添加到kset结构中的链表当中*/  
    86.         kobj->parent = parent;  
    87.     }  
    88.   
    89.     pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s' ",  
    90.          kobject_name(kobj), kobj, __func__,  
    91.          parent ? kobject_name(parent) : "<NULL>",  
    92.          kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");  
    93.   
    94.     error = create_dir(kobj);    /*根据kobj->name在sys中建立目录*/  
    95.     if (error) {  
    96.         kobj_kset_leave(kobj);    /*删除链表项*/  
    97.         kobject_put(parent);    /*减少引用计数*/  
    98.         kobj->parent = NULL;  
    99.   
    100.         /* be noisy on error issues */  
    101.         if (error == -EEXIST)  
    102.             printk(KERN_ERR "%s failed for %s with "  
    103.                    "-EEXIST, don't try to register things with "  
    104.                    "the same name in the same directory. ",  
    105.                    __func__, kobject_name(kobj));  
    106.         else  
    107.             printk(KERN_ERR "%s failed for %s (%d) ",  
    108.                    __func__, kobject_name(kobj), error);  
    109.         dump_stack();  
    110.     } else  
    111.         kobj->state_in_sysfs = 1;  
    112.   
    113.     return error;  
    114. }  

    在调用时，参数parent为NULL，且dev->kobj.kset在6.1节device_initialize函数中设置为devices_kset。

    而devices_kset对应着/sys/devices目录，因此该函数调用完成后将在/sys/devices目录下生成目录platform。

    但是这里比较奇怪的是，为什么platform目录没有对应的kset对象？？？

    6.2.3 device_create_sys_dev_entry函数

    在调用该函数之前，会在/sys/devices/platform/下生成属性文件。接着如果该device的设备号不为0，则创建属性文件dev，并调用本函数。

    但是，在本例中设备号devt从未设置过，显然为0，那么本函数实际并未执行。

    下列代码位于drivers/base/core.c。

    1. static int device_create_sys_dev_entry(struct device *dev)  
    2. {  
    3.     struct kobject *kobj = device_to_dev_kobj(dev);  
    4.     int error = 0;  
    5.     char devt_str[15];  
    6.   
    7.     if (kobj) {  
    8.         format_dev_t(devt_str, dev->devt);  
    9.         error = sysfs_create_link(kobj, &dev->kobj, devt_str);  
    10.     }  
    11.   
    12.     return error;  
    13. }  
    14. /** 
    15.  * device_to_dev_kobj - select a /sys/dev/ directory for the device 
    16.  * @dev: device 
    17.  * 
    18.  * By default we select char/ for new entries.  Setting class->dev_obj 
    19.  * to NULL prevents an entry from being created.  class->dev_kobj must 
    20.  * be set (or cleared) before any devices are registered to the class 
    21.  * otherwise device_create_sys_dev_entry() and 
    22.  * device_remove_sys_dev_entry() will disagree about the the presence 
    23.  * of the link. 
    24.  */  
    25. static struct kobject *device_to_dev_kobj(struct device *dev)  
    26. {  
    27.     struct kobject *kobj;  
    28.   
    29.     if (dev->class)  
    30.         kobj = dev->class->dev_kobj;  
    31.     else  
    32.         kobj = sysfs_dev_char_kobj;  
    33.   
    34.     return kobj;  
    35. }  

    6.2.4 device_add_class_symlinks函数

    由于dev->class为NULL，本函数其实没做任何工作。

    下列代码位于drivers/base/core.c。

    1. static int device_add_class_symlinks(struct device *dev)  
    2. {  
    3.     int error;  
    4.   
    5.     if (!dev->class)  
    6.         return 0;  
    7.   
    8.     error = sysfs_create_link(&dev->kobj,  
    9.                   &dev->class->p->class_subsys.kobj,  
    10.                   "subsystem");  
    11.     if (error)  
    12.         goto out;  
    13.   
    14. #ifdef CONFIG_SYSFS_DEPRECATED  
    15.     /* stacked class devices need a symlink in the class directory */  
    16.     if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&  
    17.         device_is_not_partition(dev)) {  
    18.         error = sysfs_create_link(&dev->class->p->class_subsys.kobj,  
    19.                       &dev->kobj, dev_name(dev));  
    20.         if (error)  
    21.             goto out_subsys;  
    22.     }  
    23.   
    24.     if (dev->parent && device_is_not_partition(dev)) {  
    25.         struct device *parent = dev->parent;  
    26.         char *class_name;  
    27.   
    28.         /* 
    29.          * stacked class devices have the 'device' link 
    30.          * pointing to the bus device instead of the parent 
    31.          */  
    32.         while (parent->class && !parent->bus && parent->parent)  
    33.             parent = parent->parent;  
    34.   
    35.         error = sysfs_create_link(&dev->kobj,  
    36.                       &parent->kobj,  
    37.                       "device");  
    38.         if (error)  
    39.             goto out_busid;  
    40.   
    41.         class_name = make_class_name(dev->class->name,  
    42.                         &dev->kobj);  
    43.         if (class_name)  
    44.             error = sysfs_create_link(&dev->parent->kobj,  
    45.                         &dev->kobj, class_name);  
    46.         kfree(class_name);  
    47.         if (error)  
    48.             goto out_device;  
    49.     }  
    50.     return 0;  
    51.   
    52. out_device:  
    53.     if (dev->parent && device_is_not_partition(dev))  
    54.         sysfs_remove_link(&dev->kobj, "device");  
    55. out_busid:  
    56.     if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&  
    57.         device_is_not_partition(dev))  
    58.         sysfs_remove_link(&dev->class->p->class_subsys.kobj,  
    59.                   dev_name(dev));  
    60. #else  
    61.     /* link in the class directory pointing to the device */  
    62.     error = sysfs_create_link(&dev->class->p->class_subsys.kobj,  
    63.                   &dev->kobj, dev_name(dev));  
    64.     if (error)  
    65.         goto out_subsys;  
    66.   
    67.     if (dev->parent && device_is_not_partition(dev)) {  
    68.         error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,  
    69.                       "device");  
    70.         if (error)  
    71.             goto out_busid;  
    72.     }  
    73.     return 0;  
    74.   
    75. out_busid:  
    76.     sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));  
    77. #endif  
    78.   
    79. out_subsys:  
    80.     sysfs_remove_link(&dev->kobj, "subsystem");  
    81. out:  
    82.     return error;  
    83. }  

    6.2.5 device_add_attrs函数

    同样dev->class为空，什么都没干。

    下列代码位于drivers/base/core.c。

    1. static int device_add_attrs(struct device *dev)  
    2. {  
    3.     struct class *class = dev->class;  
    4.     struct device_type *type = dev->type;  
    5.     int error;  
    6.   
    7.     if (class) {  
    8.         error = device_add_attributes(dev, class->dev_attrs);  
    9.         if (error)  
    10.             return error;  
    11.     }  
    12.   
    13.     if (type) {  
    14.         error = device_add_groups(dev, type->groups);  
    15.         if (error)  
    16.             goto err_remove_class_attrs;  
    17.     }  
    18.   
    19.     error = device_add_groups(dev, dev->groups);  
    20.     if (error)  
    21.         goto err_remove_type_groups;  
    22.   
    23.     return 0;  
    24.   
    25.  err_remove_type_groups:  
    26.     if (type)  
    27.         device_remove_groups(dev, type->groups);  
    28.  err_remove_class_attrs:  
    29.     if (class)  
    30.         device_remove_attributes(dev, class->dev_attrs);  
    31.   
    32.     return error;  
    33. }  

    6.2.6 bus_add_device函数

    由于dev->bus未指定，因此这个函数什么都没干。

    该函数将创建三个symlink，在sysfs中建立总线和设备间的关系。

    下列代码位于drivers/base/bus.c。

    1. /** 
    2.  * bus_add_device - add device to bus 
    3.  * @dev: device being added 
    4.  * 
    5.  * - Add the device to its bus's list of devices. 
    6.  * - Create link to device's bus. 
    7.  */  
    8. int bus_add_device(struct device *dev)  
    9. {  
    10.     struct bus_type *bus = bus_get(dev->bus);  
    11.     int error = 0;  
    12.   
    13.     if (bus) {  
    14.         pr_debug("bus: '%s': add device %s ", bus->name, dev_name(dev));  
    15.         error = device_add_attrs(bus, dev);  
    16.         if (error)  
    17.             goto out_put;  
    18.           
    19.         /*在sys/bus/XXX/devices下建立symlink,名字为设备名，该链接指向/sys/devices/下的某个目录*/  
    20.         error = sysfs_create_link(&bus->p->devices_kset->kobj,  
    21.                         &dev->kobj, dev_name(dev));  
    22.         if (error)  
    23.             goto out_id;  
    24.           
    25.         /*在sys/devices/的某个目录下建立symlink,名字为subsystem，该链接指向/sys/bus/下的某个目录*/  
    26.         error = sysfs_create_link(&dev->kobj,  
    27.                 &dev->bus->p->subsys.kobj, "subsystem");  
    28.         if (error)  
    29.             goto out_subsys;  
    30.           
    31.         /*在sys/devices/的某个目录下建立symlink,名字为bus，该链接指向/sys/bus/下的某个目录*/  
    32.         error = make_deprecated_bus_links(dev);  
    33.         if (error)  
    34.             goto out_deprecated;  
    35.     }  
    36.     return 0;  
    37.   
    38. out_deprecated:  
    39.     sysfs_remove_link(&dev->kobj, "subsystem");  
    40. out_subsys:  
    41.     sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));  
    42. out_id:  
    43.     device_remove_attrs(bus, dev);  
    44. out_put:  
    45.     bus_put(dev->bus);  
    46.     return error;  
    47. }  

    6.2.7 dpm_sysfs_add函数

    下列代码位于drivers/base/power/sysfs.c。

    1. int dpm_sysfs_add(struct device * dev)  
    2. {  
    3.     return sysfs_create_group(&dev->kobj, &pm_attr_group);  
    4. }  
    5.   
    6. static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);  
    7.   
    8.   
    9. static struct attribute * power_attrs[] = {  
    10.     &dev_attr_wakeup.attr,  
    11.     NULL,  
    12. };  
    13. static struct attribute_group pm_attr_group = {  
    14.     .name    = "power",  
    15.     .attrs    = power_attrs,  
    16. };  

    该函数将在XXX目录下建立power子目录，并在该子目录下建立属性文件wakeup。

    在本例中，将在/sys/bus/platform下建立子目录power并在子目录下建立wakeup文件。

    6.2.8 device_pm_add函数

    下列代码位于drivers/base/power/main.c。

    1. /** 
    2.  *  device_pm_add - add a device to the list of active devices 
    3.  *  @dev:   Device to be added to the list 
    4.  */  
    5. void device_pm_add(struct device *dev)  
    6. {  
    7.     pr_debug("PM: Adding info for %s:%s ",  
    8.          dev->bus ? dev->bus->name : "No Bus",  
    9.          kobject_name(&dev->kobj));  
    10.     mutex_lock(&dpm_list_mtx);  
    11.     if (dev->parent) {  
    12.         if (dev->parent->power.status >= DPM_SUSPENDING)  
    13.             dev_warn(dev, "parent %s should not be sleeping ",  
    14.                  dev_name(dev->parent));  
    15.     } else if (transition_started) {  
    16.         /* 
    17.          * We refuse to register parentless devices while a PM 
    18.          * transition is in progress in order to avoid leaving them 
    19.          * unhandled down the road 
    20.          */  
    21.         dev_WARN(dev, "Parentless device registered during a PM transaction ");  
    22.     }  
    23.   
    24.     list_add_tail(&dev->power.entry, &dpm_list); /*将该设备添加到链表中*/  
    25.     mutex_unlock(&dpm_list_mtx);  
    26. }  


    该函数只是将设备添加到电源管理链表中。

    6.2.9 bus_attach_device函数

    在本例中，由于bus未指定，该函数实际不做任何工作。

    下列代码位于drivers/base/bus.c。

    1. /** 
    2.  * bus_attach_device - add device to bus 
    3.  * @dev: device tried to attach to a driver 
    4.  * 
    5.  * - Add device to bus's list of devices. 
    6.  * - Try to attach to driver. 
    7.  */  
    8. void bus_attach_device(struct device *dev)  
    9. {  
    10.     struct bus_type *bus = dev->bus;  
    11.     int ret = 0;  
    12.   
    13.     if (bus) {  
    14.         if (bus->p->drivers_autoprobe)  
    15.             ret = device_attach(dev);   /*尝试获取驱动*/  
    16.         WARN_ON(ret < 0);  
    17.         if (ret >= 0)        /*将设备挂在到总线中*/  
    18.             klist_add_tail(&dev->p->knode_bus,  
    19.                        &bus->p->klist_devices);  
    20.     }  
    21. }  
    22.   
    23. /** 
    24.  * device_attach - try to attach device to a driver. 
    25.  * @dev: device. 
    26.  * 
    27.  * Walk the list of drivers that the bus has and call 
    28.  * driver_probe_device() for each pair. If a compatible 
    29.  * pair is found, break out and return. 
    30.  * 
    31.  * Returns 1 if the device was bound to a driver; 
    32.  * 0 if no matching device was found; 
    33.  * -ENODEV if the device is not registered. 
    34.  * 
    35.  * When called for a USB interface, @dev->parent->sem must be held. 
    36.  */  
    37. int device_attach(struct device *dev)  
    38. {  
    39.     int ret = 0;  
    40.   
    41.     down(&dev->sem);  
    42.     if (dev->driver) {    /*如果已指定驱动，即已绑定*/  
    43.         ret = device_bind_driver(dev);    /*在sysfs中建立链接关系*/  
    44.         if (ret == 0)  
    45.             ret = 1;  
    46.         else {  
    47.             dev->driver = NULL;  
    48.             ret = 0;  
    49.         }  
    50.     } else {        /*尚未绑定，尝试绑定，遍历该总线上的所有驱动*/  
    51.         ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);  
    52.     }  
    53.     up(&dev->sem);  
    54.     return ret;  
    55. }  
    56. EXPORT_SYMBOL_GPL(device_attach);  


    如果bus存在的话，将会调用device_attach函数进行绑定工作。该函数首先判断dev->driver，如果非0，表示该设备已经绑定了驱动，只要在sysfs中建立链接关系即可。

    为0表示没有绑定，接着调用bus_for_each_drv，注意作为参数传入的__device_attach，这是个函数，后面会调用它。

    我们来看下bus_for_each_drv：

    1. /** 
    2.  * bus_for_each_drv - driver iterator 
    3.  * @bus: bus we're dealing with. 
    4.  * @start: driver to start iterating on. 
    5.  * @data: data to pass to the callback. 
    6.  * @fn: function to call for each driver. 
    7.  * 
    8.  * This is nearly identical to the device iterator above. 
    9.  * We iterate over each driver that belongs to @bus, and call 
    10.  * @fn for each. If @fn returns anything but 0, we break out 
    11.  * and return it. If @start is not NULL, we use it as the head 
    12.  * of the list. 
    13.  * 
    14.  * NOTE: we don't return the driver that returns a non-zero 
    15.  * value, nor do we leave the reference count incremented for that 
    16.  * driver. If the caller needs to know that info, it must set it 
    17.  * in the callback. It must also be sure to increment the refcount 
    18.  * so it doesn't disappear before returning to the caller. 
    19.  */  
    20. int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,  
    21.              void *data, int (*fn)(struct device_driver *, void *))  
    22. {  
    23.     struct klist_iter i;  
    24.     struct device_driver *drv;  
    25.     int error = 0;  
    26.   
    27.     if (!bus)  
    28.         return -EINVAL;  
    29.   
    30.     klist_iter_init_node(&bus->p->klist_drivers, &i,  
    31.                  start ? &start->p->knode_bus : NULL);  
    32.     while ((drv = next_driver(&i)) && !error)  
    33.         error = fn(drv, data);  
    34.     klist_iter_exit(&i);  
    35.     return error;  
    36. }  
    37. EXPORT_SYMBOL_GPL(bus_for_each_drv);  

    该函数将遍历总线的drivers目录下的所有驱动，也就是/sys/bus/XXX/drivers/下的目录，为该driver调用fn函数，也就是__device_attach。我们来看下：

    1. static int __device_attach(struct device_driver *drv, void *data)  
    2. {  
    3.     struct device *dev = data;  
    4.   
    5.     if (!driver_match_device(drv, dev))   /*进行匹配工作*/  
    6.         return 0;  
    7.   
    8.     return driver_probe_device(drv, dev);  
    9. }  
    10.   
    11. static inline int driver_match_device(struct device_driver *drv,  
    12.                       struct device *dev)  
    13. {  
    14.     return drv->bus->match ? drv->bus->match(dev, drv) : 1;  
    15. }   
    16.   
    17. /** 
    18.  * driver_probe_device - attempt to bind device & driver together 
    19.  * @drv: driver to bind a device to 
    20.  * @dev: device to try to bind to the driver 
    21.  * 
    22.  * This function returns -ENODEV if the device is not registered, 
    23.  * 1 if the device is bound sucessfully and 0 otherwise. 
    24.  * 
    25.  * This function must be called with @dev->sem held.  When called for a 
    26.  * USB interface, @dev->parent->sem must be held as well. 
    27.  */  
    28. int driver_probe_device(struct device_driver *drv, struct device *dev)  
    29. {  
    30.     int ret = 0;  
    31.   
    32.     if (!device_is_registered(dev))    /*该device是否已在sysfs中*/  
    33.         return -ENODEV;  
    34.   
    35.     pr_debug("bus: '%s': %s: matched device %s with driver %s ",  
    36.          drv->bus->name, __func__, dev_name(dev), drv->name);  
    37.   
    38.     ret = really_probe(dev, drv);/*device已在sysfs，调用really_probe*/      
    39.   
    40.     return ret;  
    41. }  


    该函数首先调用driver_match_device函数，后者将会调用总线的match方法，如果有的话，来进行匹配工作。如果没有该方法，则返回1，表示匹配成功。

    我们这里是针对platform总线，该总线的方法将在7.6.2节中看到。

    随后，又调用了driver_probe_device函数。该函数将首先判断该device是否已在sysfs中，如果在则调用really_probe，否则返回出错。

    really_probe将会调用驱动的probe并完成绑定的工作。该函数将在7.6.2节中分析。

    6.2.10 小结

    在本例中，当device_register调用完成以后，将在/sys/devices/下建立目录platform，并在platfrom下建立属性文件uevent和子目录power，最后在power子目录下建立wakeup属性文件。

    最后以函数调用过程的总结来结束第6.2小结。

    6.3 spi主控制器的平台设备

    本节对一个特定的platform设备进行讲解，那就是spi主控制器的平台设备。

    在内核的启动阶段，platform设备将被注册进内核。我们来看下。

    下列代码位于arch/arm/mach-s3c2440/mach-smdk2440.c

    1. static struct resource s3c_spi0_resource[] = {  
    2.     [0] = {  
    3.         .start = S3C24XX_PA_SPI,  
    4.         .end   = S3C24XX_PA_SPI + 0x1f,  
    5.         .flags = IORESOURCE_MEM,  
    6.     },  
    7.     [1] = {  
    8.         .start = IRQ_SPI0,  
    9.         .end   = IRQ_SPI0,  
    10.         .flags = IORESOURCE_IRQ,  
    11.     }  
    12.   
    13. };  
    14.   
    15. static u64 s3c_device_spi0_dmamask = 0xffffffffUL;  
    16.   
    17. struct platform_device s3c_device_spi0 = {  
    18.     .name          = "s3c2410-spi",  
    19.     .id          = 0,  
    20.     .num_resources      = ARRAY_SIZE(s3c_spi0_resource),  
    21.     .resource      = s3c_spi0_resource,  
    22.         .dev              = {  
    23.                 .dma_mask = &s3c_device_spi0_dmamask,  
    24.                 .coherent_dma_mask = 0xffffffffUL  
    25.         }  
    26. };  
    27.   
    28. static struct platform_device *smdk2440_devices[] __initdata = {  
    29.     &s3c_device_usb,  
    30.     &s3c_device_lcd,  
    31.     &s3c_device_wdt,  
    32.     &s3c_device_i2c0,  
    33.     &s3c_device_iis,  
    34.     &s3c_device_spi0,  
    35. };  
    36.   
    37.   
    38.   
    39. static void __init smdk2440_machine_init(void)  
    40. {  
    41.     s3c24xx_fb_set_platdata(&smdk2440_fb_info);  
    42.     s3c_i2c0_set_platdata(NULL);  
    43.   
    44.     platform_add_devices(smdk2440_devices, ARRAY_SIZE(smdk2440_devices));  
    45.     smdk_machine_init();  
    46. }  
    

    在smdk2440_machine_init函数中，通过调用platform_add_devices将设备注册到内核中。接着来看下该函数。
    


    6.3.1 platform_add_devices
    


      

    1. /** 
      2. 

    2.  * platform_add_devices - add a numbers of platform devices 
      3. 

    3.  * @devs: array of platform devices to add 
      4. 

    4.  * @num: number of platform devices in array 
      5. 

    5.  */  
      6. 

    6. int platform_add_devices(struct platform_device **devs, int num)  
      7. 

    7. {  
      8. 

    8.     int i, ret = 0;  
      9. 

    9.   
      10. 

    10.     for (i = 0; i < num; i++) {  
      11. 

    11.         ret = platform_device_register(devs[i]);  
      12. 

    12.         if (ret) {  
      13. 

    13.             while (--i >= 0)  
      14. 

    14.                 platform_device_unregister(devs[i]);  
      15. 

    15.             break;  
      16. 

    16.         }  
      17. 

    17.     }  
      18. 

    18.   
      19. 

    19.     return ret;  
      20. 

    20. }  
      21. 

    21. EXPORT_SYMBOL_GPL(platform_add_devices);  
      22. 

    


    该函数将根据devs指针数组，调用platform_device_register将platform设备逐一注册进内核。
    


    6.3.2  platform_device_register
    


      

    1. /** 
      2. 

    2.  * platform_device_register - add a platform-level device 
      3. 

    3.  * @pdev: platform device we're adding 
      4. 

    4.  */  
      5. 

    5. int platform_device_register(struct platform_device *pdev)  
      6. 

    6. {  
      7. 

    7.     device_initialize(&pdev->dev);  
      8. 

    8.     return platform_device_add(pdev);  
      9. 

    9. }  
      10. 

    10. EXPORT_SYMBOL_GPL(platform_device_register);  
      11. 


    


    调用了两个函数，第一个函数在6.1节已经分析过。我们来看下第二个函数。
    


    6.3.2  platform_device_register
    


      

    1. /** 
      2. 

    2.  * platform_device_add - add a platform device to device hierarchy 
      3. 

    3.  * @pdev: platform device we're adding 
      4. 

    4.  * 
      5. 

    5.  * This is part 2 of platform_device_register(), though may be called 
      6. 

    6.  * separately _iff_ pdev was allocated by platform_device_alloc(). 
      7. 

    7.  */  
      8. 

    8. int platform_device_add(struct platform_device *pdev)  
      9. 

    9. {  
      10. 

    10.     int i, ret = 0;  
      11. 

    11.   
      12. 

    12.     if (!pdev)  
      13. 

    13.         return -EINVAL;  
      14. 

    14.   
      15. 

    15.     if (!pdev->dev.parent)  
      16. 

    16.         pdev->dev.parent = &platform_bus;    /*该设备的父设备是platform设备，/sys/devices/platform*/  
      17. 

    17.   
      18. 

    18.     pdev->dev.bus = &platform_bus_type;      /*设备挂载到platform总线上*/  
      19. 

    19.   
      20. 

    20.     if (pdev->id != -1)  
      21. 

    21.         dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);  
      22. 

    22.     else  
      23. 

    23.         dev_set_name(&pdev->dev, pdev->name);/*pdev->dev->kobj->name = pdev->name*/  
      24. 

    24.   
      25. 

    25.     /*遍历平台设备的资源，并将资源添加到资源树中*/  
      26. 

    26.     for (i = 0; i < pdev->num_resources; i++) {  
      27. 

    27.         struct resource *p, *r = &pdev->resource[i];  
      28. 

    28.   
      29. 

    29.         if (r->name == NULL)  
      30. 

    30.             r->name = dev_name(&pdev->dev);   /*获取dev->kobject->name*/  
      31. 

    31.   
      32. 

    32.         p = r->parent;  
      33. 

    33.         if (!p) {   /*p空*/  
      34. 

    34.             if (resource_type(r) == IORESOURCE_MEM)  
      35. 

    35.                 p = &iomem_resource;  
      36. 

    36.             else if (resource_type(r) == IORESOURCE_IO)  
      37. 

    37.                 p = &ioport_resource;  
      38. 

    38.         }  
      39. 

    39.   
      40. 

    40.         if (p && insert_resource(p, r)) {   /*将资源添加到资源树中*/  
      41. 

    41.             printk(KERN_ERR  
      42. 

    42.                    "%s: failed to claim resource %d
",  
      43. 

    43.                    dev_name(&pdev->dev), i);  
      44. 

    44.             ret = -EBUSY;  
      45. 

    45.             goto failed;  
      46. 

    46.         }  
      47. 

    47.     }  
      48. 

    48.   
      49. 

    49.     pr_debug("Registering platform device '%s'. Parent at %s
",  
      50. 

    50.          dev_name(&pdev->dev), dev_name(pdev->dev.parent));  
      51. 

    51.   
      52. 

    52.     ret = device_add(&pdev->dev);    /*添加设备*/  
      53. 

    53.     if (ret == 0)  
      54. 

    54.         return ret;  
      55. 

    55.   
      56. 

    56.  failed:  
      57. 

    57.     while (--i >= 0) {  
      58. 

    58.         struct resource *r = &pdev->resource[i];  
      59. 

    59.         unsigned long type = resource_type(r);  
      60. 

    60.   
      61. 

    61.         if (type == IORESOURCE_MEM || type == IORESOURCE_IO)  
      62. 

    62.             release_resource(r);  
      63. 

    63.     }  
      64. 

    64.   
      65. 

    65.     return ret;  
      66. 

    66. }  
      67. 

    67. EXPORT_SYMBOL_GPL(platform_device_add);  
      68. 


    


    在这个函数的最后赫然出现了device_add函数。我们回忆下在6.1节中device_register的注册过程，该函数只调用了两个函数，一个是device_initialize函数，另一个就是device_add。
    


    本节的platform_device_register函数，首先也是调用了device_initialize，但是随后他做了一些其他的工作，最后调用了device_add。
    

    那么这个"其他的工作"干了些什么呢？
    

    首先，它将该SPI主控制对应的平台设备的父设备设为虚拟的platform设备（platform_bus），然后将该平台设备挂在至platform总线（platform_bus_type）上，这两步尤为重要，后面我们将看到。
    

    然后，调用了dev_set_name设置了pdev->dev-kobj.name，也就是该设备对象的名字，这里的名字为s3c2410-spi.0，这个名字将被用来建立一个目录。
    

    最后，将平台的相关资源添加到资源树中。这不是本篇文章讨论的重点所在，所以不做过多说明。
    

    在"其他的工作""干完之后，调用了device_add函数。那么后面的函数调用过程将和6.2小结的一致。
    

    由于“其他的工作”的原因，实际执行的过程和结果将有所区别。我们来分析下。
    

    6.3.3 不一样device_add调用结果
    

    首先，在device_add被调用之前，有若干个非常重要的条件已经被设置了。如下：
    

    pdev->dev->kobj.kset = devices_kset
    

    pdev->dev-.parent = &platform_bus
    

    pdev->dev.bus = &platform_bus_type
    

    set_up函数执行时，由于参数parent为&platform_bus，因此最后将设置pdev->dev->kobj.parent = platform_bus.kobj。平台设备对象的父对象为虚拟的platform设备。
    

    kobject_add函数执行时，由于参数parent的存在，将在parent对象所对应的目录下创建另一个目录。parent对象代表目录/sys/devices/下的platform，因此将在/sys/devices/platform下建立目录s3c2410-spi.0。
    

    device_create_file建立属性文件uevent。
    

    bus_add_device函数执行时，由于dev.bus 为&platform_bus_type，因此将建立三个symlink。
    

                /sys/devices/platform/s3c2410-spi.0下建立链接subsystem和bus，他们指向/sys/bus/platform。
    

               /sys/bus/platform/devices/下建立链接s3c2410-spi.0，指向/sys/devices/platform/s3c2410-spi.0。
    

    dpm_sysfs_add函数在/sys/devices/platform/s3c2410-spi.0下建立子目录power，并在该子目录下建立属性文件wakeup。
    

    执行到这里时，sysfs已将内核中新添加的SPI主控制器平台设备呈现出来了，我们来验证下。
    

    [root@yj423 s3c2410-spi.0]#pwd
    /sys/devices/platform/s3c2410-spi.0
    [root@yj423 s3c2410-spi.0]#ll
    lrwxrwxrwx    1 root     root             0 Jan  1 00:29 bus -> ../../../bus/platform
    lrwxrwxrwx    1 root     root             0 Jan  1 00:29 driver -> ../../../bus/platform/drivers/s3c2410-spi
    -r--r--r--    1 root     root          4096 Jan  1 00:29 modalias
    drwxr-xr-x    2 root     root             0 Jan  1 00:29 power
    drwxr-xr-x    3 root     root             0 Jan  1 00:00 spi0.0
    drwxr-xr-x    3 root     root             0 Jan  1 00:00 spi0.1
    lrwxrwxrwx    1 root     root             0 Jan  1 00:29 spi_master:spi0 -> ../../../class/spi_master/spi0
    lrwxrwxrwx    1 root     root             0 Jan  1 00:29 subsystem -> ../../../bus/platform
    -rw-r--r--    1 root     root          4096 Jan  1 00:29 uevent
    

    [root@yj423 devices]#pwd
    /sys/bus/platform/devices
    [root@yj423 devices]#ll s3c2410-spi.0 
    lrwxrwxrwx    1 root     root             0 Jan  1 00:44 s3c2410-spi.0 -> ../../../devices/platform/s3c2410-spi.0
    

    通过sysfs将设备驱动的模型层次呈现在用户空间以后，将更新内核的设备模型之间的关系，这是通过修改链表的指向来完成的。
    

    bus_attach_device函数执行时，将设备添加到总线的设备链表中，同时也会尝试绑定驱动，不过会失败。
    

    接着，由于dev->parent的存在，将SPI主控制器设备添加到父设备platform虚拟设备的儿子链表中。
    


    7. driver举例
    

    我们已经介绍过platform总线的注册，也讲述了SPI主控制器设备作为平台设备的注册过程，在本节，将描述SPI主控制器的platform驱动是如何注册的。
    

    7.1 s3c24xx_spi_init
    

    下列代码位于drivers/spi/spi_s3c24xx.c。
    


      

    1. MODULE_ALIAS("platform:s3c2410-spi");  
      2. 

    2. static struct platform_driver s3c24xx_spi_driver = {  
      3. 

    3.     .remove        = __exit_p(s3c24xx_spi_remove),  
      4. 

    4.     .suspend    = s3c24xx_spi_suspend,  
      5. 

    5.     .resume        = s3c24xx_spi_resume,  
      6. 

    6.     .driver        = {  
      7. 

    7.         .name    = "s3c2410-spi",  
      8. 

    8.         .owner    = THIS_MODULE,  
      9. 

    9.     },  
      10. 

    10. };  
      11. 

    11.   
      12. 

    12. static int __init s3c24xx_spi_init(void)  
      13. 

    13. {  
      14. 

    14.         return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe);//设备不可热插拔，所以使用该函数，而不是platform_driver_register  
      15. 

    15. }  
      16. 


    

    驱动注册通过调用platform_driver_probe来完成。
    


    注意：driver.name字段使用来匹配设备的，该字段必须和6.3节一开始给出的pdev.name字段相同。
    

    7.2  platform_driver_probe
    

    下列代码位于drivers/base/platform.c。
    


      

    1. /** 
      2. 

    2.  * platform_driver_probe - register driver for non-hotpluggable device 
      3. 

    3.  * @drv: platform driver structure 
      4. 

    4.  * @probe: the driver probe routine, probably from an __init section 
      5. 

    5.  * 
      6. 

    6.  * Use this instead of platform_driver_register() when you know the device 
      7. 

    7.  * is not hotpluggable and has already been registered, and you want to 
      8. 

    8.  * remove its run-once probe() infrastructure from memory after the driver 
      9. 

    9.  * has bound to the device. 
      10. 

    10.  * 
      11. 

    11.  * One typical use for this would be with drivers for controllers integrated 
      12. 

    12.  * into system-on-chip processors, where the controller devices have been 
      13. 

    13.  * configured as part of board setup. 
      14. 

    14.  * 
      15. 

    15.  * Returns zero if the driver registered and bound to a device, else returns 
      16. 

    16.  * a negative error code and with the driver not registered. 
      17. 

    17.  */  
      18. 

    18. int __init_or_module platform_driver_probe(struct platform_driver *drv,  
      19. 

    19.         int (*probe)(struct platform_device *))  
      20. 

    20. {  
      21. 

    21.     int retval, code;  
      22. 

    22.   
      23. 

    23.     /* temporary section violation during probe() */  
      24. 

    24.     drv->probe = probe;  
      25. 

    25.     retval = code = platform_driver_register(drv); /*注册platform驱动*/  
      26. 

    26.   
      27. 

    27.     /* Fixup that section violation, being paranoid about code scanning 
      28. 

    28.      * the list of drivers in order to probe new devices.  Check to see 
      29. 

    29.      * if the probe was successful, and make sure any forced probes of 
      30. 

    30.      * new devices fail. 
      31. 

    31.      */  
      32. 

    32.     spin_lock(&platform_bus_type.p->klist_drivers.k_lock);  
      33. 

    33.     drv->probe = NULL;  
      34. 

    34.     if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))  
      35. 

    35.         retval = -ENODEV;  
      36. 

    36.     drv->driver.probe = platform_drv_probe_fail;  
      37. 

    37.     spin_unlock(&platform_bus_type.p->klist_drivers.k_lock);  
      38. 

    38.   
      39. 

    39.     if (code != retval)  
      40. 

    40.         platform_driver_unregister(drv);  
      41. 

    41.     return retval;  
      42. 

    42. }  
      43. 

    43. EXPORT_SYMBOL_GPL(platform_driver_probe);  
      44. 


    

    这里的重点是platform_driver_register，由它来完成了platform驱动的注册。
    


    7.3 platform_driver_register
    


      

    1. /** 
      2. 

    2.  * platform_driver_register 
      3. 

    3.  * @drv: platform driver structure 
      4. 

    4.  */  
      5. 

    5. int platform_driver_register(struct platform_driver *drv)  
      6. 

    6. {  
      7. 

    7.     drv->driver.bus = &platform_bus_type;  
      8. 

    8.     if (drv->probe)  
      9. 

    9.         drv->driver.probe = platform_drv_probe;  
      10. 

    10.     if (drv->remove)  
      11. 

    11.         drv->driver.remove = platform_drv_remove;  
      12. 

    12.     if (drv->shutdown)  
      13. 

    13.         drv->driver.shutdown = platform_drv_shutdown;  
      14. 

    14.     if (drv->suspend)  
      15. 

    15.         drv->driver.suspend = platform_drv_suspend;  
      16. 

    16.     if (drv->resume)  
      17. 

    17.         drv->driver.resume = platform_drv_resume;  
      18. 

    18.     return driver_register(&drv->driver); /*驱动注册*/  
      19. 

    19. }  
      20. 

    20. EXPORT_SYMBOL_GPL(platform_driver_register);  
      21. 


    


    driver_register函数就是driver注册的核心函数。需要注意的是，在调用函数之前，将该驱动所挂载的总线设置为platform总线（platform_bus_type）。
    


    7.4 driver_register
    

    下列代码位于drivers/base/driver.c。
    


      

    1. /** 
      2. 

    2.  * driver_register - register driver with bus 
      3. 

    3.  * @drv: driver to register 
      4. 

    4.  * 
      5. 

    5.  * We pass off most of the work to the bus_add_driver() call, 
      6. 

    6.  * since most of the things we have to do deal with the bus 
      7. 

    7.  * structures. 
      8. 

    8.  */  
      9. 

    9. int driver_register(struct device_driver *drv)  
      10. 

    10. {  
      11. 

    11.     int ret;  
      12. 

    12.     struct device_driver *other;  
      13. 

    13.   
      14. 

    14.     BUG_ON(!drv->bus->p);  
      15. 

    15.   
      16. 

    16.     if ((drv->bus->probe && drv->probe) ||  
      17. 

    17.         (drv->bus->remove && drv->remove) ||  
      18. 

    18.         (drv->bus->shutdown && drv->shutdown))  
      19. 

    19.         printk(KERN_WARNING "Driver '%s' needs updating - please use "  
      20. 

    20.             "bus_type methods
", drv->name);  
      21. 

    21.   
      22. 

    22.     other = driver_find(drv->name, drv->bus);/*用驱动名字来搜索在该总线上驱动是否已经存在*/  
      23. 

    23.     if (other) {    /*存在则报错*/  
      24. 

    24.         put_driver(other);  
      25. 

    25.         printk(KERN_ERR "Error: Driver '%s' is already registered, "  
      26. 

    26.             "aborting...
", drv->name);  
      27. 

    27.         return -EEXIST;  
      28. 

    28.     }  
      29. 

    29.   
      30. 

    30.     ret = bus_add_driver(drv);  /*将驱动添加到一个总线中*/  
      31. 

    31.     if (ret)  
      32. 

    32.         return ret;  
      33. 

    33.     ret = driver_add_groups(drv, drv->groups); /*建立属性组文件*/  
      34. 

    34.     if (ret)  
      35. 

    35.         bus_remove_driver(drv);  
      36. 

    36.     return ret;  
      37. 

    37. }  
      38. 

    38. EXPORT_SYMBOL_GPL(driver_register);  
      39. 


    

    这里主要调用两个函数driver_find和bus_add_driver。前者将通过总线来搜索该驱动是否存在，后者将添加驱动到总线中。
    


    接下来就分析这两个函数。
    

    7.5 driver_find
    

    下列代码位于drivers/base/driver.c。
    


      

    1. /** 
      2. 

    2.  * driver_find - locate driver on a bus by its name. 
      3. 

    3.  * @name: name of the driver. 
      4. 

    4.  * @bus: bus to scan for the driver. 
      5. 

    5.  * 
      6. 

    6.  * Call kset_find_obj() to iterate over list of drivers on 
      7. 

    7.  * a bus to find driver by name. Return driver if found. 
      8. 

    8.  * 
      9. 

    9.  * Note that kset_find_obj increments driver's reference count. 
      10. 

    10.  */  
      11. 

    11. struct device_driver *driver_find(const char *name, struct bus_type *bus)  
      12. 

    12. {  
      13. 

    13.     struct kobject *k = kset_find_obj(bus->p->drivers_kset, name);  
      14. 

    14.     struct driver_private *priv;  
      15. 

    15.   
      16. 

    16.     if (k) {  
      17. 

    17.         priv = to_driver(k);  
      18. 

    18.         return priv->driver;  
      19. 

    19.     }  
      20. 

    20.     return NULL;  
      21. 

    21. }  
      22. 

    22. EXPORT_SYMBOL_GPL(driver_find);  
      23. 


    



      

    1. /** 
      2. 

    2.  * kset_find_obj - search for object in kset. 
      3. 

    3.  * @kset: kset we're looking in. 
      4. 

    4.  * @name: object's name. 
      5. 

    5.  * 
      6. 

    6.  * Lock kset via @kset->subsys, and iterate over @kset->list, 
      7. 

    7.  * looking for a matching kobject. If matching object is found 
      8. 

    8.  * take a reference and return the object. 
      9. 

    9.  */  
      10. 

    10. struct kobject *kset_find_obj(struct kset *kset, const char *name)  
      11. 

    11. {  
      12. 

    12.     struct kobject *k;  
      13. 

    13.     struct kobject *ret = NULL;  
      14. 

    14.   
      15. 

    15.     spin_lock(&kset->list_lock);  
      16. 

    16.     list_for_each_entry(k, &kset->list, entry) {  
      17. 

    17.         if (kobject_name(k) && !strcmp(kobject_name(k), name)) {  
      18. 

    18.             ret = kobject_get(k);  
      19. 

    19.             break;  
      20. 

    20.         }  
      21. 

    21.     }  
      22. 

    22.     spin_unlock(&kset->list_lock);  
      23. 

    23.     return ret;  
      24. 

    24. }  
      25. 


    


    

    这里调用了kset_find_obj函数，传入的实参bus->p->drivers_kset，它对应的就是/sys/bus/platform/下的drivers目录，然后通过链表，它将搜索该目录下的所有文件，来寻找是否有名为s3c2410-spi的文件。还记得吗？ kobject就是一个文件对象。如果没有找到将返回NULL，接着将调用bus_add_driver把驱动注册进内核。
    



    7.6 bus_add_driver
    

    下列代码位于drivers/base/bus.c
    


      

    1. /** 
      2. 

    2.  * bus_add_driver - Add a driver to the bus. 
      3. 

    3.  * @drv: driver. 
      4. 

    4.  */  
      5. 

    5. int bus_add_driver(struct device_driver *drv)  
      6. 

    6. {  
      7. 

    7.     struct bus_type *bus;  
      8. 

    8.     struct driver_private *priv;  
      9. 

    9.     int error = 0;  
      10. 

    10.   
      11. 

    11.     bus = bus_get(drv->bus); /*增加引用计数获取bus_type*/  
      12. 

    12.     if (!bus)  
      13. 

    13.         return -EINVAL;  
      14. 

    14.   
      15. 

    15.     pr_debug("bus: '%s': add driver %s
", bus->name, drv->name);  
      16. 

    16.   
      17. 

    17.     priv = kzalloc(sizeof(*priv), GFP_KERNEL);  /*分配driver_private结构体*/  
      18. 

    18.     if (!priv) {  
      19. 

    19.         error = -ENOMEM;  
      20. 

    20.         goto out_put_bus;  
      21. 

    21.     }  
      22. 

    22.     /*初始化内核链表*/  
      23. 

    23.     klist_init(&priv->klist_devices, NULL, NULL);  
      24. 

    24.     /*相互保存*/  
      25. 

    25.     priv->driver = drv;  
      26. 

    26.     drv->p = priv;  
      27. 

    27.     /*设置该kobj属于那个kset*/  
      28. 

    28.     priv->kobj.kset = bus->p->drivers_kset;  
      29. 

    29.     error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,   /*parent=NULL*/  
      30. 

    30.                      "%s", drv->name);   /*执行完以后，会在bus/总线名/drivers/下建立名为drv->name的目录*/  
      31. 

    31.     if (error)  
      32. 

    32.         goto out_unregister;  
      33. 

    33.   
      34. 

    34.     if (drv->bus->p->drivers_autoprobe) {  
      35. 

    35.         error = driver_attach(drv); /*尝试绑定驱动和设备*/  
      36. 

    36.         if (error)  
      37. 

    37.             goto out_unregister;  
      38. 

    38.     }  
      39. 

    39.     /*添加该驱动到bus的内核链表中*/  
      40. 

    40.     klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);  
      41. 

    41.     module_add_driver(drv->owner, drv);/*?????????*/  
      42. 

    42.   
      43. 

    43.     /*创建属性，在bus/总线名/drivers/驱动名/下建立文件uevent*/  
      44. 

    44.     error = driver_create_file(drv, &driver_attr_uevent);  
      45. 

    45.     if (error) {  
      46. 

    46.         printk(KERN_ERR "%s: uevent attr (%s) failed
",  
      47. 

    47.             __func__, drv->name);  
      48. 

    48.     }  
      49. 

    49.     /*利用bus->drv_attrs创建属性，位于bus/总线名/drivers/驱动名/*/  
      50. 

    50.     error = driver_add_attrs(bus, drv);  
      51. 

    51.     if (error) {  
      52. 

    52.         /* How the hell do we get out of this pickle? Give up */  
      53. 

    53.         printk(KERN_ERR "%s: driver_add_attrs(%s) failed
",  
      54. 

    54.             __func__, drv->name);  
      55. 

    55.     }  
      56. 

    56.     /*创建属性，在bus/总线名/drivers/驱动名/下建立文件bind和unbind*/  
      57. 

    57.     error = add_bind_files(drv);  
      58. 

    58.     if (error) {  
      59. 

    59.         /* Ditto */  
      60. 

    60.         printk(KERN_ERR "%s: add_bind_files(%s) failed
",  
      61. 

    61.             __func__, drv->name);  
      62. 

    62.     }  
      63. 

    63.     /*通知用户空间???*/  
      64. 

    64.     kobject_uevent(&priv->kobj, KOBJ_ADD);  
      65. 

    65.     return 0;  
      66. 

    66. out_unregister:  
      67. 

    67.     kfree(drv->p);  
      68. 

    68.     drv->p = NULL;  
      69. 

    69.     kobject_put(&priv->kobj);  
      70. 

    70. out_put_bus:  
      71. 

    71.     bus_put(bus);  
      72. 

    72.     return error;  
      73. 

    73. }  
      74. 

    

    在设置driver的kobj.kset为drivers目录所对应的kset之后，调用了kobject_init_and_add，我们来看下。
    


    7.6.1 kobject_init_and_add
    

    下列代码位于lib/kobject.c。
    


      

    1. /** 
      2. 

    2.  * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy 
      3. 

    3.  * @kobj: pointer to the kobject to initialize 
      4. 

    4.  * @ktype: pointer to the ktype for this kobject. 
      5. 

    5.  * @parent: pointer to the parent of this kobject. 
      6. 

    6.  * @fmt: the name of the kobject. 
      7. 

    7.  * 
      8. 

    8.  * This function combines the call to kobject_init() and 
      9. 

    9.  * kobject_add().  The same type of error handling after a call to 
      10. 

    10.  * kobject_add() and kobject lifetime rules are the same here. 
      11. 

    11.  */  
      12. 

    12. int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,  
      13. 

    13.              struct kobject *parent, const char *fmt, ...)  
      14. 

    14. {  
      15. 

    15.     va_list args;  
      16. 

    16.     int retval;  
      17. 

    17.   
      18. 

    18.     kobject_init(kobj, ktype);  
      19. 

    19.   
      20. 

    20.     va_start(args, fmt);  
      21. 

    21.     retval = kobject_add_varg(kobj, parent, fmt, args);  
      22. 

    22.     va_end(args);  
      23. 

    23.   
      24. 

    24.     return retval;  
      25. 

    25. }  
      26. 

    26. EXPORT_SYMBOL_GPL(kobject_init_and_add);  
      27. 

    

    该函数中调用了两个函数，这两个函数分别在6.1.2和6.2.2中讲述过，这里不再赘述。
    


    调用该函数时由于parent为NULL，但kobj.kset为drivers目录，所以将在/sys/bus/platform/drivers/下建立目录，名为s3c2410-spi。
    

    我们来验证下：
    

    [root@yj423 s3c2410-spi]#pwd
    /sys/bus/platform/drivers/s3c2410-spi
    

    接着由于drivers_autoprobe在bus_register执行的时候已经置1，将调用driver_attach。
    

    7.6.2 driver_attach
    

    下列代码位于drivers/base/dd.c。
    


      

    1. /** 
      2. 

    2.  * driver_attach - try to bind driver to devices. 
      3. 

    3.  * @drv: driver. 
      4. 

    4.  * 
      5. 

    5.  * Walk the list of devices that the bus has on it and try to 
      6. 

    6.  * match the driver with each one.  If driver_probe_device() 
      7. 

    7.  * returns 0 and the @dev->driver is set, we've found a 
      8. 

    8.  * compatible pair. 
      9. 

    9.  */  
      10. 

    10. int driver_attach(struct device_driver *drv)  
      11. 

    11. {  
      12. 

    12.     return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);  
      13. 

    13. }  
      14. 

    14. EXPORT_SYMBOL_GPL(driver_attach);  
      15. 


    

    该函数将调用bus_for_each_dev来寻找总线上的每个设备，这里的总线即为platform总线，然后尝试绑定设备。
    


    这里需要注意的是最后一个参数__driver_attach，这是一个函数名，后面将会调用它。
    


      

    1. /** 
      2. 

    2.  * bus_for_each_dev - device iterator. 
      3. 

    3.  * @bus: bus type. 
      4. 

    4.  * @start: device to start iterating from. 
      5. 

    5.  * @data: data for the callback. 
      6. 

    6.  * @fn: function to be called for each device. 
      7. 

    7.  * 
      8. 

    8.  * Iterate over @bus's list of devices, and call @fn for each, 
      9. 

    9.  * passing it @data. If @start is not NULL, we use that device to 
      10. 

    10.  * begin iterating from. 
      11. 

    11.  * 
      12. 

    12.  * We check the return of @fn each time. If it returns anything 
      13. 

    13.  * other than 0, we break out and return that value. 
      14. 

    14.  * 
      15. 

    15.  * NOTE: The device that returns a non-zero value is not retained 
      16. 

    16.  * in any way, nor is its refcount incremented. If the caller needs 
      17. 

    17.  * to retain this data, it should do, and increment the reference 
      18. 

    18.  * count in the supplied callback. 
      19. 

    19.  */  
      20. 

    20. int bus_for_each_dev(struct bus_type *bus, struct device *start,  
      21. 

    21.              void *data, int (*fn)(struct device *, void *))  
      22. 

    22. {  
      23. 

    23.     struct klist_iter i;  
      24. 

    24.     struct device *dev;  
      25. 

    25.     int error = 0;  
      26. 

    26.   
      27. 

    27.     if (!bus)  
      28. 

    28.         return -EINVAL;  
      29. 

    29.   
      30. 

    30.     klist_iter_init_node(&bus->p->klist_devices, &i,  
      31. 

    31.                  (start ? &start->p->knode_bus : NULL));  
      32. 

    32.     while ((dev = next_device(&i)) && !error)  
      33. 

    33.         error = fn(dev, data);  
      34. 

    34.     klist_iter_exit(&i);  
      35. 

    35.     return error;  
      36. 

    36. }  
      37. 

    37. EXPORT_SYMBOL_GPL(bus_for_each_dev);  
      38. 


    

    通过klist将遍历该总线上的所有设备，并为其调用__driver_attach函数。
    



      

    1. static int __driver_attach(struct device *dev, void *data)  
      2. 

    2. {  
      3. 

    3.     struct device_driver *drv = data;  
      4. 

    4.   
      5. 

    5.     /* 
      6. 

    6.      * Lock device and try to bind to it. We drop the error 
      7. 

    7.      * here and always return 0, because we need to keep trying 
      8. 

    8.      * to bind to devices and some drivers will return an error 
      9. 

    9.      * simply if it didn't support the device. 
      10. 

    10.      * 
      11. 

    11.      * driver_probe_device() will spit a warning if there 
      12. 

    12.      * is an error. 
      13. 

    13.      */  
      14. 

    14.   
      15. 

    15.     if (!driver_match_device(drv, dev))  
      16. 

    16.         return 0;  
      17. 

    17.   
      18. 

    18.     if (dev->parent) /* Needed for USB */  
      19. 

    19.         down(&dev->parent->sem);  
      20. 

    20.     down(&dev->sem);  
      21. 

    21.     if (!dev->driver)  
      22. 

    22.         driver_probe_device(drv, dev);  
      23. 

    23.     up(&dev->sem);  
      24. 

    24.     if (dev->parent)  
      25. 

    25.         up(&dev->parent->sem);  
      26. 

    26.   
      27. 

    27.     return 0;  
      28. 

    28. }  
      29. 


    

    首先调用了driver_match_device函数，该函数进会进行匹配，如果匹配成功将返回1。我们看下这个函数：
    



      

    1. static inline int driver_match_device(struct device_driver *drv,  
      2. 

    2.                       struct device *dev)  
      3. 

    3. {  
      4. 

    4.     return drv->bus->match ? drv->bus->match(dev, drv) : 1;  
      5. 

    5. }  
      6. 


    


    这里直接调用了platform总线的match方法，我们来看下这个方法。
    


      

    1. /** 
      2. 

    2.  * platform_match - bind platform device to platform driver. 
      3. 

    3.  * @dev: device. 
      4. 

    4.  * @drv: driver. 
      5. 

    5.  * 
      6. 

    6.  * Platform device IDs are assumed to be encoded like this: 
      7. 

    7.  * "<name><instance>", where <name> is a short description of the type of 
      8. 

    8.  * device, like "pci" or "floppy", and <instance> is the enumerated 
      9. 

    9.  * instance of the device, like '0' or '42'.  Driver IDs are simply 
      10. 

    10.  * "<name>".  So, extract the <name> from the platform_device structure, 
      11. 

    11.  * and compare it against the name of the driver. Return whether they match 
      12. 

    12.  * or not. 
      13. 

    13.  */  
      14. 

    14. static int platform_match(struct device *dev, struct device_driver *drv)  
      15. 

    15. {  
      16. 

    16.     struct platform_device *pdev = to_platform_device(dev);  
      17. 

    17.     struct platform_driver *pdrv = to_platform_driver(drv);  
      18. 

    18.   
      19. 

    19.     /* match against the id table first */  
      20. 

    20.     if (pdrv->id_table)  
      21. 

    21.         return platform_match_id(pdrv->id_table, pdev) != NULL;  
      22. 

    22.   
      23. 

    23.     /* fall-back to driver name match */  
      24. 

    24.     return (strcmp(pdev->name, drv->name) == 0);  
      25. 

    25. }  
      26. 


    

    该方法的核心其实就是使用stcmp进行字符匹配，判断pdev->name和drv->name是否相等。
    


    在本例中两者同为s3c2410-spi。因此匹配完成，返回1。
    

    返回后，由于dev->driver为NULL，将调用driver_probe_device函数。我们来看下：
    


      

    1. /** 
      2. 

    2.  * driver_probe_device - attempt to bind device & driver together 
      3. 

    3.  * @drv: driver to bind a device to 
      4. 

    4.  * @dev: device to try to bind to the driver 
      5. 

    5.  * 
      6. 

    6.  * This function returns -ENODEV if the device is not registered, 
      7. 

    7.  * 1 if the device is bound sucessfully and 0 otherwise. 
      8. 

    8.  * 
      9. 

    9.  * This function must be called with @dev->sem held.  When called for a 
      10. 

    10.  * USB interface, @dev->parent->sem must be held as well. 
      11. 

    11.  */  
      12. 

    12. int driver_probe_device(struct device_driver *drv, struct device *dev)  
      13. 

    13. {  
      14. 

    14.     int ret = 0;  
      15. 

    15.   
      16. 

    16.     if (!device_is_registered(dev))  
      17. 

    17.         return -ENODEV;  
      18. 

    18.   
      19. 

    19.     pr_debug("bus: '%s': %s: matched device %s with driver %s
",  
      20. 

    20.          drv->bus->name, __func__, dev_name(dev), drv->name);  
      21. 

    21.   
      22. 

    22.     ret = really_probe(dev, drv);  
      23. 

    23.   
      24. 

    24.     return ret;  
      25. 

    25. }  
      26. 

    26. static inline int device_is_registered(struct device *dev)  
      27. 

    27. {  
      28. 

    28.     return dev->kobj.state_in_sysfs;  
      29. 

    29. }  
      30. 


    

    该函数将调用really_probe来绑定设备和它的驱动。
    

      

    1. static int really_probe(struct device *dev, struct device_driver *drv)  
      2. 

    2. {  
      3. 

    3.     int ret = 0;  
      4. 

    4.   
      5. 

    5.     atomic_inc(&probe_count);  
      6. 

    6.     pr_debug("bus: '%s': %s: probing driver %s with device %s
",  
      7. 

    7.          drv->bus->name, __func__, drv->name, dev_name(dev));  
      8. 

    8.     WARN_ON(!list_empty(&dev->devres_head));  
      9. 

    9.   
      10. 

    10.     dev->driver = drv;  
      11. 

    11.     if (driver_sysfs_add(dev)) {    /*创建两个symlink，更新sysfs*/  
      12. 

    12.         printk(KERN_ERR "%s: driver_sysfs_add(%s) failed
",  
      13. 

    13.             __func__, dev_name(dev));  
      14. 

    14.         goto probe_failed;  
      15. 

    15.     }  
      16. 

    16.   
      17. 

    17.     if (dev->bus->probe) {  
      18. 

    18.         ret = dev->bus->probe(dev);/*调用总线的probe方法*/  
      19. 

    19.         if (ret)  
      20. 

    20.             goto probe_failed;  
      21. 

    21.     } else if (drv->probe) {  
      22. 

    22.         ret = drv->probe(dev);   /*调用驱动的probe方法*/  
      23. 

    23.         if (ret)  
      24. 

    24.             goto probe_failed;  
      25. 

    25.     }  
      26. 

    26.   
      27. 

    27.     driver_bound(dev);              /*绑定设备和驱动*/  
      28. 

    28.     ret = 1;  
      29. 

    29.     pr_debug("bus: '%s': %s: bound device %s to driver %s
",  
      30. 

    30.          drv->bus->name, __func__, dev_name(dev), drv->name);  
      31. 

    31.     goto done;  
      32. 

    32.   
      33. 

    33. probe_failed:  
      34. 

    34.     devres_release_all(dev);  
      35. 

    35.     driver_sysfs_remove(dev);  
      36. 

    36.     dev->driver = NULL;  
      37. 

    37.   
      38. 

    38.     if (ret != -ENODEV && ret != -ENXIO) {  
      39. 

    39.         /* driver matched but the probe failed */  
      40. 

    40.         printk(KERN_WARNING  
      41. 

    41.                "%s: probe of %s failed with error %d
",  
      42. 

    42.                drv->name, dev_name(dev), ret);  
      43. 

    43.     }  
      44. 

    44.     /* 
      45. 

    45.      * Ignore errors returned by ->probe so that the next driver can try 
      46. 

    46.      * its luck. 
      47. 

    47.      */  
      48. 

    48.     ret = 0;  
      49. 

    49. done:  
      50. 

    50.     atomic_dec(&probe_count);  
      51. 

    51.     wake_up(&probe_waitqueue);  
      52. 

    52.     return ret;  
      53. 

    53. }  
      54. 


    


    在这个函数中调用4个函数。
    

    第一个函数driver_sysfs_add将更新sysfs。
    



      

    1. static int driver_sysfs_add(struct device *dev)  
      2. 

    2. {  
      3. 

    3.     int ret;  
      4. 

    4.     /* 在/sys/bus/XXX/drivers/XXX目录下建立symlink，链接名为kobj->name， 
      5. 

    5.        链接指向/sys/devices/platform/XXX */  
      6. 

    6.     ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,  
      7. 

    7.               kobject_name(&dev->kobj));  
      8. 

    8.     if (ret == 0) {  
      9. 

    9.         /* 在/sys/devices/platform/XXX/下建立symlink，链接名为driver， 
      10. 

    10.           指向/sys/bus/xxx/drivers目录下的某个目录*/  
      11. 

    11.         ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,  
      12. 

    12.                     "driver");  
      13. 

    13.         if (ret)  
      14. 

    14.             sysfs_remove_link(&dev->driver->p->kobj,  
      15. 

    15.                     kobject_name(&dev->kobj));  
      16. 

    16.     }  
      17. 

    17.     return ret;  
      18. 

    18. }  
      19. 


    


    执行完以后，建立了两个链接。
    


    在/sys/bus/platform/drivers/s3c2410-spi下建立链接，指向/sys/devices/platform/s3c2410-spi.0
    

    在/sys/devices/platform/s3c2410-spi.0下建立链接，指向/sys/devices/platform/s3c2410-spi.0。
    

    这样就在用户空间呈现出驱动和设备的关系了。我们来验证下。
    


    [root@yj423 s3c2410-spi]#pwd
    /sys/bus/platform/drivers/s3c2410-spi
    [root@yj423 s3c2410-spi]#ll s3c2410-spi.0 
    lrwxrwxrwx    1 root     root             0 Jan  1 02:28 s3c2410-spi.0 -> ../../../../devices/platform/s3c2410-spi.0
    

    [root@yj423 s3c2410-spi.0]#pwd
    /sys/devices/platform/s3c2410-spi.0
    [root@yj423 s3c2410-spi.0]#ll driver
    lrwxrwxrwx    1 root     root             0 Jan  1 02:26 driver -> ../../../bus/platform/drivers/s3c2410-spi
    

    第2个函数执行总线的probe方法，由于platform总线没有提供probe方法，因此不执行。
    

    第3个函数执行驱动的probe方法，驱动提供了probe，因此调用它，该函数的细节超过了本文的讨论内容，所以略过。
    

    第4个函数执行driver_bound，用来绑定设备和驱动，来看下这个函数。
    


      

    1. static void driver_bound(struct device *dev)  
      2. 

    2. {  
      3. 

    3.     if (klist_node_attached(&dev->p->knode_driver)) {  
      4. 

    4.         printk(KERN_WARNING "%s: device %s already bound
",  
      5. 

    5.             __func__, kobject_name(&dev->kobj));  
      6. 

    6.         return;  
      7. 

    7.     }  
      8. 

    8.   
      9. 

    9.     pr_debug("driver: '%s': %s: bound to device '%s'
", dev_name(dev),  
      10. 

    10.          __func__, dev->driver->name);  
      11. 

    11.   
      12. 

    12.     if (dev->bus)  
      13. 

    13.         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,  
      14. 

    14.                          BUS_NOTIFY_BOUND_DRIVER, dev);  
      15. 

    15.   
      16. 

    16.     klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);  
      17. 

    17. }  
      18. 


    

    其实，所谓的绑定，就是将设备的驱动节点添加到驱动支持的设备链表中。
    


    至此，通过内核链表，这个platform device 和platform driver 已经绑定完成，将继续遍历内核链表尝试匹配和绑定，直到链表结束。
    

    在driver_attach执行完毕以后，bus_add_driver函数还有些剩余工作要完成。
    

    首先，将驱动添加到总线的驱动列表中。
    

    接着，如果定义了驱动属性文件，则创建。
    

    最后，在/sys/bus/platform/drivers/s3c2410-spi/下建立属性文件uevent，并在同一目录下建立文件bind和unbind。
    

    我们来验证下：
    

    [root@yj423 s3c2410-spi]#pwd
    /sys/bus/platform/drivers/s3c2410-spi
    [root@yj423 s3c2410-spi]#ls
    bind           s3c2410-spi.0  uevent         unbind
    

    7.7 小结
    

    在本节中，我们看到了platform driver是如何注册到内核中，在注册过程中，通过更新了sysfs，向用户空间展示总线，设备和驱动之间的关系。
    

    同时，还更新了链表的指向，在内核中体现了同样的关系。
    

    最后以platform driver的注册过程结束本章。
    

    

    

    8. sysfs底层函数
    

    下面讲述的内容将基于VFS，有关VFS的基本内容超过本文的范围，请参考<<深入理解Linux内核>>一书的第12章。
    

    在前面讲述的过程中，我们知道设备驱动模型是如何通过kobject将总线，设备和驱动间的层次关系在用户空间呈现出来的。事实上，就是通过目录，文件和symlink来呈现相互之间的关系。在前面的叙述中，我们并没有对目录，文件和symlink的创建进行 讲解，本章就对这些底层函数进行讲解。在讲解这些函数之前，我们先来看下，sysfs文件系统是如何注册的。
    

    8.1 注册sysfs文件系统
    

    sysfs文件系统的注册是调用sysfs_init函数来完成的，该函数在内核启动阶段被调用，我们来看下大致函数调用流程，这里不作分析。
    

    start_kernel( ) ->  vfs_caches_init( ) ->  mnt_init( ) ->  mnt_init( ) ->  sysfs_init( )。
    

    


      

    1. int __init sysfs_init(void)  
      2. 

    2. {  
      3. 

    3.     int err = -ENOMEM;  
      4. 

    4.     /*建立cache,名字为sysfs_dir_cache*/  
      5. 

    5.     sysfs_dir_cachep = kmem_cache_create("sysfs_dir_cache",  
      6. 

    6.                           sizeof(struct sysfs_dirent),  
      7. 

    7.                           0, 0, NULL);  
      8. 

    8.     if (!sysfs_dir_cachep)  
      9. 

    9.         goto out;  
      10. 

    10.   
      11. 

    11.     err = sysfs_inode_init();  
      12. 

    12.     if (err)  
      13. 

    13.         goto out_err;  
      14. 

    14.     /*注册文件系统*/  
      15. 

    15.     err = register_filesystem(&sysfs_fs_type);  
      16. 

    16.     if (!err) {  
      17. 

    17.         /*注册成功，加载文件系统*/  
      18. 

    18.         sysfs_mount = kern_mount(&sysfs_fs_type);  
      19. 

    19.         if (IS_ERR(sysfs_mount)) {  
      20. 

    20.             printk(KERN_ERR "sysfs: could not mount!
");  
      21. 

    21.             err = PTR_ERR(sysfs_mount);  
      22. 

    22.             sysfs_mount = NULL;  
      23. 

    23.             unregister_filesystem(&sysfs_fs_type);  
      24. 

    24.             goto out_err;  
      25. 

    25.         }  
      26. 

    26.     } else  
      27. 

    27.         goto out_err;  
      28. 

    28. out:  
      29. 

    29.     return err;  
      30. 

    30. out_err:  
      31. 

    31.     kmem_cache_destroy(sysfs_dir_cachep);  
      32. 

    32.     sysfs_dir_cachep = NULL;  
      33. 

    33.     goto out;  
      34. 

    34. }  
      35. 

    35.   
      36. 

    36. static struct file_system_type sysfs_fs_type = {  
      37. 

    37.     .name        = "sysfs",  
      38. 

    38.     .get_sb        = sysfs_get_sb,  
      39. 

    39.     .kill_sb    = kill_anon_super,  
      40. 

    40. };  
      41. 

    



    8.1.1 register_filesystem
    

    下列代码位于fs/filesystems.c。
    


      

    1. /** 
      2. 

    2.  *  register_filesystem - register a new filesystem 
      3. 

    3.  *  @fs: the file system structure 
      4. 

    4.  * 
      5. 

    5.  *  Adds the file system passed to the list of file systems the kernel 
      6. 

    6.  *  is aware of for mount and other syscalls. Returns 0 on success, 
      7. 

    7.  *  or a negative errno code on an error. 
      8. 

    8.  * 
      9. 

    9.  *  The &struct file_system_type that is passed is linked into the kernel  
      10. 

    10.  *  structures and must not be freed until the file system has been 
      11. 

    11.  *  unregistered. 
      12. 

    12.  */  
      13. 

    13.    
      14. 

    14. int register_filesystem(struct file_system_type * fs)  
      15. 

    15. {  
      16. 

    16.     int res = 0;  
      17. 

    17.     struct file_system_type ** p;  
      18. 

    18.   
      19. 

    19.     BUG_ON(strchr(fs->name, '.'));  
      20. 

    20.     if (fs->next)  
      21. 

    21.         return -EBUSY;  
      22. 

    22.     INIT_LIST_HEAD(&fs->fs_supers);  
      23. 

    23.     write_lock(&file_systems_lock);  
      24. 

    24.     p = find_filesystem(fs->name, strlen(fs->name));  /*查找要住的文件是同是否存在，返回位置*/  
      25. 

    25.     if (*p)  
      26. 

    26.         res = -EBUSY;   /*该文件系统已存在，返回error*/  
      27. 

    27.     else  
      28. 

    28.         *p = fs;        /*将新的文件系统加入到链表中*/  
      29. 

    29.     write_unlock(&file_systems_lock);  
      30. 

    30.     return res;  
      31. 

    31. }  
      32. 

    



      

    1. static struct file_system_type **find_filesystem(const char *name, unsigned len)  
      2. 

    2. {  
      3. 

    3.     struct file_system_type **p;  
      4. 

    4.     for (p=&file_systems; *p; p=&(*p)->next)  
      5. 

    5.         if (strlen((*p)->name) == len &&  
      6. 

    6.             strncmp((*p)->name, name, len) == 0)  
      7. 

    7.             break;  
      8. 

    8.     return p;  
      9. 

    9. }  
      10. 

    

    


    

    该函数将调用函数file_system_type，此函数根据name字段（sysfs）来查找要注册的文件系统是否已经存在。
    


    如果不存在，表示还未注册，则将新的fs添加到链表中，链表的第一项为全局变量file_systems。
    

    该全局变量为单项链表，所有已注册的文件系统都被插入到这个链表当中。
    

    8.1.2 kern_mount函数
    

    下列代码位于include/linux/fs.h
    


      

    1. #define kern_mount(type) kern_mount_data(type, NULL)  
      2. 

    

    下列代码位于fs/sysfs/mount.c
    

      

    1. struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)  
      2. 

    2. {  
      3. 

    3.     return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);  
      4. 

    4. }  
      5. 

    5.   
      6. 

    6. EXPORT_SYMBOL_GPL(kern_mount_data);  
      7. 

    


    kern_mount实际上最后是调用了vfs_kern_mount函数。我们来看下：
    


      

    1. struct vfsmount *  
      2. 

    2. vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)  
      3. 

    3. {  
      4. 

    4.     struct vfsmount *mnt;  
      5. 

    5.     char *secdata = NULL;  
      6. 

    6.     int error;  
      7. 

    7.   
      8. 

    8.     if (!type)  
      9. 

    9.         return ERR_PTR(-ENODEV);  
      10. 

    10.   
      11. 

    11.     error = -ENOMEM;  
      12. 

    12.     mnt = alloc_vfsmnt(name);   /*分配struct vfsmount*/  
      13. 

    13.     if (!mnt)  
      14. 

    14.         goto out;  
      15. 

    15.   
      16. 

    16.     if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {  
      17. 

    17.         secdata = alloc_secdata();  
      18. 

    18.         if (!secdata)  
      19. 

    19.             goto out_mnt;  
      20. 

    20.   
      21. 

    21.         error = security_sb_copy_data(data, secdata);  
      22. 

    22.         if (error)  
      23. 

    23.             goto out_free_secdata;  
      24. 

    24.     }  
      25. 

    25.         /*get_sb方法，分配superblock对象，并初始化*/  
      26. 

    26.     error = type->get_sb(type, flags, name, data, mnt);  
      27. 

    27.     if (error < 0)  
      28. 

    28.         goto out_free_secdata;  
      29. 

    29.     BUG_ON(!mnt->mnt_sb);  
      30. 

    30.   
      31. 

    31.     error = security_sb_kern_mount(mnt->mnt_sb, flags, secdata);  
      32. 

    32.     if (error)  
      33. 

    33.         goto out_sb;  
      34. 

    34.   
      35. 

    35.     mnt->mnt_mountpoint = mnt->mnt_root;/*设置挂载点的dentry*/  
      36. 

    36.     mnt->mnt_parent = mnt;           /*设置所挂载的fs为自己本身*/  
      37. 

    37.     up_write(&mnt->mnt_sb->s_umount);  
      38. 

    38.     free_secdata(secdata);  
      39. 

    39.     return mnt;  
      40. 

    40. out_sb:  
      41. 

    41.     dput(mnt->mnt_root);  
      42. 

    42.     deactivate_locked_super(mnt->mnt_sb);  
      43. 

    43. out_free_secdata:  
      44. 

    44.     free_secdata(secdata);  
      45. 

    45. out_mnt:  
      46. 

    46.     free_vfsmnt(mnt);  
      47. 

    47. out:  
      48. 

    48.     return ERR_PTR(error);  
      49. 

    49. }  
      50. 

    


    该函数在首先调用alloc_vfsmnt来分配struct vfsmount结构，并做了一些初试化工作。
    


    下列函数位于fs/super.c
    


      

    1. struct vfsmount *alloc_vfsmnt(const char *name)  
      2. 

    2. {  
      3. 

    3.     struct vfsmount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);  
      4. 

    4.     if (mnt) {  
      5. 

    5.         int err;  
      6. 

    6.   
      7. 

    7.         err = mnt_alloc_id(mnt);    /*设置mnt->mnt_id*/  
      8. 

    8.         if (err)  
      9. 

    9.             goto out_free_cache;  
      10. 

    10.   
      11. 

    11.         if (name) {  
      12. 

    12.             mnt->mnt_devname = kstrdup(name, GFP_KERNEL); /*拷贝name，并赋值*/  
      13. 

    13.             if (!mnt->mnt_devname)  
      14. 

    14.                 goto out_free_id;  
      15. 

    15.         }  
      16. 

    16.   
      17. 

    17.         atomic_set(&mnt->mnt_count, 1);  
      18. 

    18.         INIT_LIST_HEAD(&mnt->mnt_hash);  
      19. 

    19.         INIT_LIST_HEAD(&mnt->mnt_child);  
      20. 

    20.         INIT_LIST_HEAD(&mnt->mnt_mounts);  
      21. 

    21.         INIT_LIST_HEAD(&mnt->mnt_list);  
      22. 

    22.         INIT_LIST_HEAD(&mnt->mnt_expire);  
      23. 

    23.         INIT_LIST_HEAD(&mnt->mnt_share);  
      24. 

    24.         INIT_LIST_HEAD(&mnt->mnt_slave_list);  
      25. 

    25.         INIT_LIST_HEAD(&mnt->mnt_slave);  
      26. 

    26.         atomic_set(&mnt->__mnt_writers, 0);  
      27. 

    27.     }  
      28. 

    28.     return mnt;  
      29. 

    29.   
      30. 

    30. out_free_id:  
      31. 

    31.     mnt_free_id(mnt);  
      32. 

    32. out_free_cache:  
      33. 

    33.     kmem_cache_free(mnt_cache, mnt);  
      34. 

    34.     return NULL;  
      35. 

    35. }  
      36. 


    

    分配好结构体以后，由于参数data为NULL，将直接调用文件系统类型提供的get_sb方法，该方法就是函数sysfs_get_sb。我们来看下：
    


    下列函数位于fs/sysfs/mount.c。
    


      

    1. static int sysfs_get_sb(struct file_system_type *fs_type,  
      2. 

    2.     int flags, const char *dev_name, void *data, struct vfsmount *mnt)  
      3. 

    3. {  
      4. 

    4.     return get_sb_single(fs_type, flags, data, sysfs_fill_super, mnt);  
      5. 

    5. }  
      6. 


    

    这里直接调用了get_sb_single函数，注意这里的第4个实参sysfs_fill_super，该参数是函数名，后面将会调用该函数。
    


    该函数将分配sysfs文件系统的superblock，获取文件系统根目录的inode和dentry。
    

    该函数的执行过程相当复杂，在下一节单独讲述。
    

    8.2 get_sb_single函数
    

    下列函数位于fs/sysfs/mount.c。
    


      

    1. int get_sb_single(struct file_system_type *fs_type,  
      2. 

    2.     int flags, void *data,  
      3. 

    3.     int (*fill_super)(struct super_block *, void *, int),  
      4. 

    4.     struct vfsmount *mnt)  
      5. 

    5. {  
      6. 

    6.     struct super_block *s;  
      7. 

    7.     int error;  
      8. 

    8.     /*查找或者创建super_block*/  
      9. 

    9.     s = sget(fs_type, compare_single, set_anon_super, NULL);  
      10. 

    10.     if (IS_ERR(s))  
      11. 

    11.         return PTR_ERR(s);  
      12. 

    12.     if (!s->s_root) {        /*没有根目录dentry*/  
      13. 

    13.         s->s_flags = flags;  
      14. 

    14.         /*获取root( / )的 inode和dentry*/  
      15. 

    15.         error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);  
      16. 

    16.         if (error) {  
      17. 

    17.             deactivate_locked_super(s);  
      18. 

    18.             return error;  
      19. 

    19.         }  
      20. 

    20.         s->s_flags |= MS_ACTIVE;  
      21. 

    21.     }  
      22. 

    22.     do_remount_sb(s, flags, data, 0);  
      23. 

    23.     simple_set_mnt(mnt, s); /*设置vfsmount的superblock和根dentry*/  
      24. 

    24.     return 0;  
      25. 

    25. }  
      26. 

    26.   
      27. 

    27. EXPORT_SYMBOL(get_sb_single);  
      28. 


    


    8.2.1 sget函数
    

    首先调用了sget函数来查找是否
    

    下列函数位于fs/super.c。
    


      

    1. /** 
      2. 

    2.  *  sget    -   find or create a superblock 
      3. 

    3.  *  @type:  filesystem type superblock should belong to 
      4. 

    4.  *  @test:  comparison callback 
      5. 

    5.  *  @set:   setup callback 
      6. 

    6.  *  @data:  argument to each of them 
      7. 

    7.  */  
      8. 

    8. struct super_block *sget(struct file_system_type *type,  
      9. 

    9.             int (*test)(struct super_block *,void *),  
      10. 

    10.             int (*set)(struct super_block *,void *),  
      11. 

    11.             void *data)  
      12. 

    12. {  
      13. 

    13.     struct super_block *s = NULL;  
      14. 

    14.     struct super_block *old;  
      15. 

    15.     int err;  
      16. 

    16.   
      17. 

    17. retry:  
      18. 

    18.     spin_lock(&sb_lock);  
      19. 

    19.     if (test) {           
      20. 

    20.         /*遍历所有属于该文件系统的super_block*/  
      21. 

    21.         list_for_each_entry(old, &type->fs_supers, s_instances) {  
      22. 

    22.             if (!test(old, data))  
      23. 

    23.                 continue;  
      24. 

    24.             if (!grab_super(old))  
      25. 

    25.                 goto retry;  
      26. 

    26.             if (s) {  
      27. 

    27.                 up_write(&s->s_umount);  
      28. 

    28.                 destroy_super(s);  
      29. 

    29.             }  
      30. 

    30.             return old;  
      31. 

    31.         }  
      32. 

    32.     }  
      33. 

    33.     if (!s) {  
      34. 

    34.         spin_unlock(&sb_lock);  
      35. 

    35.         s = alloc_super(type);  /*创建新的super_block并初始化*/  
      36. 

    36.         if (!s)  
      37. 

    37.             return ERR_PTR(-ENOMEM);  
      38. 

    38.         goto retry;  
      39. 

    39.     }  
      40. 

    40.           
      41. 

    41.     err = set(s, data);     /*设置s->s_dev */  
      42. 

    42.     if (err) {  
      43. 

    43.         spin_unlock(&sb_lock);  
      44. 

    44.         up_write(&s->s_umount);  
      45. 

    45.         destroy_super(s);  
      46. 

    46.         return ERR_PTR(err);  
      47. 

    47.     }  
      48. 

    48.     s->s_type = type;  
      49. 

    49.     strlcpy(s->s_id, type->name, sizeof(s->s_id)); /*拷贝name*/  
      50. 

    50.     list_add_tail(&s->s_list, &super_blocks);        /*将新的super_block添加到链表头super_blocks中*/  
      51. 

    51.     list_add(&s->s_instances, &type->fs_supers);  /*将新的super_block添加到相应的文件系统类型的链表中*/  
      52. 

    52.     spin_unlock(&sb_lock);  
      53. 

    53.     get_filesystem(type);  
      54. 

    54.     return s;  
      55. 

    55. }  
      56. 

    56.   
      57. 

    57. EXPORT_SYMBOL(sget);  
      58. 


    

    该函数将遍历属于sysfs文件系统的所有superblock，本例中由于之前没有任何superblock创建，遍历立即结束。
    


    然后调用alloc_super函数来创建新的struct super_block。
    

    下列函数位于fs/super.c。
    


      

    1. /** 
      2. 

    2.  *  alloc_super -   create new superblock 
      3. 

    3.  *  @type:  filesystem type superblock should belong to 
      4. 

    4.  * 
      5. 

    5.  *  Allocates and initializes a new &struct super_block.  alloc_super() 
      6. 

    6.  *  returns a pointer new superblock or %NULL if allocation had failed. 
      7. 

    7.  */  
      8. 

    8. static struct super_block *alloc_super(struct file_system_type *type)  
      9. 

    9. {  
      10. 

    10.     struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);/*分配并清0super_block*/  
      11. 

    11.     static struct super_operations default_op;  
      12. 

    12.   
      13. 

    13.     if (s) {  
      14. 

    14.         if (security_sb_alloc(s)) {  
      15. 

    15.             kfree(s);  
      16. 

    16.             s = NULL;  
      17. 

    17.             goto out;  
      18. 

    18.         }  
      19. 

    19.         INIT_LIST_HEAD(&s->s_dirty);  
      20. 

    20.         INIT_LIST_HEAD(&s->s_io);  
      21. 

    21.         INIT_LIST_HEAD(&s->s_more_io);  
      22. 

    22.         INIT_LIST_HEAD(&s->s_files);  
      23. 

    23.         INIT_LIST_HEAD(&s->s_instances);  
      24. 

    24.         INIT_HLIST_HEAD(&s->s_anon);  
      25. 

    25.         INIT_LIST_HEAD(&s->s_inodes);  
      26. 

    26.         INIT_LIST_HEAD(&s->s_dentry_lru);  
      27. 

    27.         INIT_LIST_HEAD(&s->s_async_list);  
      28. 

    28.         init_rwsem(&s->s_umount);  
      29. 

    29.         mutex_init(&s->s_lock);  
      30. 

    30.         lockdep_set_class(&s->s_umount, &type->s_umount_key);  
      31. 

    31.         /* 
      32. 

    32.          * The locking rules for s_lock are up to the 
      33. 

    33.          * filesystem. For example ext3fs has different 
      34. 

    34.          * lock ordering than usbfs: 
      35. 

    35.          */  
      36. 

    36.         lockdep_set_class(&s->s_lock, &type->s_lock_key);  
      37. 

    37.         /* 
      38. 

    38.          * sget() can have s_umount recursion. 
      39. 

    39.          * 
      40. 

    40.          * When it cannot find a suitable sb, it allocates a new 
      41. 

    41.          * one (this one), and tries again to find a suitable old 
      42. 

    42.          * one. 
      43. 

    43.          * 
      44. 

    44.          * In case that succeeds, it will acquire the s_umount 
      45. 

    45.          * lock of the old one. Since these are clearly distrinct 
      46. 

    46.          * locks, and this object isn't exposed yet, there's no 
      47. 

    47.          * risk of deadlocks. 
      48. 

    48.          * 
      49. 

    49.          * Annotate this by putting this lock in a different 
      50. 

    50.          * subclass. 
      51. 

    51.          */  
      52. 

    52.         down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);  
      53. 

    53.         s->s_count = S_BIAS;  
      54. 

    54.         atomic_set(&s->s_active, 1);  
      55. 

    55.         mutex_init(&s->s_vfs_rename_mutex);  
      56. 

    56.         mutex_init(&s->s_dquot.dqio_mutex);  
      57. 

    57.         mutex_init(&s->s_dquot.dqonoff_mutex);  
      58. 

    58.         init_rwsem(&s->s_dquot.dqptr_sem);  
      59. 

    59.         init_waitqueue_head(&s->s_wait_unfrozen);  
      60. 

    60.         s->s_maxbytes = MAX_NON_LFS;  
      61. 

    61.         s->dq_op = sb_dquot_ops;  
      62. 

    62.         s->s_qcop = sb_quotactl_ops;  
      63. 

    63.         s->s_op = &default_op;  
      64. 

    64.         s->s_time_gran = 1000000000;  
      65. 

    65.     }  
      66. 

    66. out:  
      67. 

    67.     return s;  
      68. 

    68. }  
      69. 


    

    分配完以后，调用作为参数传入的函数指针set，也就是set_anon_super函数，该函数用来设置s->s_dev。
    


    下列函数位于fs/super.c。
    


      

    1. int set_anon_super(struct super_block *s, void *data)  
      2. 

    2. {  
      3. 

    3.     int dev;  
      4. 

    4.     int error;  
      5. 

    5.   
      6. 

    6.  retry:  
      7. 

    7.     if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)/*分配ID号*/  
      8. 

    8.         return -ENOMEM;  
      9. 

    9.     spin_lock(&unnamed_dev_lock);  
      10. 

    10.     error = ida_get_new(&unnamed_dev_ida, &dev);/*获取ID号，保存在dev中*/  
      11. 

    11.     spin_unlock(&unnamed_dev_lock);  
      12. 

    12.     if (error == -EAGAIN)  
      13. 

    13.         /* We raced and lost with another CPU. */  
      14. 

    14.         goto retry;  
      15. 

    15.     else if (error)  
      16. 

    16.         return -EAGAIN;  
      17. 

    17.   
      18. 

    18.     if ((dev & MAX_ID_MASK) == (1 << MINORBITS)) {  
      19. 

    19.         spin_lock(&unnamed_dev_lock);  
      20. 

    20.         ida_remove(&unnamed_dev_ida, dev);  
      21. 

    21.         spin_unlock(&unnamed_dev_lock);  
      22. 

    22.         return -EMFILE;  
      23. 

    23.     }  
      24. 

    24.     s->s_dev = MKDEV(0, dev & MINORMASK);    /*构建设备号*/  
      25. 

    25.     return 0;  
      26. 

    26. }  
      27. 


    


    8.2.2  sysfs_fill_super函数
    

    分配了super_block之后，将判断该super_block是否有root dentry。本例中，显然没有。然后调用形参fill_super指向的函数，也就是sysfs_fill_super函数。
    

    下列函数位于fs/sysfs/mount.c。
    



      

    1. struct super_block * sysfs_sb = NULL;  
      2. 

    2.   
      3. 

    3. static int sysfs_fill_super(struct super_block *sb, void *data, int silent)  
      4. 

    4. {  
      5. 

    5.     struct inode *inode;  
      6. 

    6.     struct dentry *root;  
      7. 

    7.   
      8. 

    8.     sb->s_blocksize = PAGE_CACHE_SIZE;   /*4KB*/  
      9. 

    9.     sb->s_blocksize_bits = PAGE_CACHE_SHIFT; /*4KB*/  
      10. 

    10.     sb->s_magic = SYSFS_MAGIC;           /*0x62656572*/  
      11. 

    11.     sb->s_op = &sysfs_ops;  
      12. 

    12.     sb->s_time_gran = 1;  
      13. 

    13.     sysfs_sb = sb;      /*sysfs_sb即为sysfs的super_block*/  
      14. 

    14.   
      15. 

    15.     /* get root inode, initialize and unlock it */  
      16. 

    16.     mutex_lock(&sysfs_mutex);  
      17. 

    17.     inode = sysfs_get_inode(&sysfs_root); /*sysfs_root即为sysfs所在的根目录的dirent，，获取inode*/         
      18. 

    18.     mutex_unlock(&sysfs_mutex);  
      19. 

    19.     if (!inode) {  
      20. 

    20.         pr_debug("sysfs: could not get root inode
");  
      21. 

    21.         return -ENOMEM;  
      22. 

    22.     }  
      23. 

    23.   
      24. 

    24.     /* instantiate and link root dentry */  
      25. 

    25.     root = d_alloc_root(inode); /*为获得的根inode分配root(/) dentry*/  
      26. 

    26.     if (!root) {  
      27. 

    27.         pr_debug("%s: could not get root dentry!
",__func__);  
      28. 

    28.         iput(inode);  
      29. 

    29.         return -ENOMEM;  
      30. 

    30.     }  
      31. 

    31.     root->d_fsdata = &sysfs_root;  
      32. 

    32.     sb->s_root = root;   /*保存superblock的根dentry*/  
      33. 

    33.     return 0;  
      34. 

    34. }  
      35. 

    35.   
      36. 

    36. struct sysfs_dirent sysfs_root = {    /*sysfs_root即为sysfs所在的根目录的dirent*/  
      37. 

    37.     .s_name        = "",  
      38. 

    38.     .s_count    = ATOMIC_INIT(1),  
      39. 

    39.     .s_flags    = SYSFS_DIR,  
      40. 

    40.     .s_mode        = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,  
      41. 

    41.     .s_ino        = 1,  
      42. 

    42. };  
      43. 


    


    在设置了一些字段后，设置了sysfs_sb这个全局变量，该全局变量表示的就是sysfs的super_block。
    


    随后，调用了sysfs_get_inode函数，来获取sysfs的根目录的dirent。该函数的参数sysfs_root为全局变量，表示sysfs的根目录的sysfs_dirent。
    

    我们看些这个sysfs_dirent数据结构：
    


      

    1. /* 
      2. 

    2.  * sysfs_dirent - the building block of sysfs hierarchy.  Each and 
      3. 

    3.  * every sysfs node is represented by single sysfs_dirent. 
      4. 

    4.  * 
      5. 

    5.  * As long as s_count reference is held, the sysfs_dirent itself is 
      6. 

    6.  * accessible.  Dereferencing s_elem or any other outer entity 
      7. 

    7.  * requires s_active reference. 
      8. 

    8.  */  
      9. 

    9. struct sysfs_dirent {  
      10. 

    10.     atomic_t        s_count;  
      11. 

    11.     atomic_t        s_active;  
      12. 

    12.     struct sysfs_dirent *s_parent;  
      13. 

    13.     struct sysfs_dirent *s_sibling;  
      14. 

    14.     const char      *s_name;  
      15. 

    15.   
      16. 

    16.     union {  
      17. 

    17.         struct sysfs_elem_dir       s_dir;  
      18. 

    18.         struct sysfs_elem_symlink   s_symlink;  
      19. 

    19.         struct sysfs_elem_attr      s_attr;  
      20. 

    20.         struct sysfs_elem_bin_attr  s_bin_attr;  
      21. 

    21.     };  
      22. 

    22.   
      23. 

    23.     unsigned int        s_flags;  
      24. 

    24.     ino_t           s_ino;  
      25. 

    25.     umode_t         s_mode;  
      26. 

    26.     struct iattr        *s_iattr;  
      27. 

    27. };  
      28. 


    

    其中比较关键的就是那个联合体，针对不同的形式（目录，symlink，属性文件和可执行文件）将使用不同的数据结构。
    


    另外，sysfs_dirent将最为dentry的fs专有数据被保存下来，这一点会在下面中看到。
    

    接着，在来看下sysfs_get_inode函数：
    

    下列函数位于fs/sysfs/inode.c。
    


      

    1. /** 
      2. 

    2.  *  sysfs_get_inode - get inode for sysfs_dirent 
      3. 

    3.  *  @sd: sysfs_dirent to allocate inode for 
      4. 

    4.  * 
      5. 

    5.  *  Get inode for @sd.  If such inode doesn't exist, a new inode 
      6. 

    6.  *  is allocated and basics are initialized.  New inode is 
      7. 

    7.  *  returned locked. 
      8. 

    8.  * 
      9. 

    9.  *  LOCKING: 
      10. 

    10.  *  Kernel thread context (may sleep). 
      11. 

    11.  * 
      12. 

    12.  *  RETURNS: 
      13. 

    13.  *  Pointer to allocated inode on success, NULL on failure. 
      14. 

    14.  */  
      15. 

    15. struct inode * sysfs_get_inode(struct sysfs_dirent *sd)  
      16. 

    16. {  
      17. 

    17.     struct inode *inode;  
      18. 

    18.   
      19. 

    19.     inode = iget_locked(sysfs_sb, sd->s_ino);    /*在inode cache查找inode是否存在，不存在侧创建一个*/  
      20. 

    20.     if (inode && (inode->i_state & I_NEW))       /*如果是新创建的inode，则包含I_NEW*/  
      21. 

    21.         sysfs_init_inode(sd, inode);  
      22. 

    22.   
      23. 

    23.     return inode;  
      24. 

    24. }  
      25. 

    25.   
      26. 

    26. /** 
      27. 

    27.  * iget_locked - obtain an inode from a mounted file system 
      28. 

    28.  * @sb:        super block of file system 
      29. 

    29.  * @ino:    inode number to get 
      30. 

    30.  * 
      31. 

    31.  * iget_locked() uses ifind_fast() to search for the inode specified by @ino in 
      32. 

    32.  * the inode cache and if present it is returned with an increased reference 
      33. 

    33.  * count. This is for file systems where the inode number is sufficient for 
      34. 

    34.  * unique identification of an inode. 
      35. 

    35.  * 
      36. 

    36.  * If the inode is not in cache, get_new_inode_fast() is called to allocate a 
      37. 

    37.  * new inode and this is returned locked, hashed, and with the I_NEW flag set. 
      38. 

    38.  * The file system gets to fill it in before unlocking it via 
      39. 

    39.  * unlock_new_inode(). 
      40. 

    40.  */  
      41. 

    41. struct inode *iget_locked(struct super_block *sb, unsigned long ino)  
      42. 

    42. {  
      43. 

    43.     struct hlist_head *head = inode_hashtable + hash(sb, ino);  
      44. 

    44.     struct inode *inode;  
      45. 

    45.   
      46. 

    46.     inode = ifind_fast(sb, head, ino);/*在inode cache查找该inode*/  
      47. 

    47.     if (inode)  
      48. 

    48.         return inode;         /*找到了该inode*/  
      49. 

    49.     /* 
      50. 

    50.      * get_new_inode_fast() will do the right thing, re-trying the search 
      51. 

    51.      * in case it had to block at any point. 
      52. 

    52.      */  
      53. 

    53.     return get_new_inode_fast(sb, head, ino);    /*分配一个新的inode*/  
      54. 

    54. }  
      55. 

    55. EXPORT_SYMBOL(iget_locked);  
      56. 

    56.   
      57. 

    57. static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)  
      58. 

    58. {  
      59. 

    59.     struct bin_attribute *bin_attr;  
      60. 

    60.   
      61. 

    61.     inode->i_private = sysfs_get(sd);  
      62. 

    62.     inode->i_mapping->a_ops = &sysfs_aops;  
      63. 

    63.     inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;  
      64. 

    64.     inode->i_op = &sysfs_inode_operations;  
      65. 

    65.     inode->i_ino = sd->s_ino;  
      66. 

    66.     lockdep_set_class(&inode->i_mutex, &sysfs_inode_imutex_key);  
      67. 

    67.   
      68. 

    68.     if (sd->s_iattr) {  
      69. 

    69.         /* sysfs_dirent has non-default attributes 
      70. 

    70.          * get them for the new inode from persistent copy 
      71. 

    71.          * in sysfs_dirent 
      72. 

    72.          */  
      73. 

    73.         set_inode_attr(inode, sd->s_iattr);  
      74. 

    74.     } else  
      75. 

    75.         set_default_inode_attr(inode, sd->s_mode);/*设置inode属性*/  
      76. 

    76.   
      77. 

    77.   
      78. 

    78.     /* initialize inode according to type */  
      79. 

    79.     switch (sysfs_type(sd)) {  
      80. 

    80.     case SYSFS_DIR:  
      81. 

    81.         inode->i_op = &sysfs_dir_inode_operations;  
      82. 

    82.         inode->i_fop = &sysfs_dir_operations;  
      83. 

    83.         inode->i_nlink = sysfs_count_nlink(sd);  
      84. 

    84.         break;  
      85. 

    85.     case SYSFS_KOBJ_ATTR:  
      86. 

    86.         inode->i_size = PAGE_SIZE;  
      87. 

    87.         inode->i_fop = &sysfs_file_operations;  
      88. 

    88.         break;  
      89. 

    89.     case SYSFS_KOBJ_BIN_ATTR:  
      90. 

    90.         bin_attr = sd->s_bin_attr.bin_attr;  
      91. 

    91.         inode->i_size = bin_attr->size;  
      92. 

    92.         inode->i_fop = &bin_fops;  
      93. 

    93.         break;  
      94. 

    94.     case SYSFS_KOBJ_LINK:  
      95. 

    95.         inode->i_op = &sysfs_symlink_inode_operations;  
      96. 

    96.         break;  
      97. 

    97.     default:  
      98. 

    98.         BUG();  
      99. 

    99.     }  
      100. 

    100.   
      101. 

    101.     unlock_new_inode(inode);  
      102. 

    102. }  
      103. 


    

    该函数首先调用了，iget_locked来查找该inode是否已存在，如果不存在则创建。如果是新创建的inode，则对inode进行初始化。
    再获取了根目录的inode和sysfs_dirent后，调用d_alloc_root来获得dirent。
    



      

    1. /** 
      2. 

    2.  * d_alloc_root - allocate root dentry 
      3. 

    3.  * @root_inode: inode to allocate the root for 
      4. 

    4.  * 
      5. 

    5.  * Allocate a root ("/") dentry for the inode given. The inode is 
      6. 

    6.  * instantiated and returned. %NULL is returned if there is insufficient 
      7. 

    7.  * memory or the inode passed is %NULL. 
      8. 

    8.  */  
      9. 

    9.    
      10. 

    10. struct dentry * d_alloc_root(struct inode * root_inode)  
      11. 

    11. {  
      12. 

    12.     struct dentry *res = NULL;  
      13. 

    13.   
      14. 

    14.     if (root_inode) {  
      15. 

    15.         static const struct qstr name = { .name = "/", .len = 1 };  
      16. 

    16.   
      17. 

    17.         res = d_alloc(NULL, &name); /*分配struct dentry，没有父dentry*/  
      18. 

    18.         if (res) {  
      19. 

    19.             res->d_sb = root_inode->i_sb;  
      20. 

    20.             res->d_parent = res;   
      21. 

    21.             d_instantiated_instantiate(res, root_inode); /*绑定inode和dentry之间的关系*/  
      22. 

    22.         }  
      23. 

    23.     }  
      24. 

    24.     return res;  
      25. 

    25. }  
      26. 

    26.   
      27. 

    27. /** 
      28. 

    28.  * d_alloc    -    allocate a dcache entry 
      29. 

    29.  * @parent: parent of entry to allocate 
      30. 

    30.  * @name: qstr of the name 
      31. 

    31.  * 
      32. 

    32.  * Allocates a dentry. It returns %NULL if there is insufficient memory 
      33. 

    33.  * available. On a success the dentry is returned. The name passed in is 
      34. 

    34.  * copied and the copy passed in may be reused after this call. 
      35. 

    35.  */  
      36. 

    36.    
      37. 

    37. struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)  
      38. 

    38. {  
      39. 

    39.     struct dentry *dentry;  
      40. 

    40.     char *dname;  
      41. 

    41.   
      42. 

    42.     dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL);/*分配struct dentry*/  
      43. 

    43.     if (!dentry)  
      44. 

    44.         return NULL;  
      45. 

    45.   
      46. 

    46.     if (name->len > DNAME_INLINE_LEN-1) {  
      47. 

    47.         dname = kmalloc(name->len + 1, GFP_KERNEL);  
      48. 

    48.         if (!dname) {  
      49. 

    49.             kmem_cache_free(dentry_cache, dentry);   
      50. 

    50.             return NULL;  
      51. 

    51.         }  
      52. 

    52.     } else  {  
      53. 

    53.         dname = dentry->d_iname;  
      54. 

    54.     }      
      55. 

    55.     dentry->d_name.name = dname;  
      56. 

    56.   
      57. 

    57.     dentry->d_name.len = name->len;  
      58. 

    58.     dentry->d_name.hash = name->hash;  
      59. 

    59.     memcpy(dname, name->name, name->len);  
      60. 

    60.     dname[name->len] = 0;  
      61. 

    61.   
      62. 

    62.     atomic_set(&dentry->d_count, 1);  
      63. 

    63.     dentry->d_flags = DCACHE_UNHASHED;  
      64. 

    64.     spin_lock_init(&dentry->d_lock);  
      65. 

    65.     dentry->d_inode = NULL;  
      66. 

    66.     dentry->d_parent = NULL;  
      67. 

    67.     dentry->d_sb = NULL;  
      68. 

    68.     dentry->d_op = NULL;  
      69. 

    69.     dentry->d_fsdata = NULL;  
      70. 

    70.     dentry->d_mounted = 0;  
      71. 

    71.     INIT_HLIST_NODE(&dentry->d_hash);  
      72. 

    72.     INIT_LIST_HEAD(&dentry->d_lru);  
      73. 

    73.     INIT_LIST_HEAD(&dentry->d_subdirs);  
      74. 

    74.     INIT_LIST_HEAD(&dentry->d_alias);  
      75. 

    75.   
      76. 

    76.     if (parent) {    /*有父目录，则设置指针来表示关系*/  
      77. 

    77.         dentry->d_parent = dget(parent);  
      78. 

    78.         dentry->d_sb = parent->d_sb;  /*根dentry的父对象为自己*/  
      79. 

    79.     } else {  
      80. 

    80.         INIT_LIST_HEAD(&dentry->d_u.d_child);  
      81. 

    81.     }  
      82. 

    82.   
      83. 

    83.     spin_lock(&dcache_lock);  
      84. 

    84.     if (parent)        /*有父目录，则添加到父目录的儿子链表中*/  
      85. 

    85.         list_add(&dentry->d_u.d_child, &parent->d_subdirs);  
      86. 

    86.     dentry_stat.nr_dentry++;  
      87. 

    87.     spin_unlock(&dcache_lock);  
      88. 

    88.   
      89. 

    89.     return dentry;  
      90. 

    90. }   
      91. 

    91.   
      92. 

    92. /** 
      93. 

    93.  * d_instantiate - fill in inode information for a dentry 
      94. 

    94.  * @entry: dentry to complete 
      95. 

    95.  * @inode: inode to attach to this dentry 
      96. 

    96.  * 
      97. 

    97.  * Fill in inode information in the entry. 
      98. 

    98.  * 
      99. 

    99.  * This turns negative dentries into productive full members 
      100. 

    100.  * of society. 
      101. 

    101.  * 
      102. 

    102.  * NOTE! This assumes that the inode count has been incremented 
      103. 

    103.  * (or otherwise set) by the caller to indicate that it is now 
      104. 

    104.  * in use by the dcache. 
      105. 

    105.  */  
      106. 

    106.    
      107. 

    107. void d_instantiate(struct dentry *entry, struct inode * inode)  
      108. 

    108. {  
      109. 

    109.     BUG_ON(!list_empty(&entry->d_alias));  
      110. 

    110.     spin_lock(&dcache_lock);  
      111. 

    111.     __d_instantiate(entry, inode);  
      112. 

    112.     spin_unlock(&dcache_lock);  
      113. 

    113.     security_d_instantiate(entry, inode);  
      114. 

    114. }  
      115. 

    115.   
      116. 

    116. /* the caller must hold dcache_lock */  
      117. 

    117. static void __d_instantiate(struct dentry *dentry, struct inode *inode)  
      118. 

    118. {  
      119. 

    119.     if (inode)  
      120. 

    120.         list_add(&dentry->d_alias, &inode->i_dentry);/*将dentry添加到inode的链表中*/  
      121. 

    121.     dentry->d_inode = inode;        /*保存dentry对应的inode*/  
      122. 

    122.     fsnotify_d_instantiate(dentry, inode);  
      123. 

    123. }  
      124. 


    


    该函数首先调用了d_alloc来创建struct dentry，参数parent为NULL，既然是为根( / )建立dentry，自然没有父对象。
    


    接着调用d_instantiate来绑定inode和dentry之间的关系。
    


    在sysfs_fill_super函数执行的最后，将sysfs_root保存到了dentry->d_fsdata。
    

    可见，在sysfs中用sysfs_dirent来表示目录，但是对于VFS，还是要使用dentry来表示目录。
    

    8.2.3  do_remount_sb
    

    下列代码位于fs/super.c。
    


      

    1. /** 
      2. 

    2.  *  do_remount_sb - asks filesystem to change mount options. 
      3. 

    3.  *  @sb:    superblock in question 
      4. 

    4.  *  @flags: numeric part of options 
      5. 

    5.  *  @data:  the rest of options 
      6. 

    6.  *      @force: whether or not to force the change 
      7. 

    7.  * 
      8. 

    8.  *  Alters the mount options of a mounted file system. 
      9. 

    9.  */  
      10. 

    10. int do_remount_sb(struct super_block *sb, int flags, void *data, int force)  
      11. 

    11. {  
      12. 

    12.     int retval;  
      13. 

    13.     int remount_rw;  
      14. 

    14.       
      15. 

    15. #ifdef CONFIG_BLOCK  
      16. 

    16.     if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))  
      17. 

    17.         return -EACCES;  
      18. 

    18. #endif  
      19. 

    19.     if (flags & MS_RDONLY)  
      20. 

    20.         acct_auto_close(sb);  
      21. 

    21.     shrink_dcache_sb(sb);  
      22. 

    22.     fsync_super(sb);  
      23. 

    23.   
      24. 

    24.     /* If we are remounting RDONLY and current sb is read/write, 
      25. 

    25.        make sure there are no rw files opened */  
      26. 

    26.     if ((flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY)) {  
      27. 

    27.         if (force)  
      28. 

    28.             mark_files_ro(sb);  
      29. 

    29.         else if (!fs_may_remount_ro(sb))  
      30. 

    30.             return -EBUSY;  
      31. 

    31.         retval = vfs_dq_off(sb, 1);  
      32. 

    32.         if (retval < 0 && retval != -ENOSYS)  
      33. 

    33.             return -EBUSY;  
      34. 

    34.     }  
      35. 

    35.     remount_rw = !(flags & MS_RDONLY) && (sb->s_flags & MS_RDONLY);  
      36. 

    36.   
      37. 

    37.     if (sb->s_op->remount_fs) {  
      38. 

    38.         lock_super(sb);  
      39. 

    39.         retval = sb->s_op->remount_fs(sb, &flags, data);  
      40. 

    40.         unlock_super(sb);  
      41. 

    41.         if (retval)  
      42. 

    42.             return retval;  
      43. 

    43.     }  
      44. 

    44.     sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);  
      45. 

    45.     if (remount_rw)  
      46. 

    46.         vfs_dq_quota_on_remount(sb);  
      47. 

    47.     return 0;  
      48. 

    48. }  
      49. 


    


    这个函数用来修改挂在选项，这个函数就不分析了，不是重点。
    


    8.2.4simple_set_mnt
    

    下列函数位于fs/namespace.c。
    


      

    1. void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb)  
      2. 

    2. {  
      3. 

    3.     mnt->mnt_sb = sb;  
      4. 

    4.     mnt->mnt_root = dget(sb->s_root);  
      5. 

    5. }  
      6. 


    

    该函数设置了vfsmount的superblock和根dentry。

    


    8.2.5 小结
    

    这里，对sysfs的注册过程做一个总结。
    

    sysfs_init函数调用过程示意图如下：
    

    

    在整个过程中，先后使用和创建了许多struct
    

    第一，根据file_system_type表示的sysfs文件系统的类型注册了sysfs。
    

    第二，建立了vfsmount。
    

    第三，创建了超级块super_block。
    

    第四，根据sysfs_dirent表示的根目录，建立了inode。
    

    最后，根据刚才建立的inode创建了dentry。
    

    除了sysfs_dirent，其他5个结构体都是VFS中基本的数据结构，而sysfs_dirent则是特定于sysfs文件系统的数据结构。
    

    8.3 创建目录
    

    在前面的描述中，使用sysfs_create_dir在sysfs下建立一个目录。我们来看下这个函数是如何来建立目录的。
    

    下列代码位于fs/sysfs/dir.c。
    


      

    1. /** 
      2. 

    2.  *  sysfs_create_dir - create a directory for an object. 
      3. 

    3.  *  @kobj:      object we're creating directory for.  
      4. 

    4.  */  
      5. 

    5. int sysfs_create_dir(struct kobject * kobj)  
      6. 

    6. {  
      7. 

    7.     struct sysfs_dirent *parent_sd, *sd;  
      8. 

    8.     int error = 0;  
      9. 

    9.   
      10. 

    10.     BUG_ON(!kobj);  
      11. 

    11.   
      12. 

    12.     if (kobj->parent)    /*如果有parent，获取parent对应的sys目录*/  
      13. 

    13.         parent_sd = kobj->parent->sd;  
      14. 

    14.     else                /*没有则是在sys根目录*/  
      15. 

    15.         parent_sd = &sysfs_root;  
      16. 

    16.   
      17. 

    17.     error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);  
      18. 

    18.     if (!error)  
      19. 

    19.         kobj->sd = sd;  
      20. 

    20.     return error;  
      21. 

    21. }  
      22. 


    


    函数中，首先获取待建目录的父sysfs_dirent，然后将它作为参数 来调用create_dir函数。
    


    很明显，就是要在父sysfs_dirent下建立新的sysfs_dirent，新建立的sysfs_dirent将保存到参数sd中。
    

    下列代码位于fs/sysfs/dir.c。
    


      

    1. static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,  
      2. 

    2.               const char *name, struct sysfs_dirent **p_sd)  
      3. 

    3. {  
      4. 

    4.     umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;  
      5. 

    5.     struct sysfs_addrm_cxt acxt;  
      6. 

    6.     struct sysfs_dirent *sd;  
      7. 

    7.     int rc;  
      8. 

    8.   
      9. 

    9.     /* allocate */  /*分配sysfs_dirent并初始化*/  
      10. 

    10.     sd = sysfs_new_dirent(name, mode, SYSFS_DIR);  
      11. 

    11.     if (!sd)  
      12. 

    12.         return -ENOMEM;  
      13. 

    13.     sd->s_dir.kobj = kobj;    /*保存kobject对象*/  
      14. 

    14.   
      15. 

    15.     /* link in */  
      16. 

    16.     sysfs_addrm_start(&acxt, parent_sd);/*寻找父sysfs_dirent对应的inode*/  
      17. 

    17.     rc = sysfs_add_one(&acxt, sd);  /*检查父sysfs_dirent下是否已有有该sysfs_dirent，没有则添加到父sysfs_dirent中*/  
      18. 

    18.     sysfs_addrm_finish(&acxt);      /*收尾工作*/  
      19. 

    19.   
      20. 

    20.     if (rc == 0)        /*rc为0表示创建成功*/  
      21. 

    21.         *p_sd = sd;  
      22. 

    22.     else  
      23. 

    23.         sysfs_put(sd);  /*增加引用计数*/  
      24. 

    24.   
      25. 

    25.     return rc;  
      26. 

    26. }  
      27. 


    

    这里要注意一下mode变量，改变了使用了宏定义SYSFS_DIR，这个就表示要创建的是一个目录。
    

    mode还有几个宏定义可以使用，如下：
    

      

    1. #define SYSFS_KOBJ_ATTR         0x0002  
      2. 

    2. #define SYSFS_KOBJ_BIN_ATTR     0x0004  
      3. 

    3. #define SYSFS_KOBJ_LINK         0x0008  
      4. 

    4. #define SYSFS_COPY_NAME         (SYSFS_DIR | SYSFS_KOBJ_LINK)  
      5. 


    


    8.3.1 sysfs_new_dirent 
    

      在create_dir函数中，首先调用了sysfs_new_dirent来建立一个新的sysfs_dirent结构体。
    

    下列代码位于fs/sysfs/dir.c。
    


      

    1. struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)  
      2. 

    2. {  
      3. 

    3.     char *dup_name = NULL;  
      4. 

    4.     struct sysfs_dirent *sd;  
      5. 

    5.   
      6. 

    6.     if (type & SYSFS_COPY_NAME) {  
      7. 

    7.         name = dup_name = kstrdup(name, GFP_KERNEL);  
      8. 

    8.         if (!name)  
      9. 

    9.             return NULL;  
      10. 

    10.     }  
      11. 

    11.     /*分配sysfs_dirent并清0*/  
      12. 

    12.     sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);  
      13. 

    13.     if (!sd)  
      14. 

    14.         goto err_out1;  
      15. 

    15.   
      16. 

    16.     if (sysfs_alloc_ino(&sd->s_ino)) /*分配ID号*/  
      17. 

    17.         goto err_out2;  
      18. 

    18.   
      19. 

    19.     atomic_set(&sd->s_count, 1);  
      20. 

    20.     atomic_set(&sd->s_active, 0);  
      21. 

    21.   
      22. 

    22.     sd->s_name = name;  
      23. 

    23.     sd->s_mode = mode;  
      24. 

    24.     sd->s_flags = type;  
      25. 

    25.   
      26. 

    26.     return sd;  
      27. 

    27.   
      28. 

    28.  err_out2:  
      29. 

    29.     kmem_cache_free(sysfs_dir_cachep, sd);  
      30. 

    30.  err_out1:  
      31. 

    31.     kfree(dup_name);  
      32. 

    32.     return NULL;  
      33. 

    33. }  
      34. 


    


    8.3.2 有关sysfs_dirent中的联合体
    

    分配了sysfs_dirent后，设置了该结构中的联合体数据。先来看下联合体中的四个数据结构。
    


      

    1. /* type-specific structures for sysfs_dirent->s_* union members */  
      2. 

    2. struct sysfs_elem_dir {  
      3. 

    3.     struct kobject      *kobj;  
      4. 

    4.     /* children list starts here and goes through sd->s_sibling */  
      5. 

    5.     struct sysfs_dirent *children;  
      6. 

    6. };  
      7. 

    7.   
      8. 

    8. struct sysfs_elem_symlink {  
      9. 

    9.     struct sysfs_dirent    *target_sd;  
      10. 

    10. };  
      11. 

    11.   
      12. 

    12. struct sysfs_elem_attr {  
      13. 

    13.     struct attribute    *attr;  
      14. 

    14.     struct sysfs_open_dirent *open;  
      15. 

    15. };  
      16. 

    16.   
      17. 

    17. struct sysfs_elem_bin_attr {  
      18. 

    18.     struct bin_attribute    *bin_attr;  
      19. 

    19.     struct hlist_head    buffers;  
      20. 

    20. };  
      21. 


    

    根据sysfs_dirent所代表的类型不同，也就是目录，synlink，属性文件和bin文件，将分别使用该联合体中相应的struct。
    


    在本例中要创建的是目录，自然使用sysfs_elem_dir结构体，然后保存了kobject对象。
    

    在8.4和8.5中我们将分别看到sysfs_elem_attr和sysfs_elem_symlink的使用。
    

    8.3.3 sysfs_addrm_start
    

    在获取了父sysfs_dirent，调用sysfs_addrm_start来获取与之对应的inode。
    

    下列代码位于fs/sysfs/dir.c。
    


      

    1. /** 
      2. 

    2.  *  sysfs_addrm_start - prepare for sysfs_dirent add/remove 
      3. 

    3.  *  @acxt: pointer to sysfs_addrm_cxt to be used 
      4. 

    4.  *  @parent_sd: parent sysfs_dirent 
      5. 

    5.  * 
      6. 

    6.  *  This function is called when the caller is about to add or 
      7. 

    7.  *  remove sysfs_dirent under @parent_sd.  This function acquires 
      8. 

    8.  *  sysfs_mutex, grabs inode for @parent_sd if available and lock 
      9. 

    9.  *  i_mutex of it.  @acxt is used to keep and pass context to 
      10. 

    10.  *  other addrm functions. 
      11. 

    11.  * 
      12. 

    12.  *  LOCKING: 
      13. 

    13.  *  Kernel thread context (may sleep).  sysfs_mutex is locked on 
      14. 

    14.  *  return.  i_mutex of parent inode is locked on return if 
      15. 

    15.  *  available. 
      16. 

    16.  */  
      17. 

    17. void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,  
      18. 

    18.                struct sysfs_dirent *parent_sd)  
      19. 

    19. {  
      20. 

    20.     struct inode *inode;  
      21. 

    21.   
      22. 

    22.     memset(acxt, 0, sizeof(*acxt));  
      23. 

    23.     acxt->parent_sd = parent_sd;  
      24. 

    24.   
      25. 

    25.     /* Lookup parent inode.  inode initialization is protected by 
      26. 

    26.      * sysfs_mutex, so inode existence can be determined by 
      27. 

    27.      * looking up inode while holding sysfs_mutex. 
      28. 

    28.      */  
      29. 

    29.     mutex_lock(&sysfs_mutex);  
      30. 

    30.     /*根据parent_sd来寻找父inode*/  
      31. 

    31.     inode = ilookup5(sysfs_sb, parent_sd->s_ino, sysfs_ilookup_test,  
      32. 

    32.              parent_sd);  
      33. 

    33.     if (inode) {  
      34. 

    34.         WARN_ON(inode->i_state & I_NEW);  
      35. 

    35.   
      36. 

    36.         /* parent inode available */  
      37. 

    37.         acxt->parent_inode = inode;      /*保存找到的父inode*/  
      38. 

    38.   
      39. 

    39.         /* sysfs_mutex is below i_mutex in lock hierarchy. 
      40. 

    40.          * First, trylock i_mutex.  If fails, unlock 
      41. 

    41.          * sysfs_mutex and lock them in order. 
      42. 

    42.          */  
      43. 

    43.         if (!mutex_trylock(&inode->i_mutex)) {  
      44. 

    44.             mutex_unlock(&sysfs_mutex);  
      45. 

    45.             mutex_lock(&inode->i_mutex);  
      46. 

    46.             mutex_lock(&sysfs_mutex);  
      47. 

    47.         }  
      48. 

    48.     }  
      49. 

    49. }  
      50. 

    50.   
      51. 

    51. /* 
      52. 

    52.  * Context structure to be used while adding/removing nodes. 
      53. 

    53.  */  
      54. 

    54. struct sysfs_addrm_cxt {  
      55. 

    55.     struct sysfs_dirent    *parent_sd;  
      56. 

    56.     struct inode        *parent_inode;  
      57. 

    57.     struct sysfs_dirent    *removed;  
      58. 

    58.     int            cnt;  
      59. 

    59. };  
      60. 


    

    注意形参sysfs_addrm_cxt，该结构作用是临时存放数据。
    


    8.3.4 sysfs_add_one
    

    下列代码位于fs/sysfs/dir.c。
    


      

    1. /** 
      2. 

    2.  *  sysfs_add_one - add sysfs_dirent to parent 
      3. 

    3.  *  @acxt: addrm context to use 
      4. 

    4.  *  @sd: sysfs_dirent to be added 
      5. 

    5.  * 
      6. 

    6.  *  Get @acxt->parent_sd and set sd->s_parent to it and increment 
      7. 

    7.  *  nlink of parent inode if @sd is a directory and link into the 
      8. 

    8.  *  children list of the parent. 
      9. 

    9.  * 
      10. 

    10.  *  This function should be called between calls to 
      11. 

    11.  *  sysfs_addrm_start() and sysfs_addrm_finish() and should be 
      12. 

    12.  *  passed the same @acxt as passed to sysfs_addrm_start(). 
      13. 

    13.  * 
      14. 

    14.  *  LOCKING: 
      15. 

    15.  *  Determined by sysfs_addrm_start(). 
      16. 

    16.  * 
      17. 

    17.  *  RETURNS: 
      18. 

    18.  *  0 on success, -EEXIST if entry with the given name already 
      19. 

    19.  *  exists. 
      20. 

    20.  */  
      21. 

    21. int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)  
      22. 

    22. {  
      23. 

    23.     int ret;  
      24. 

    24.   
      25. 

    25.     ret = __sysfs_add_one(acxt, sd);  
      26. 

    26.     if (ret == -EEXIST) {  
      27. 

    27.         char *path = kzalloc(PATH_MAX, GFP_KERNEL);  
      28. 

    28.         WARN(1, KERN_WARNING  
      29. 

    29.              "sysfs: cannot create duplicate filename '%s'
",  
      30. 

    30.              (path == NULL) ? sd->s_name :  
      31. 

    31.              strcat(strcat(sysfs_pathname(acxt->parent_sd, path), "/"),  
      32. 

    32.                     sd->s_name));  
      33. 

    33.         kfree(path);  
      34. 

    34.     }  
      35. 

    35.   
      36. 

    36.     return ret;  
      37. 

    37. }  
      38. 

    38.   
      39. 

    39. /** 
      40. 

    40.  *    __sysfs_add_one - add sysfs_dirent to parent without warning 
      41. 

    41.  *    @acxt: addrm context to use 
      42. 

    42.  *    @sd: sysfs_dirent to be added 
      43. 

    43.  * 
      44. 

    44.  *    Get @acxt->parent_sd and set sd->s_parent to it and increment 
      45. 

    45.  *    nlink of parent inode if @sd is a directory and link into the 
      46. 

    46.  *    children list of the parent. 
      47. 

    47.  * 
      48. 

    48.  *    This function should be called between calls to 
      49. 

    49.  *    sysfs_addrm_start() and sysfs_addrm_finish() and should be 
      50. 

    50.  *    passed the same @acxt as passed to sysfs_addrm_start(). 
      51. 

    51.  * 
      52. 

    52.  *    LOCKING: 
      53. 

    53.  *    Determined by sysfs_addrm_start(). 
      54. 

    54.  * 
      55. 

    55.  *    RETURNS: 
      56. 

    56.  *    0 on success, -EEXIST if entry with the given name already 
      57. 

    57.  *    exists. 
      58. 

    58.  */  
      59. 

    59. int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)  
      60. 

    60. {  
      61. 

    61.     /*查找该parent_sd下有无将要建立的sd,没有返回NULL*/  
      62. 

    62.     if (sysfs_find_dirent(acxt->parent_sd, sd->s_name))  
      63. 

    63.         return -EEXIST;  
      64. 

    64.   
      65. 

    65.     sd->s_parent = sysfs_get(acxt->parent_sd);    /*设置父sysfs_dirent，增加父sysfs_dirent的引用计数*/  
      66. 

    66.   
      67. 

    67.     if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)    /*如果要创建的是目录或文件，并且有父inode*/  
      68. 

    68.         inc_nlink(acxt->parent_inode);    /*inode->i_nlink加1*/  
      69. 

    69.   
      70. 

    70.     acxt->cnt++;  
      71. 

    71.   
      72. 

    72.     sysfs_link_sibling(sd);  
      73. 

    73.   
      74. 

    74.     return 0;  
      75. 

    75. }  
      76. 

    76.   
      77. 

    77. /** 
      78. 

    78.  *    sysfs_find_dirent - find sysfs_dirent with the given name 
      79. 

    79.  *    @parent_sd: sysfs_dirent to search under 
      80. 

    80.  *    @name: name to look for 
      81. 

    81.  * 
      82. 

    82.  *    Look for sysfs_dirent with name @name under @parent_sd. 
      83. 

    83.  * 
      84. 

    84.  *    LOCKING: 
      85. 

    85.  *    mutex_lock(sysfs_mutex) 
      86. 

    86.  * 
      87. 

    87.  *    RETURNS: 
      88. 

    88.  *    Pointer to sysfs_dirent if found, NULL if not. 
      89. 

    89.  */  
      90. 

    90. struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,  
      91. 

    91.                        const unsigned char *name)  
      92. 

    92. {  
      93. 

    93.     struct sysfs_dirent *sd;  
      94. 

    94.   
      95. 

    95.     for (sd = parent_sd->s_dir.children; sd; sd = sd->s_sibling)  
      96. 

    96.         if (!strcmp(sd->s_name, name))  
      97. 

    97.             return sd;  
      98. 

    98.     return NULL;  
      99. 

    99. }   
      100. 

    100.   
      101. 

    101. /** 
      102. 

    102.  *    sysfs_link_sibling - link sysfs_dirent into sibling list 
      103. 

    103.  *    @sd: sysfs_dirent of interest 
      104. 

    104.  * 
      105. 

    105.  *    Link @sd into its sibling list which starts from 
      106. 

    106.  *    sd->s_parent->s_dir.children. 
      107. 

    107.  * 
      108. 

    108.  *    Locking: 
      109. 

    109.  *    mutex_lock(sysfs_mutex) 
      110. 

    110.  */  
      111. 

    111. static void sysfs_link_sibling(struct sysfs_dirent *sd)  
      112. 

    112. {  
      113. 

    113.     struct sysfs_dirent *parent_sd = sd->s_parent;  
      114. 

    114.     struct sysfs_dirent **pos;  
      115. 

    115.   
      116. 

    116.     BUG_ON(sd->s_sibling);  
      117. 

    117.   
      118. 

    118.     /* Store directory entries in order by ino.  This allows 
      119. 

    119.      * readdir to properly restart without having to add a 
      120. 

    120.      * cursor into the s_dir.children list. 
      121. 

    121.      */  
      122. 

    122.      /*children链表根据s_ino按升序排列，现在将sd插入到正确的儿子链表中*/  
      123. 

    123.     for (pos = &parent_sd->s_dir.children; *pos; pos = &(*pos)->s_sibling) {  
      124. 

    124.         if (sd->s_ino < (*pos)->s_ino)  
      125. 

    125.             break;  
      126. 

    126.     }  
      127. 

    127.     /*插入链表*/  
      128. 

    128.     sd->s_sibling = *pos;  
      129. 

    129.     *pos = sd;   
      130. 

    130. }  
      131. 


    

    该函数直接调用了__sysfs_add_one，后者先调用sysfs_find_dirent来查找该parent_sd下有无该的sysfs_dirent，如果没有，则设置创建好的新的sysfs_dirent的s_parent字段。也就是将新的sysfs_dirent添加到父sys_dirent中。接着调用sysfs_link_sibling函数，将新建的sysfs_dirent添加到sd->s_parent->s_dir.children链表中。
    


    8.3.5 sysfs_addrm_finish
    

    下列代码位于fs/sysfs/dir.c。
    


      

    1. /** 
      2. 

    2.  *  sysfs_addrm_finish - finish up sysfs_dirent add/remove 
      3. 

    3.  *  @acxt: addrm context to finish up 
      4. 

    4.  * 
      5. 

    5.  *  Finish up sysfs_dirent add/remove.  Resources acquired by 
      6. 

    6.  *  sysfs_addrm_start() are released and removed sysfs_dirents are 
      7. 

    7.  *  cleaned up.  Timestamps on the parent inode are updated. 
      8. 

    8.  * 
      9. 

    9.  *  LOCKING: 
      10. 

    10.  *  All mutexes acquired by sysfs_addrm_start() are released. 
      11. 

    11.  */  
      12. 

    12. void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)  
      13. 

    13. {  
      14. 

    14.     /* release resources acquired by sysfs_addrm_start() */  
      15. 

    15.     mutex_unlock(&sysfs_mutex);  
      16. 

    16.     if (acxt->parent_inode) {  
      17. 

    17.         struct inode *inode = acxt->parent_inode;  
      18. 

    18.   
      19. 

    19.         /* if added/removed, update timestamps on the parent */  
      20. 

    20.         if (acxt->cnt)  
      21. 

    21.             inode->i_ctime = inode->i_mtime = CURRENT_TIME;/*更新父inode的时间*/  
      22. 

    22.   
      23. 

    23.         mutex_unlock(&inode->i_mutex);  
      24. 

    24.         iput(inode);  
      25. 

    25.     }  
      26. 

    26.   
      27. 

    27.     /* kill removed sysfs_dirents */  
      28. 

    28.     while (acxt->removed) {  
      29. 

    29.         struct sysfs_dirent *sd = acxt->removed;  
      30. 

    30.   
      31. 

    31.         acxt->removed = sd->s_sibling;  
      32. 

    32.         sd->s_sibling = NULL;  
      33. 

    33.   
      34. 

    34.         sysfs_drop_dentry(sd);  
      35. 

    35.         sysfs_deactivate(sd);  
      36. 

    36.         unmap_bin_file(sd);  
      37. 

    37.         sysfs_put(sd);  
      38. 

    38.     }  
      39. 

    39. }  
      40. 


    


    该函数结束了添加sysfs_dirent的工作，这个就不多做说明了。
    



    至此，添加一个目录的工作已经完成了，添加目录的工作其实就是创建了一个新的sysfs_dirent，并把它添加到父sysfs_dirent中。
    

    下面我们看下如何添加属性文件。
    

    8.4 创建属性文件
    

    添加属性文件使用sysfs_create_file函数。
    

    下列函数位于fs/sysfs/file.c。
    


      

    1. /** 
      2. 

    2.  *  sysfs_create_file - create an attribute file for an object. 
      3. 

    3.  *  @kobj:  object we're creating for.  
      4. 

    4.  *  @attr:  attribute descriptor. 
      5. 

    5.  */  
      6. 

    6.   
      7. 

    7. int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)  
      8. 

    8. {  
      9. 

    9.     BUG_ON(!kobj || !kobj->sd || !attr);  
      10. 

    10.   
      11. 

    11.     return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);  
      12. 

    12.   
      13. 

    13. }  
      14. 

    14.   
      15. 

    15. int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,  
      16. 

    16.            int type)  
      17. 

    17. {  
      18. 

    18.     return sysfs_add_file_mode(dir_sd, attr, type, attr->mode);  
      19. 

    19. }  
      20. 

    20.   
      21. 

    21. int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,  
      22. 

    22.             const struct attribute *attr, int type, mode_t amode)  
      23. 

    23. {  
      24. 

    24.     umode_t mode = (amode & S_IALLUGO) | S_IFREG;  
      25. 

    25.     struct sysfs_addrm_cxt acxt;  
      26. 

    26.     struct sysfs_dirent *sd;  
      27. 

    27.     int rc;  
      28. 

    28.     /*分配sysfs_dirent并初始化*/  
      29. 

    29.     sd = sysfs_new_dirent(attr->name, mode, type);  
      30. 

    30.     if (!sd)  
      31. 

    31.         return -ENOMEM;  
      32. 

    32.     sd->s_attr.attr = (void *)attr;  
      33. 

    33.   
      34. 

    34.     sysfs_addrm_start(&acxt, dir_sd);    /*寻找父sysfs_dirent对应的inode*/  
      35. 

    35.     rc = sysfs_add_one(&acxt, sd);        /*检查父sysfs_dirent下是否已有有该sysfs_dirent，没有则创建*/  
      36. 

    36.     sysfs_addrm_finish(&acxt);            /*收尾工作*/  
      37. 

    37.   
      38. 

    38.     if (rc)            /*0表示创建成功*/   
      39. 

    39.         sysfs_put(sd);  
      40. 

    40.   
      41. 

    41.     return rc;  
      42. 

    42. }  
      43. 


    


    sysfs_create_file用参数SYSFS_KOBJ_ATTR（表示建立属性文件）来调用了sysfs_add_file，后者又直接调用了sysfs_add_file_mode。
    


    sysfs_add_file_mode函数的执行和8.3节的create_dir函数非常类似，只不过它并没有保存kobject对象，也就是说该sysfs_dirent并没有一个对应的kobject对象。
    

    需要注意的是，这里是建立属性文件，因此使用了联合体中的结构体s_attr。
    



    8.5 创建symlink
    

    最后，来看下symlink的建立。
    



      

    1. /** 
      2. 

    2.  *  sysfs_create_link - create symlink between two objects. 
      3. 

    3.  *  @kobj:  object whose directory we're creating the link in. 
      4. 

    4.  *  @target:    object we're pointing to. 
      5. 

    5.  *  @name:      name of the symlink. 
      6. 

    6.  */  
      7. 

    7. int sysfs_create_link(struct kobject *kobj, struct kobject *target,  
      8. 

    8.               const char *name)  
      9. 

    9. {  
      10. 

    10.     return sysfs_do_create_link(kobj, target, name, 1);  
      11. 

    11. }  
      12. 

    12.   
      13. 

    13. static int sysfs_do_create_link(struct kobject *kobj, struct kobject *target,  
      14. 

    14.                 const char *name, int warn)  
      15. 

    15. {  
      16. 

    16.     struct sysfs_dirent *parent_sd = NULL;  
      17. 

    17.     struct sysfs_dirent *target_sd = NULL;  
      18. 

    18.     struct sysfs_dirent *sd = NULL;  
      19. 

    19.     struct sysfs_addrm_cxt acxt;  
      20. 

    20.     int error;  
      21. 

    21.   
      22. 

    22.     BUG_ON(!name);  
      23. 

    23.   
      24. 

    24.     if (!kobj)    /*kobj为空，表示在sysyfs跟目录下建立symlink*/  
      25. 

    25.         parent_sd = &sysfs_root;  
      26. 

    26.     else        /*有父sysfs_dirent*/  
      27. 

    27.         parent_sd = kobj->sd;  
      28. 

    28.   
      29. 

    29.     error = -EFAULT;  
      30. 

    30.     if (!parent_sd)  
      31. 

    31.         goto out_put;  
      32. 

    32.   
      33. 

    33.     /* target->sd can go away beneath us but is protected with 
      34. 

    34.      * sysfs_assoc_lock.  Fetch target_sd from it. 
      35. 

    35.      */  
      36. 

    36.     spin_lock(&sysfs_assoc_lock);  
      37. 

    37.     if (target->sd)  
      38. 

    38.         target_sd = sysfs_get(target->sd);    、/*获取目标对象的sysfs_dirent*/  
      39. 

    39.     spin_unlock(&sysfs_assoc_lock);  
      40. 

    40.   
      41. 

    41.     error = -ENOENT;  
      42. 

    42.     if (!target_sd)  
      43. 

    43.         goto out_put;  
      44. 

    44.   
      45. 

    45.     error = -ENOMEM;  
      46. 

    46.     /*分配sysfs_dirent并初始化*/  
      47. 

    47.     sd = sysfs_new_dirent(name, S_IFLNK|S_IRWXUGO, SYSFS_KOBJ_LINK);  
      48. 

    48.     if (!sd)  
      49. 

    49.         goto out_put;  
      50. 

    50.   
      51. 

    51.     sd->s_symlink.target_sd = target_sd;/*保存目标sysfs_dirent*/  
      52. 

    52.     target_sd = NULL;    /* reference is now owned by the symlink */  
      53. 

    53.   
      54. 

    54.     sysfs_addrm_start(&acxt, parent_sd);/*寻找父sysfs_dirent对应的inode*/  
      55. 

    55.     if (warn)  
      56. 

    56.         error = sysfs_add_one(&acxt, sd);/*检查父sysfs_dirent下是否已有有该sysfs_dirent，没有则创建*/  
      57. 

    57.     else  
      58. 

    58.         error = __sysfs_add_one(&acxt, sd);  
      59. 

    59.     sysfs_addrm_finish(&acxt);            /*收尾工作*/  
      60. 

    60.   
      61. 

    61.     if (error)  
      62. 

    62.         goto out_put;  
      63. 

    63.   
      64. 

    64.     return 0;  
      65. 

    65.   
      66. 

    66.  out_put:  
      67. 

    67.     sysfs_put(target_sd);  
      68. 

    68.     sysfs_put(sd);  
      69. 

    69.     return error;  
      70. 

    70. }  
      71. 


    


    这个函数的执行也和8.3节的create_dir函数非常类似。其次，symlink同样没有对应的kobject对象。
    


    因为sysfs_dirent表示的是symlink，这里使用了联合体中的s_symlink。同时设置了s_symlink.target_sd指向的目标sysfs_dirent为参数targed_sd。
    

    8.6 小结
    

    本节首先对syfs这一特殊的文件系统的注册过程进行了分析。接着对目录，属性文件和symlink的建立进行了分析。这三者的建立过程基本一致，但是目录
    

    有kobject对象，而剩余两个没有。其次，这三者的每个sysfs_dirent中，都使用了自己的联合体数据。
    

    9 总结
    

    本文首先对sysfs的核心数据kobject，kset等数据结构做出了分析，正是通过它们才能向用户空间呈现出设备驱动模型。
    

    接着，以/sys/bus目录的建立为例，来说明如何通过kobject和kset来建立该bus目录。
    

    随后，介绍了驱动模型中表示总线，设备和驱动的三个数据结构。
    

    然后，介绍了platform总线(bus/platform)的注册，再介绍了虚拟的platform设备(devices/platform)的添加过程。
    

    之后 ，以spi主控制器的platform设备为例，介绍了该platform设备和相应的驱动的注册过程。
    

    最后，介绍了底层sysfs文件系统的注册过程和如何建立目录，属性文件和symlink的过程。
    

    

    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  第二章 java内存区域与内存溢出异常
                    
    TCP实现可靠传输
                    
    Tomcat的类加载架构
                    
    浅析Synchronized
                    
    设计数据库
                    
    http和https
                    
    IOC容器的依赖注入
                    
    IOC容器初始化
                    
    深入理解Java内存模型
                    
    单例应该这么写
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/wangdgy/p/6189543.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看