Chinaunix首页 | 论坛 | 博客

芸锺鹤－闲芸阁

首页　| 　博文目录　| 　关于我

芸锺鹤

  • 博客访问： 239725
  • 博文数量： 54
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 431
  • 用 户 组： 普通用户
  • 注册时间： 2014-07-26 09:36
文章分类

全部博文（54）

推荐博文
相关博文
驱动探究-设备驱动模型核心数据结构kobject、kobj_type、kset

分类： LINUX

2014-09-18 22:48:17

目录:
1 设备驱动模型概述
2 设备驱动模型核心数据结构
    2.1 kobject结构
    2.2 kobj_type结构
    2.3 kset结构


1 设备驱动模型概述:

    设备驱动模型在2.6内核被引入进来，它充分体现了分层，分工的思想。设备驱动程序的引入，很大程度上增加了代码的复用率。
    设备驱动模型提供了硬件的抽象，内核可以使用这些抽象完成很多硬件重复的工作。这些抽象包括：
(1) 电源管理
    电源管理主要目的是为了降低系统的功耗问题。即在设备不需要工作时，以低功耗的形式将设备挂起，待使用时再将其唤醒。
    总线上的设备没有都挂起时，总线必须处于唤醒状态，只有所有的设备都挂起时，总线才能被挂起。

(2) 热插拔的支持
     系统能够自动的探测设备是否接入系统。

(3) 用户空间sys文件系统通信接口
     将内核中的信息通过sys文件系统与用户空间进行交互。
     sys文件系统是Linux 2.6内核引入的一个内存文件系统。在sys文件系统中，大多数文件是ASCII文件，这样便于用户空间直接进行访问，也可称之为属性文件，通常每个文件有一个值，称之为属性。
     sys文件系统中有三个重要的数据结构:
--------------------------------------------------------------------------------------------------
    内核结构                                                      sys结构
--------------------------------------------------------------------------------------------------
kobject    (内核对象)                                           目录
kobj_type(对象属性)                                        属性文件
对象关联  (对象关系)                                        符号链接
--------------------------------------------------------------------------------------------------



     sys文件系统目录结构由目录，属性文件，符号链接组成。sys文件系统中挂接的目录代表sys文件系统中的子系统。
     当设备启动时，设备驱动模型会注册kobject对象，产生相应的目录文件。

(1) block目录
    block目录包含了系统中发现的每个块设备的子目录，每个块设备对应一个子目录。在子目录中包含了该块设备的属性文件。
    块设备目录中，有一个表示IO调度器的目录，这个目录提供了一些属性文件。可以利用这些属性文件控制块设备，包括改变它们的调度器等。块设备的每个分区分别为块设备的子目录，子目录中包含了分区的信息。

(2) bus目录
    bus目录中包含了系统中注册而得到的物理总线的子目录。在子目录中，包含device和driver目录,分别表示该总线上的设备和驱动。

(3) class目录
    class目录中的子目录为注册到内核中的设备类。

2 设备驱动模型核心数据结构:

    设备驱动模型将设备与驱动分离，主要由以下几个数据结构来进行描述：kobject、kset、subsystem.
    设备驱动模型：
    

    对应sys中的内容:
    

内核对于数据结构的处理，一般的使用流程即：
    定义数据结构对象   --》  初始化数据结构对象  --》注册数据结构对象到内核。

设备驱动模型存在的意义在于把抽象的高级对象链接到设备驱动模型中，通过设备驱动模型来对设备进行管理。


下面就利用这个这个流程来对设备驱动模型核心数据结构进行分析：

2.1 kobject结构:

    kobject主要实现以下作用：
1) 对象的引用计数。
2) sysfs空间的表述。
3) 设备驱动模型数据结构的关联。
4) 热插拔事件的处理。

kobject数据结构对象：

点击(此处)折叠或打开

  1. --include/linux/kobject.h

  3. struct kobject {
  4.         const char *name;                                                            /* kobject 名称,该名称在sys目录中表现为一个目录的名称 */
  5.         struct list_head entry;                                        /* kobject链表入口，连接下一个kobject */
  6.         struct kobject *parent;                                                   /* kobject父对象指针，如果存在 */  
  7.         struct kset *kset;                                                                /* kobject集合指针 */
  8.         struct kobj_type *ktype;                                                /* kobject属性指针 ，可以看做sys目录中的一个文件.
  9.                                                                                        * 注意：对于sys中的普通文件的读写，都是通过kobject->kobj_type->sysfs_ops
  10.                                                                                        *             来完成的。
  11.                                                                                        */
  12.         struct sysfs_dirent *sd;                                      /* 对应sys的文件目录 */
  13.         struct kref kref;                                                   /* kobject的引用计数,kobjet_get和kobject_put函数分别用于增加/减少引用计数 */
  14.         unsigned int state_initialized:1;                        /* 状态位：是否初始化过，1表示初始化完成，0 表示初始化未完成 */
  15.         unsigned int state_in_sysfs:1;                            /* 状态位：是否导入sys中 */
  16.         unsigned int state_add_uevent_sent:1;                /* 状态位：是否添加u_event */
  17.         unsigned int state_remove_uevent_sent:1;     /* 状态位：是否移除u_event */
  18.         unsigned int uevent_suppress:1;                       /* 状态位：是否抑制u_event */
  19. };

    kobject由上述的成员组成，创建完kobject后需要对其进行初始化。kobject的初始化工作应该先使用memset来对其进行清零，以避免不必要的错误，具体的初始化工作由kobject_init来完成：

kobject数据结构对象初始化：
(1) void kobject_init(struct kobject *kobj, struct kobj_type *ktype):

点击(此处)折叠或打开

  1. --lib/kobject.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 the be passed to the kobject_add() call。After this function is 
  7.  * called， the kobject MUST be cleaned up by a call to kobject_put(), not by a call to kfree directly to ensure that all of the memory
  8.  * is cleaned up properly.
  9.  */
  10. void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
    {
            char *err_str;

            if  ( !kobj ) {        /* 参数检查 */
                    err_str = "invalid kobject pointer!";
                    goto error;
            }
            if  ( !ktype ) {     /* 参数检查 */
                    err_str = "must have a ktype to be initialized properly!\n";
                    goto error;
            }
            if ( kobj->state_initialized ) {       /* 判定是否初始化已经完成 */
                    /* do not error out as sometimes we can recover */
                    printk(KERN_ERR "kobject (%p): tried to init an initialized "
                           "object, something is seriously wrong.\n", kobj);
                    dump_stack();
            }

            kobject_init_internal(kobj);           /* 初始化kobject内部成员 */
            kobj->ktype = ktype;                      /* 设置kobject属性 */
            return;

    error:
            printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
            dump_stack();
    }
    EXPORT_SYMBOL(kobject_init);
上述初始化过程可以看出，初始化工作大部分是放置在kobject_init_internal函数中来完成的。

static void kobject_init_internal(struct kobject *kobj):

点击(此处)折叠或打开

  1. --lib/kobject.c

  3. static void kobject_init_internal(struct kobject *kobj)
  4. {
  5.         if (!kobj)                                             /* 参数检查 */
  6.                 return;
  7.         kref_init(&kobj->kref);                   /* 引用计数初始化,初始化为1 */
  8.         INIT_LIST_HEAD(&kobj->entry);    /* 初始化kobject链表 */
  9.         kobj->state_in_sysfs = 0;                                    /*  状态位： 未导出到sys中 */
  10.         kobj->state_add_uevent_sent = 0;           /*  状态位：未添加uevent */
  11.         kobj->state_remove_uevent_sent = 0;    /*  状态位 :  未移除uevent */
  12.         kobj->state_initialized = 1;                        /*  状态位：已完成初始化 */
  13. }
  14. 注意：上述初始化过程未初始化 kobject的name成员，而ktype成员在kobject_init中进行了初始化。

上述初始化过程有关于引用计数的问题，引用计数由下列函数来完成：
void kref_init(struct kref *kref)

点击(此处)折叠或打开

  1. --lib/kref.c

  3. /**
  4.  *  kref_init - initialize object.
  5.  *  @kref: object in question.
  6.  */
  7. void kref_init(struct kref *kref)
  8. {
  9.         kref_set(kref, 1);
  10. }

  12. /**
  13.  * kref_set - initialize object and set refcount to requested number.
  14.  *  @kref: object in question.
  15.  *  @num: initial reference counter（引用计数）
  16.  */
  17. void kref_set(struct kref *kref, int num)
  18. {
  19.         atomic_set(&kref->refcount, num);
  20.         smp_mb();
  21. }





     kobject将被其子对象引用，因此为了控制对其占用的资源是否释放，需对其进行引用计数:
(1)增加kobject的引用计数:
struct kobject *kobject_get(struct kobject *kobj)

点击(此处)折叠或打开

  1. --lib/kobject.c

  3. /**
  4.  * kobject_get - increment refcount for object.
  5.  * @kobj: object.
  6.  */
  7. struct kobject *kobject_get(struct kobject *kobj)
  8. {
  9.         if (kobj)
  10.                 kref_get(&kobj->kref);
  11.         return kobj;
  12. }



  16. --lib/kref.c

  18. /**
  19.  * kref_get - increment refcount for object.
  20.  * @kref: object.
  21.  */
  22. void kref_get(struct kref *kref)
  23. {
  24.     WARN_ON(!atomic_read(&kref->refcount));
  25.     atomic_inc(&kref->refcount);
  26.     smp_mb__after_atomic_inc();
    }
(2) 减少kobject的引用计数:
void kobject_put(struct kobject *kobj)

点击(此处)折叠或打开

  1. --lib/kobject.c


  4. /**
  5.  * kobject_put - decrement refcount for object.
  6.  * @kobj: object.
  7.  *
  8.  * Decrement the refcount, and if 0, call kobject_cleanup().
  9.  */
  10. void kobject_put(struct kobject *kobj)
  11. {
  12.         if (kobj) {
  13.                 if (!kobj->state_initialized)
  14.                         WARN(1, KERN_WARNING "kobject: '%s' (%p): is not "
  15.                                "initialized, yet kobject_put() is being "
  16.                                "called.\n", kobject_name(kobj), kobj);
  17.                 kref_put(&kobj->kref, kobject_release);     /* 当引用计数为0时，自动调用kobject_release函数进行资源的释放 */
  18.         }
  19. }


  22. --lib/kref.c

  24. /**
  25.  * kref_put - decrement refcount for object.
  26.  * @kref: object.
  27.  * @release: pointer to the function that will clean up the object when the
  28.  * last reference to the object is released.
  29.  * This pointer is required, and it is not acceptable to pass kfree
  30.  * in as this function.
  31.  *
  32.  * Decrement the refcount, and if 0, call release().
  33.  * Return 1 if the object was removed, otherwise return 0. Beware, if this
  34.  * function returns 0, you still can not count on the kref from remaining in
  35.  * memory. Only use the return value if you want to see if the kref is now
  36.  * gone, not present.
  37.  */
  38. int kref_put(struct kref *kref, void (*release)(struct kref *kref))
  39. {
  40.         WARN_ON(release == NULL);
  41.         WARN_ON(release == (void (*)(struct kref *))kfree);

  43.         if (atomic_dec_and_test(&kref->refcount)) {
  44.                 release(kref);
  45.                 return 1;
  46.         }
  47.         return 0;
  48. }

  50.  
  51.   --lib/kobject.c
  52.  static void kobject_release(struct kref *kref)
  53. {
  54.         kobject_cleanup(container_of(kref, struct kobject, kref));
  55. }



  59. --lib/kobject.c
  60. /**
  61.  *kobject_cleanup - free kobject resources.
  62.  * @kobj: object to cleanup
  63.  */
  64. static void kobject_cleanup(struct kobject *kobj)     /* kobject_put函数最终调用了该函数 */
  65. {
  66.         struct kobj_type *t = get_ktype(kobj);
  67.         const char *name = kobj->name;
  68.         pr_debug("kobject: '%s' (%p): %s\n",
  69.                 kobject_name(kobj), kobj, __func__);

  71.         if (t && !t->release)  /* kobject_release函数最终调用了kobject->ktype->release函数，该函数需要用户自己实现，用于释放资源 */
  72.                 pr_debug("kobject: '%s' (%p): does not have a release() "
  73.                          "function, it is broken and must be fixed.\n",
  74.                          kobject_name(kobj), kobj);

  76.         /* send "remove" if the caller did not do it but sent "add" */
  77.         if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
  78.                 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
  79.                          kobject_name(kobj), kobj);
  80.                 kobject_uevent(kobj, KOBJ_REMOVE);
  81.         }

  83.         /* remove from sysfs if the caller did not do it */
  84.         if (kobj->state_in_sysfs) {
  85.                 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
  86.                          kobject_name(kobj), kobj);
  87.                 kobject_del(kobj);
  88.         }

  90.         if (t && t->release) {
  91.                 pr_debug("kobject: '%s' (%p): calling ktype release\n",
  92.                          kobject_name(kobj), kobj);
  93.                 t->release(kobj);
  94.         }

  96.         /* free name if we allocated it */
  97.         if (name) {
  98.                 pr_debug("kobject: '%s': free name\n", name);
  99.                 kfree(name);
  100.         }

总结以下kobject的释放流程如下：





    kobject注册到内核后，将以其name成员名称，呈现在/sys目录中，以下函数可操作name成员:

int kobject_set_name(struct kobject *kobj, const char *fmt, ...):    直接设置name成员。

点击(此处)折叠或打开

  1. --lib/kobject.c

  3.  
  4. /**
  5.  * kobject_set_name - Set the name of a kobject
  6.  * @kobj: struct kobject to set the name of
  7.  * @fmt: format string used to build the name(格式化字符串，与printf形式相同)
  8.  *
  9.  * This sets the name of the kobject. If you have already added the
  10.  * kobject to the system, you must call kobject_rename() in order to
  11.  * change the name of the kobject.
  12.  */
  13. int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
  14. {
  15.         va_list vargs;
  16.         int retval;

  18.         va_start(vargs, fmt);
  19.         retval = kobject_set_name_vargs(kobj, fmt, vargs);
  20.         va_end(vargs);

  22.         return retval;
  23. }
  24. EXPORT_SYMBOL(kobject_set_name);
int kobject_rename(struct kobject *kobj, const char *new_name)： 重命名，一般在kobject注册到系统后需要更改name时使用。

点击(此处)折叠或打开

  1. --lib/kobject.c


  4. /**
  5.  * kobject_rename - change the name of an object
  6.  * @kobj: object in question.
  7.  * @new_name: object's new name
  8.  *
  9.  * It is the responsibility of the caller to provide mutual
  10.  * exclusion between two different calls of kobject_rename
  11.  * on the same kobject and to ensure that new_name is valid and
  12.  * won't conflict with other kobjects.
  13.  */
  14. int kobject_rename(struct kobject *kobj, const char *new_name)
  15. {
  16.         int error = 0;
  17.         const char *devpath = NULL;
  18.         const char *dup_name = NULL, *name;
  19.         char *devpath_string = NULL;
  20.         char *envp[2];

  22.         kobj = kobject_get(kobj);
  23.         if (!kobj)
  24.                 return -EINVAL;
  25.         if (!kobj->parent)
  26.                 return -EINVAL;

  28.         devpath = kobject_get_path(kobj, GFP_KERNEL);
  29.         if (!devpath) {
  30.                 error = -ENOMEM;
  31.                 goto out;
  32.         }
  33.         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
  34.         if (!devpath_string) {
  35.                 error = -ENOMEM;
  36.                 goto out;
  37.         }
  38.         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
  39.         envp[0] = devpath_string;
  40.         envp[1] = NULL;

  42.         name = dup_name = kstrdup(new_name, GFP_KERNEL);
  43.         if (!name) {
  44.                 error = -ENOMEM;
  45.                 goto out;
  46.         }

  48.         error = sysfs_rename_dir(kobj, new_name);
  49.         if (error)
  50.                 goto out;

  52.         /* Install the new kobject name */
  53.         dup_name = kobj->name;
  54.         kobj->name = name;

  56.         /* This function is mostly/only used for network interface.
  57.          * Some hotplug package track interfaces by their name and
  58.          * therefore want to know when the name is changed by the user. */
  59.         kobject_uevent_env(kobj, KOBJ_MOVE, envp);

  61. out:
  62.         kfree(dup_name);
  63.         kfree(devpath_string);
  64.         kfree(devpath);
  65.         kobject_put(kobj);

  67.         return error;
  68. }
  69. EXPORT_SYMBOL_GPL(kobject_rename);


kobject数据结构对象注册：
int kobject_add(struct kobject *kobj, struct kobject *parent,   const char *fmt, ...)

点击(此处)折叠或打开

  1. --lib/kobject.c

  3. /**
  4.  * kobject_add - the main kobject add function
  5.  * @kobj: the kobject to add
  6.  * @parent: pointer to the parent of the kobject.
  7.  * @fmt: format to name the kobject with.
  8.  *
  9.  * The kobject name is set and added to the kobject hierarchy in this function.
  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 kobject associted with the kset assigned to this kobject. If no 
  12.  * kset is assigned to the kobject, then the kobject will be located in the root of the sysfs tree.
  13.  *
  14.  * If this function returns an error, kobject_put() must be called to properly clean up the memory associated with the object.
  15.  * Under no instance should the kobject that is passed to this function be directly freed with a call to kfree(), that can leak memory.
  16.  *
  17.  * Note, no "add" uevent will be created with this call, the caller should set up all of the necessary sysfs files for the object and then
  18.  * call kobject_uevent() with the UEVENT_ADD parameter to ensure that userspace is properly notified of this kobject's creation.
  19.  */

  21. int kobject_add(struct kobject *kobj, struct kobject *parent, const char *fmt, ...)
  22. {
  23.         va_list args;
  24.         int retval;

  26.         if (!kobj)
  27.                 return -EINVAL;

  29.         if (!kobj->state_initialized) {
  30.                 printk(KERN_ERR "kobject '%s' (%p): tried to add an "
  31.                        "uninitialized object, something is seriously wrong.\n",
  32.                        kobject_name(kobj), kobj);
  33.                 dump_stack();
  34.                 return -EINVAL;
  35.         }
  36.         va_start(args, fmt);
  37.         retval = kobject_add_varg(kobj, parent, fmt, args);
  38.         va_end(args);

  40.         return retval;
  41. }
  42. EXPORT_SYMBOL(kobject_add);

  int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype, struct kobject *parent, const char *fmt, ...)

点击(此处)折叠或打开

  1. --lib/kobject.c

  3. /**
  4.  * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy
  5.  * @kobj: pointer to the kobject to initialize
  6.  * @ktype: pointer to the ktype for this kobject.
  7.  * @parent: pointer to the parent of this kobject.
  8.  * @fmt: the name of the kobject.
  9.  *
  10.  * This function combines the call to kobject_init() and
  11.  * kobject_add(). The same type of error handling after a call to
  12.  * kobject_add() and kobject lifetime rules are the same here.
  13.  */
  14. int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
  15.                          struct kobject *parent, const char *fmt, ...)
  16. {
  17.         va_list args;
  18.         int retval;

  20.         kobject_init(kobj, ktype);

  22.         va_start(args, fmt);
  23.         retval = kobject_add_varg(kobj, parent, fmt, args);
  24.         va_end(args);

  26.         return retval;
  27. }
  28. EXPORT_SYMBOL_GPL(kobject_init_and_add);


2.2 kobj_type结构:

    kobject的属性用kobj_type进行表示。

点击(此处)折叠或打开

  1. --include/linux/kobject.h

  3. struct kobj_type {
  4.         void (*release)(struct kobject *kobj);           /* kobject资源释放函数，一般需自己实现*/
  5.         struct sysfs_ops *sysfs_ops;                                /*  kobject属性数组操作集合 */
  6.         struct attribute **default_attrs;                       /*  kobject默认属性数组 */
  7. };


点击(此处)折叠或打开

  1. --include/linux/sysfs.h


  4. /* FIXME
  5.  * The *owner field is no longer used.
  6.  * x86 tree has been cleaned up. The owner
  7.  * attribute is still left for other arches.
  8.  */
  9. struct attribute {
  10.         const char *name;               /* 属性的名字,即sys目录中的文件名称 */
  11.         struct module *owner;    /* 属性的拥有者 */
  12.         mode_t mode;                        /* 属性的读写权限，定义在include/linux/stat.h*/
  13. };



点击(此处)折叠或打开

  1. --include/linux/sysfs.h

  3. struct sysfs_ops {                        /* 对属性的操作函数 */
  4.         ssize_t (*show)(struct kobject *, struct attribute *,char *);                                /* 读属性操作函数 */
  5.         ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);    /* 写属性操作函数 */
  6. };

    上述介绍了kobject的默认属性，除了默认属性外，可以对kobject添加一些非默认属性，用来控制kobject代表的总线，设备，驱动的行为。
添加非默认属性，使用如下函数：

int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)

点击(此处)折叠或打开

  1. ./fs/sysfs/file.c


  4. /**
  5.  * sysfs_create_file - create an attribute file for an object.
  6.  * @kobj: object we're creating for.
  7.  * @attr: attribute descriptor.
  8.  */

  10. int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)　　　　／*成功返回０，失败返回错误码 */
  11. {
  12.         BUG_ON(!kobj || !kobj->sd || !attr);

  14.         return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);

  16. }


void sysfs_remove_file(struct kobject * kobj, const struct attribute * attr)

点击(此处)折叠或打开

  1. ./fs/sysfs/file.c

  3. /**
  4.  * sysfs_remove_file - remove an object attribute.
  5.  * @kobj: object we're acting for.
  6.  * @attr: attribute descriptor.
  7.  *
  8.  * Hash the attribute name and kill the victim.
  9.  */

  11. void sysfs_remove_file(struct kobject * kobj, const struct attribute * attr)
  12. {
  13.         sysfs_hash_and_remove(kobj->sd, attr->name);
  14. }
[备注]：当属性文件删除后，若用户空间的程序仍然在使用该文件描述符时，会造成错误。



  2.3 kset结构:

    kobject是通过kset组织成层次化的结构。kset是具有相同类型的kobject的集合，存放在/sys/drivers目录下。

点击(此处)折叠或打开

  1. --include/linux/kobject.h

  3. /**
  4.  * struct kset - a set of kobjects of a specific type, belonging to a specific subsystem.
  5.  *
  6.  * A kset defines a group of kobjects. They can be individually  different "types" but overall these kobjects all want to be grouped
  7.  * together and operated on in the same manner. ksets are used to define the attribute callbacks and other common events that
  8.  * happen to 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 called whenever a kobject has something happen to it so
  14.  *                           that the kset can add new environment variables, or filter out the uevents if so desired.
  15.  */
  16. struct kset {                             /* kset是一个kobject的集合，常用来描述一个子系统 */
  17.         struct list_head list;                /* 链接包含所有kobject的对象的链表（双向环型）首部 */
  18.         spinlock_t list_lock;                /* 维护list链表的自旋锁 */
  19.         struct kobject kobj;                /* 内嵌kobject,表明kset本身也是一个目录 */
  20.         struct kset_uevent_ops *uevent_ops;    /* 热插拔事件 */
  21. };
    kobject的kobj_type指针指向自身的kobj_type,每一个kobject都有一个单独的kobj_type结构体。另外，kset中也有一个kobject，其也关联一个kobj_type. 注意:kset中的kobject关联的kobj_type的优先级高于其包含的各个kobject关联的kobj_type。如果同时存在，优先调用kset中的函数，如果kset中的kobj_type指针为空，才调用各个kobject自身关联的kobj_type.
    ket中的uevent_ops是用于处理热插拔事件的。热插拔事件是从内核空间发送到用户空间的通知，表明系统某些部分的配置已经发生了变化。用户空间接收到内核空间的通知后，会调用相应的程序，处理配置的变化。内核将在什么时候产生热插拔事件呢？当驱动程序将kobject注册到设备驱动模型时，会产生热插拔事件。即内核调用kobject_add()和kobject_del()函数时，会产生热插拔事件。热插拔事件产生时，内核会根据kobject的
kset指针找到所属的kset结构体，执行kset中的uevent_ops包含的热插拔函数:

点击(此处)折叠或打开

  1. --include/linux/kobject.h

  3. struct kset_uevent_ops {
  4.         int (*filter)(struct kset *kset, struct kobject *kobj);        /* 用于过滤内核是否向用户空间发送事件信号，
  5.                                                                                                        *若filter返回0，表示不产生事件；若返回1，表示产生事件
  6.                                                                                                        */
  7.         const char *(*name)(struct kset *kset, struct kobject *kobj);
  8.         int (*uevent)(struct kset *kset, struct kobject *kobj,
  9.                       struct kobj_uevent_env *env);
  10. };

kset与kobject,kobj_type的关系图示：



    kset相关数据结构关系已经叙述了,下面根据内核操作数据结构对象的流程来看看kset的操作函数：


kset初始化函数：
void kset_init(struct kset *k)

点击(此处)折叠或打开

  1. --lib/kobjet.c

  3. /**
  4.  * kset_init - initialize a kset for use
  5.  * @k: kset
  6.  */
  7. void kset_init(struct kset *k)     /* 初始化kset中的kobject, list, spinlock */
  8. {
  9.         kobject_init_internal(&k->kobj);      /* 调用kobject初始化函数，初始化kset->kobject */
  10.         INIT_LIST_HEAD(&k->list);                   /* 初始化kset中的kobject链表 */
  11.         spin_lock_init(&k->list_lock);               /* 初始化kobject 链表的自旋锁 */
  12. }

kset注册函数：
int kset_register(struct kset *k)

点击(此处)折叠或打开

  1. --lib/kobjet.c

  3. /**
  4.  * kset_register - initialize and add a kset.
  5.  * @k: kset.
  6.  */
  7. int kset_register(struct kset *k)
  8. {
  9.         int err;

  11.         if (!k)
  12.                 return -EINVAL;

  14.         kset_init(k);
  15.         err = kobject_add_internal(&k->kobj);
  16.         if (err)
  17.                 return err;
  18.         kobject_uevent(&k->kobj, KOBJ_ADD);
  19.         return 0;
  20. }

kset注销函数：
void kset_unregister(struct kset *k)

点击(此处)折叠或打开

  1. --lib/kobject.c

  3. /**
  4.  * kset_unregister - remove a kset.
  5.  * @k: kset.
  6.  */
  7. void kset_unregister(struct kset *k)
  8. {
  9.         if (!k)
  10.                 return;
  11.         kobject_put(&k->kobj);
  12. }

kset引用计数：
static inline struct kset *kset_get(struct kset *k)    增加引用计数
static inline void   kset_put(struct kset *k)               减少引用计数

点击(此处)折叠或打开

  1. --include/linux/kobject.h


  1. static inline struct kset *kset_get(struct kset *k)
  2. {
  3.         return k ? to_kset(kobject_get(&k->kobj)) : NULL;
  4. }

  6. static inline void kset_put(struct kset *k)
  7. {
  8.         kobject_put(&k->kobj);
  9. }




阅读(2200) | 评论(0) | 转发(1) |
0

上一篇：驱动探究-设备驱动模型--总线、设备、驱动

下一篇：va_start和va_end使用详解

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6