kobject

最新推荐文章于 2022-12-02 00:30:00 发布
最新推荐文章于 2022-12-02 00:30:00 发布
阅读量692 收藏
点赞数
分类专栏： Linux 驱动 文章标签： kobject 设备驱动程序模型 kset 
一、kobject应用举例
Linux设备模型最基本的组成元素是kobject，我们先来看一个kobject的应用例子，该程序在Ubuntu 10.10, 2.6.32-38-generic-pae内核上调试通过。
 
 

  
  

   
   

    
    [cpp] 
    
    view plain
    
    copy
    
    

   
   

  
  

  
  
  1. #include <linux/device.h>  
  2. #include <linux/module.h>  
  3. #include <linux/kernel.h>  
  4. #include <linux/init.h>  
  5. #include <linux/string.h>  
  6. #include <linux/sysfs.h>  
  7. #include <linux/stat.h>  
  8.   
  9. MODULE_AUTHOR("haoyu");  
  10. MODULE_LICENSE("Dual BSD/GPL");  
  11.   
  12. struct my_kobject  
  13. {  
  14.     int value;  
  15.     struct kobject kobj;  
  16. };  
  17.       
  18. struct my_kobject my_kobj;  
  19.   
  20. void kobject_release(struct kobject *kobject);  
  21. ssize_t kobject_attr_show(struct kobject *kobject, struct attribute *attr,char *buf);  
  22. ssize_t kobject_attr_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count);  
  23.   
  24. struct attribute kobject_attr1 = {  
  25.     .name = "name",  
  26.     .mode = S_IRWXUGO,  
  27. };  
  28.   
  29. struct attribute kobject_attr2 = {  
  30.     .name = "value",  
  31.     .mode = S_IRWXUGO,  
  32. };  
  33.   
  34. static struct attribute *kobject_def_attrs[] = {  
  35.     &kobject_attr1,  
  36.     &kobject_attr2,  
  37.     NULL,  
  38. };  
  39.   
  40. struct sysfs_ops kobject_sysfs_ops =  
  41. {  
  42.     .show = kobject_attr_show,  
  43.     .store = kobject_attr_store,  
  44. };  
  45.   
  46. struct kobj_type ktype =  
  47. {  
  48.     .release = kobject_release,  
  49.     .sysfs_ops = &kobject_sysfs_ops,  
  50.     .default_attrs = kobject_def_attrs,  
  51. };  
  52.   
  53. void kobject_release(struct kobject *kobject)  
  54. {  
  55.     printk("kobject release.\n");  
  56. }  
  57.   
  58. ssize_t kobject_attr_show(struct kobject *kobject, struct attribute *attr,char *buf)  
  59. {  
  60.     int count = 0;  
  61.     struct my_kobject *my_kobj = container_of(kobject, struct my_kobject, kobj);  
  62.     printk("kobject attribute show.\n");  
  63.     if(strcmp(attr->name, "name") == 0)  
  64.         count = sprintf(buf, "%s\n", kobject->name);  
  65.     else if(strcmp(attr->name, "value") == 0)  
  66.         count = sprintf(buf, "%d\n", my_kobj->value);  
  67.     else  
  68.         printk("no this attribute.\n");  
  69.       
  70.     return count;  
  71. }  
  72.   
  73. ssize_t kobject_attr_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count)  
  74. {  
  75.     int val;  
  76.     struct my_kobject *my_kobj = container_of(kobject, struct my_kobject, kobj);  
  77.     printk("kobject attribute store.\n");  
  78.     if(strcmp(attr->name, "name") == 0)  
  79.         printk("Can not change name.\n");  
  80.     else if(strcmp(attr->name, "value") == 0)  
  81.     {  
  82.         val = buf[0] - '0';  
  83.         if(val == 0 || val == 1)  
  84.             my_kobj->value = val;  
  85.         else  
  86.             printk("value is '0' or '1'\n");  
  87.     }  
  88.     else  
  89.         printk("no this attribute.\n");  
  90.           
  91.     return count;  
  92. }  
  93.   
  94. static int kobject_test_init(void)  
  95. {  
  96.     printk("kboject test init.\n");  
  97.     kobject_init_and_add(&my_kobj.kobj,&ktype,NULL,"kobject_test");  
  98.     return 0;  
  99. }  
  100.   
  101. static void kobject_test_exit(void)  
  102. {  
  103.     printk("kobject test exit.\n");  
  104.     kobject_del(&my_kobj.kobj);  
  105. }  
  106.   
  107. module_init(kobject_test_init);  
  108. module_exit(kobject_test_exit);  

 
 


该模块执行过程如下图所示：
 
二、相关数据结构：
kobject是Linux设备模型中最基本的数据结构，代表设备模式的一个基本对象。
kobj_type是kobject的类型，包括kobject的属性以及属性的操作接口，不同的kobject可以具有相同的kobj_type。
kset是几个kobject的集合，这些kobject可以具有相同的kobj_type，也可以具有不同的kobj_type。

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  1. struct kobject {  
  2.         const char             *name;  
  3.         struct list_head       entry;  
  4.         struct kobject         *parent;  
  5.         struct kset            *kset;  
  6.         struct kobj_type       *ktype;  
  7.         struct sysfs_dirent    *sd;  
  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. };  
  15.    
  16. /** 
  17.  * struct kset - a set of kobjects of a specific type, belonging to a specific subsystem. 
  18.  * 
  19.  * A kset defines a group of kobjects.  They can be individually 
  20.  * different "types" but overall these kobjects all want to be grouped 
  21.  * together and operated on in the same manner.  ksets are used to 
  22.  * define the attribute callbacks and other common events that happen to 
  23.  * a kobject. 
  24.  * 
  25.  * @list: the list of all kobjects for this kset 
  26.  * @list_lock: a lock for iterating over the kobjects 
  27.  * @kobj: the embedded kobject for this kset (recursion, isn't it fun...) 
  28.  * @uevent_ops: the set of uevent operations for this kset.  These are 
  29.  * called whenever a kobject has something happen to it so that the kset 
  30.  * can add new environment variables, or filter out the uevents if so 
  31.  * desired. 
  32.  */  
  33. struct kset {  
  34.         struct list_head list;  
  35.         spinlock_t list_lock;  
  36.         struct kobject kobj;  
  37.         const struct kset_uevent_ops *uevent_ops;  
  38. };  
  39.    
  40. struct kset_uevent_ops {  
  41.         int (* const filter)(struct kset *kset, struct kobject *kobj);  
  42.         const char *(* const name)(struct kset *kset, struct kobject *kobj);  
  43.         int (* const uevent)(struct kset *kset, struct kobject *kobj,  
  44.                      struct kobj_uevent_env *env);  
  45. };  
  46.    
  47. struct kobj_type {  
  48.         void (*release)(struct kobject *kobj);  
  49.         const struct sysfs_ops *sysfs_ops;  
  50.         struct attribute **default_attrs;  
  51.         const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);  
  52.         const void *(*namespace)(struct kobject *kobj);  
  53. };  
  54.    
  55. struct sysfs_ops {  
  56.         ssize_t (*show)(struct kobject *, struct attribute *,char *);  
  57.         ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);  
  58. };  
  59.    
  60. struct attribute {  
  61.         const char             *name;  
  62.         mode_t                 mode;  
  63. #ifdef CONFIG_DEBUG_LOCK_ALLOC  
  64.         struct lock_class_key  *key;  
  65.         struct lock_class_key  skey;  
  66. #endif  
  67. };  
  68.    
  69. /* 
  70.  * Callbacks so sysfs can determine namespaces 
  71.  *   @current_ns: return calling task's namespace 
  72.  *   @netlink_ns: return namespace to which a sock belongs (right?) 
  73.  *   @initial_ns: return the initial namespace (i.e. init_net_ns) 
  74.  */  
  75. struct kobj_ns_type_operations {  
  76.         enum kobj_ns_type type;  
  77.         const void *(*current_ns)(void);  
  78.         const void *(*netlink_ns)(struct sock *sk);  
  79.         const void *(*initial_ns)(void);  
  80. };  
  81.    
  82. struct kref {  
  83.         atomic_t refcount;  
  84. };  

  
  

 
三、kobject注册和注销过程分析
kobject的注册是通过调用kobject_init_and_add函数，该函数定义如下：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

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

  
  

这个函数分为两部分，首先调用kobject_init函数对kobject对象进行基本的初始化。然后，调用kobject_add_varg函数将kobject注册到系统中。va_start和va_end是处理可变参数的固定语法。
先来看kobject_init，该函数定义如下：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  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!\n";  
  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.\n", 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\n", kobj, err_str);  
  38.         dump_stack();  
  39. }  

  
  

该函数首先确保kobj和ktype都存在，否则直接退出。如果该kobj进行过初始化，则打印警告信息。然后调用kobject_init_internal真正开始初始化kobj，最后把kobj->ktype设置为ktype。
kobject_init_internal函数定义如下：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  1. static void kobject_init_internal(struct kobject *kobj)  
  2. {  
  3.         if (!kobj)  
  4.                return;  
  5.         kref_init(&kobj->kref);  
  6.         INIT_LIST_HEAD(&kobj->entry);  
  7.         kobj->state_in_sysfs = 0;  
  8.         kobj->state_add_uevent_sent = 0;  
  9.         kobj->state_remove_uevent_sent = 0;  
  10.         kobj->state_initialized = 1;  
  11. }  

  
  

首先初始化kobj->kref，实际上kobj->kref就是一个原子变量(atomic_t)。接着初始化链表项kobj->entry，并设置其他kobject成员。
至此，kobject_init函数就分析完了，我们返回到kobject_init_and_add函数，下面该分析kobject_add_varg函数了：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  1. static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,  
  2.                            const char *fmt, va_list vargs)  
  3. {  
  4.         int retval;  
  5.    
  6.         retval = kobject_set_name_vargs(kobj, fmt, vargs);  
  7.         if (retval) {  
  8.                printk(KERN_ERR "kobject: can not set name properly!\n");  
  9.                return retval;  
  10.         }  
  11.         kobj->parent = parent;  
  12.         return kobject_add_internal(kobj);  
  13. }  

  
  

首先调用kobject_set_name_vargs设置kob->name。然后初始化kobj->parent为parent参数指定的kobject。最后，调用kobject_add_internal将kobject注册到系统中，该函数定义如下：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  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.    
  9.         if (!kobj->name || !kobj->name[0]) {  
  10.                WARN(1, "kobject: (%p): attempted to be registered with empty "  
  11.                         "name!\n", 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.                        parent = kobject_get(&kobj->kset->kobj);  
  21.                kobj_kset_join(kobj);  
  22.                kobj->parent = parent;  
  23.         }  
  24.    
  25.         pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",  
  26.                 kobject_name(kobj), kobj, __func__,  
  27.                 parent ? kobject_name(parent) : "<NULL>",  
  28.                 kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");  
  29.    
  30.         error = create_dir(kobj);  
  31.         if (error) {  
  32.                kobj_kset_leave(kobj);  
  33.                kobject_put(parent);  
  34.                kobj->parent = NULL;  
  35.    
  36.                /* be noisy on error issues */  
  37.                if (error == -EEXIST)  
  38.                        printk(KERN_ERR "%s failed for %s with "  
  39.                               "-EEXIST, don't try to register things with "  
  40.                               "the same name in the same directory.\n",  
  41.                               __func__, kobject_name(kobj));  
  42.                else  
  43.                        printk(KERN_ERR "%s failed for %s (%d)\n",  
  44.                               __func__, kobject_name(kobj), error);  
  45.                dump_stack();  
  46.         } else  
  47.                kobj->state_in_sysfs = 1;  
  48.    
  49.         return error;  
  50. }  

  
  

首先确保kobj->name已经被赋值，即kobject必须有名字。如果指定了kobj->kset，则调用kobj_kset_join将kobj加入到kobj->kset中。同时，如果kobj->parent仍为NULL，则将kobj->parent设置为kobj->kset->kobj。
然后，调用create_dir(kobj)在/sys目录下建立kobject相关目录结构。
kobj_kset_join函数定义如下：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  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);  
  8.         spin_lock(&kobj->kset->list_lock);  
  9.         list_add_tail(&kobj->entry, &kobj->kset->list);  
  10.         spin_unlock(&kobj->kset->list_lock);  
  11. }  

  
  

create_dir函数定义如下：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  1. static int create_dir(struct kobject *kobj)  
  2. {  
  3.         int error = 0;  
  4.         if (kobject_name(kobj)) {  
  5.                error = sysfs_create_dir(kobj);  
  6.                if (!error) {  
  7.                        error = populate_dir(kobj);  
  8.                        if (error)  
  9.                                sysfs_remove_dir(kobj);  
  10.                }  
  11.         }  
  12.         return error;  
  13. }  

  
  

首先调用sysfs_create_dir在/sys下建立目录，然后再调用populate_dir在新建目录下生成属性文件。
sysfs_create_dir函数定义如下：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  1. /** 
  2.  *      sysfs_create_dir - create a directory for an object. 
  3.  *      @kobj:         object we're creating directory for.  
  4.  */  
  5. int sysfs_create_dir(struct kobject * kobj)  
  6. {  
  7.         enum kobj_ns_type type;  
  8.         struct sysfs_dirent *parent_sd, *sd;  
  9.         const void *ns = NULL;  
  10.         int error = 0;  
  11.    
  12.         BUG_ON(!kobj);  
  13.    
  14.         if (kobj->parent)  
  15.                parent_sd = kobj->parent->sd;  
  16.         else  
  17.                parent_sd = &sysfs_root;  
  18.    
  19.         if (sysfs_ns_type(parent_sd))  
  20.                ns = kobj->ktype->namespace(kobj);  
  21.         type = sysfs_read_ns_type(kobj);  
  22.    
  23.         error = create_dir(kobj, parent_sd, type, ns, kobject_name(kobj), &sd);  
  24.         if (!error)  
  25.                kobj->sd = sd;  
  26.         return error;  
  27. }  

  
  

这里主要是通过调用create_dir函数建立kobject对应的目录。这个函数我们就不继续向下跟踪了。
下面来看populate_dir函数，其定义如下：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  1. /* 
  2.  * populate_dir - populate directory with attributes. 
  3.  * @kobj: object we're working on. 
  4.  * 
  5.  * Most subsystems have a set of default attributes that are associated 
  6.  * with an object that registers with them.  This is a helper called during 
  7.  * object registration that loops through the default attributes of the 
  8.  * subsystem and creates attributes files for them in sysfs. 
  9.  */  
  10. static int populate_dir(struct kobject *kobj)  
  11. {  
  12.         struct kobj_type *t = get_ktype(kobj);  
  13.         struct attribute *attr;  
  14.         int error = 0;  
  15.         int i;  
  16.    
  17.         if (t && t->default_attrs) {  
  18.                for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {  
  19.                        error = sysfs_create_file(kobj, attr);  
  20.                        if (error)  
  21.                                break;  
  22.                }  
  23.         }  
  24.         return error;  
  25. }  

  
  

该函数循环遍历kobject的所有属性，并调用sysfs_create_file函数在/sys系统对应目录下建立属性文件。
至此，kobject的注册过程我们就分析完了。
kobject的注销过程是调用kobject_del函数，该函数定义如下：

  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     

    
    

   
   

   
   
  1. /** 
  2.  * kobject_del - unlink kobject from hierarchy. 
  3.  * @kobj: object. 
  4.  */  
  5. void kobject_del(struct kobject *kobj)  
  6. {  
  7.         if (!kobj)  
  8.                return;  
  9.    
  10.         sysfs_remove_dir(kobj);  
  11.         kobj->state_in_sysfs = 0;  
  12.         kobj_kset_leave(kobj);  
  13.         kobject_put(kobj->parent);  
  14.         kobj->parent = NULL;  
  15. }  

  
  

这里需要注意的是，只要把目录删除，目录下的属性文件自动就删除了。
水无声风无痕
关注
专栏目录
Linux设备模型分析之kobject
Linux/Android开发记录
04-20 4464
作者：刘昊昱  博客：http://blog.csdn.net/liuhaoyutz 内核版本：2.6.36   一、kobject应用举例 Linux设备模型最基本的组成元素是kobject，我们先来看一个kobject的应用例子，该程序在Ubuntu 10.10, 2.6.32-38-generic-pae内核上调试通过。 #include #include #inc
Linux设备驱动工程师之路——设备模型（上）底层模型
mmdev
09-22 205
Linux设备驱动工程师之路——设备模型（上）底层模型 K-Style 转载请注明来自于衡阳师范学院08电2 Y-Kee http://blog.csdn.net/ayangke,QQ:843308498 一、重要知识点 1.Sysfs文件系统 Sysfs文件系统是一种类似于proc文件系统的特殊文件系统，它存在于内存当中，当系统启动时由内核挂载于内存当中。用于将系统中的设备...
linux设备模型之kobject
u012590688的专栏
06-14 735
kobject 结构     在Linux内核里，kobject是组成Linux设备模型的基础，一个kobject对应sysfs里的 一个目录。从面向对象的角度来说，kobject可以看作是所有设备对象的基类，因为C 语言并没有面向对象的语法，所以一般是把kobject内嵌到其他结构体里来实现类似的 作用，这里的其他结构体可以看作是kobject的派生类。Kobject为Linux
linux 输入模型结构的使用,Linux设备模型之一：Kobject
weixin_39649611的博客
05-14 170
1. 前言Kobject是Linux设备模型的基础，也是设备模型中最难理解的一部分(可参考Documentation/kobject.txt的表述)。因此有必要先把它分析清楚。2. 基本概念由“Linux设备模型(1)_基本概念”可知，Linux设备模型的核心是使用Bus、Class、Device、Driver四个核心数据结构，将大量的、不同功能的硬件设备(以及驱动该硬件设备的方法)，以树状结构的...
Linux设备模型之kobject
sxw1002的专栏
07-29 1086
Linux设备模型是从linux内核2.6版本开始引进，sysfs实现了设备模型的管理，这是一个虚拟文件系统，以一个树状结构呈现出对系统中所有的设备管理。
Linux设备模型kobj_type、kobject、kset三者间关系总结
08-20
Linux 设备模型 kobj_type、kobject、kset 三者间关系总结 Linux 设备模型中，kobj_type、kobject、kset 三者之间存在着复杂的关系。为了更好地理解这三者的关系，我们需要从基本概念开始，逐步深入到流程图的解释...
Linux设备模型kobject与kset之间的关系
08-20
Linux设备模型kobject与kset之间的关系 Linux设备模型是Linux操作系统中对设备的描述模型，它提供了一个统一的接口来管理和操作设备。在Linux设备模型中，kobject和kset是两个核心概念，它们之间的关系是设备模型的...
实例：kobject & kset实验
11-09
kobject & kset实验 从/sys目录的构成可知整个sysfs文件系统盘根错节，此处补充一个向系统添加kobject & kset对象的实验，帮助理解该过程（但不会过分深入细节）
kobject结构体1
08-03
在Linux内核中，kobject结构体是驱动模型的核心组成部分，它提供了一种抽象机制，使得内核对象的管理变得更加灵活和有序。kobject的主要作用是为其他内核对象提供一个通用的接口，这些对象可以是设备、模块、内存...
Linux 设备模型之kobject
06-08
kobject_init用来初始化kobject结构，kobject_add用来把kobj加入到设备模型之中。 在实作中，我们先对obj1进行初始化和添加的动作，调用参数里，parent被赋为NULL，表示obj1没有父对象，反映到sysfs里， my_kobj1...
【Linux kernel】Linux设备模型(2)_Kobject
最新发布
weixin_41028159的博客
12-02 155
Kobject是Linux设备模型的基础，也是设备模型中最难理解的一部分（可参考Documentation/kobject.txt的表述）。因此有必要先把它分析清楚。
Linux 设备模型之 （kobject、kset 和 Subsystem）（二）
ZP1015
06-08 2716
问题描述：前文我们知道了/sys是包含内核和驱动的实施信息的，用户可以通过 /sys 这个接口，用户通过这个接口可以一览内核设备的全貌。本文将从Linux内核的角度来看一看这个设备模型是如何构建的。 1、kobject 结构 在Linux内核里，kobject是组成Linux设备模型的基础，一个kobject对应sysfs里的一个目录。从面向对象的角度来说，kobject可以看作是所有设备对象的基类，因为C语言并没有面向对象的语法，所以一般是把kobject内嵌到其他结构体里来实现类似的作用，这里的其他
linux底层驱动模型之三：kobject应用实例
阿赞的专栏
11-24 429
接下来我们从例子着手，运行localhost:/home/XX/examples/lddbus#insmod lddbus.ko，此时再看/sys/bus/ 这时就多了一个文件夹ldd。这表示系统中多了一种名叫ldd的总线类型。同时再看/sys/device/，也多出来一个ldd0的文件夹，这表示系统中多了一个名叫ldd0的硬件。       在lddbus.c中， 定义了一个总线和硬件类型
linux设备模型之 kobject原理与实例分析
05-19 3709
<!-- @page {margin:2cm} p {margin-bottom:0.21cm} --> 1、Sysfs文件系统            "sysfsis a ram-based filesystem initially based on ramfs. It provides ameans to export kernel data structur
我对linux理解之driver_register
qq345260600的专栏
08-06 842
/**  * driver_register - register driver with bus  * @drv: driver to register  *  * We pass off most of the work to the bus_add_driver() call,  * since most of the things we have to do deal with
转一篇关于linux设备模型的好文章
tracyzhang的专栏
11-15 560
文章出处：http://ericxiao.cublog.cn/ 一：前言 Linux设备模型是一个极其复杂的结构体系，在编写驱动程序的时候，通常不会用到这方面的东西，但是。理解这部份内容，对于我们理解linux设备驱动的结构是大有裨益的。我们不但可以在编写程序程序的时候知其然，亦知其所以然。又可以学习到一种极其精致的架构设计方法。由于之前已经详细分析了sysfs文件系统。所以本节的讨论主要
设备模型-kobject详解
你系得嘎，加油
11-29 1481
/*整理于2012.11.29于广工大 */   先说说sysfs         sysfs文件系统是一个处于内存中的虚拟文件系统，它为我们提供了kobject对象层次结构的视图。帮助用户可以以一个简单文件系统的方式来观察系统中各种设备的拓扑结构。         借助属性对象，kobject可用导出文件的方式，将内核变量提供给用户读取或写入。
linux设备驱动模型之Kobject、kobj_type、kset
风雨无阻
07-08 4912
学习中platform平台驱动中，慢慢发现底层有一个叫做linux设备驱动模型的东西。发现是驱动中十分重要的一部分，现在针对设备驱动模型进行分析。 用户空间程序通过sysfs虚拟文件系统访问设备的相关信息。这些信息被组织成层次结构，用sysfs虚拟文件系统来表示，用户通过对sysfs的操作，就可以控制设备或者读取设备的信息。 一、sysfs文件系统简介： 1、sysfs概述 sysfs文件
Linux 2.6内核设备模型：kobject解析
"kobject是Linux内核设备模型中的核心组件，用于构建系统设备的拓扑结构，实现设备与驱动的关联，并通过sysfs在用户空间呈现。" 在Linux 2.6内核中引入的统一设备模型（device model）极大地改进了对硬件设备的管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值