Chinaunix首页 | 论坛 | 博客

辉捺天韵的ChinaUnix博客linuxjason.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

辉捺天韵

  • 博客访问： 471418
  • 博文数量： 65
  • 博客积分： 573
  • 博客等级： 中士
  • 技术积分： 693
  • 用 户 组： 普通用户
  • 注册时间： 2011-06-09 17:16
文章分类

全部博文（65）

文章存档

2015年（12）

2014年（9）

2013年（22）

2012年（7）

2011年（15）

我的朋友
最近访客
推荐博文
相关博文
kobject与kset简单注册示例

分类： LINUX

2014-09-16 16:58:19

kobject与kset的介绍，在ldd3中已经介绍的很详细了，没有了解过的，可以去看看第十四章设备模型这一章，这里只简单介绍一下kobject和kset,并提供一个可运行的示例程序，用做备忘！
示例程序运行kernel版本为3.0.36,示例程序是国嵌的，修改使之在3.0.36内核版本可运行，并消除编译时的警告信息

kobject实现了基本的面相对象管理机制，是构成Linux内核设备模型的核心结构，它与sys紧密相连，在内核中注册的每个kobject对应sys文件系统中一个目录。kobject结构定义如下：
struct kobject {
 const char *name; //名字
 struct list_head entry;
 struct kobject *parent; //父kobject
 struct kset *kset;
 struct kobj_type *ktype; //kobject类型
 struct sysfs_dirent *sd;
 struct kref kref; //引用计数
 unsigned int state_initialized:1;
 unsigned int state_in_sysfs:1;
 unsigned int state_add_uevent_sent:1;
 unsigned int state_remove_uevent_sent:1;
 unsigned int uevent_suppress:1;
};

 struct kobj_type结构定义如下：
struct kobj_type {
 void (*release)(struct kobject *kobj);   //引用计数为0时，调用该函数释放kobject所占用的资源
 const struct sysfs_ops *sysfs_ops; //属性文件的操作函数
 struct attribute **default_attrs; //属性文件，对应sys文件系统中的一个文件
 const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
 const void *(*namespace)(struct kobject *kobj);
};

struct sysfs_ops {
 ssize_t (*show)(struct kobject *, struct attribute *,char *); //读如上属性文件时调用该函数
 ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t); //写如上属性文件时调用该函数
};

直接贴上示例程序，该模块只是简单注册一个kobject，kobject中包含一个名为kobj_config的属性文件


kobject.c

  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_LICENSE("Dual BSD/GPL");
  10.  
  11. void obj_test_release(struct kobject *kobject);
  12. ssize_t kobj_test_show(struct kobject *kobject, struct attribute *attr,char *buf);
  13. ssize_t kobj_test_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count);


  16. //定义的一个属性文件，名字为kobj_config,权限为可读可写
  17. struct attribute test_attr = {
  18.         .name = "kobj_config",
  19.         .mode = S_IRWXUGO,
  20. };
  21.  
  22. static struct attribute *def_attrs[] = {
  23.         &test_attr,
  24.         NULL,
  25. };
  26.  
  27.  
  28. struct sysfs_ops obj_test_sysops =
  29. {
  30.         .show = kobj_test_show, //当对属性文件kobj_config进行读时，执行此函数
  31.         .store = kobj_test_store,//当对属性文件kobj_config进行写时，执行此函数
  32. };
  33. //定义一个kobj_type,描述要注册的kobject的类型信息，如属性和释放操作
  34. struct kobj_type ktype =
  35. {
  36.         .release = obj_test_release, //kobject释放函数
  37.         .sysfs_ops=&obj_test_sysops, //属性文件操作函数
  38.         .default_attrs=def_attrs, //定义的默认属性文件数组
  39. };
  40. //当kobj的应用计数为0时，用于释放kobj的资源，这里只是执行了一条打印信息
  41. void obj_test_release(struct kobject *kobject)
  42. {
  43.         printk("eric_test: release .\n");
  44. }

  46. //当对属性文件kobj_config进行读时，执行此函数
  47. ssize_t kobj_test_show(struct kobject *kobject, struct attribute *attr,char *buf)
  48. {
  49.         printk("have show.\n");
  50.         printk("attrname:%s.\n", attr->name);
  51.         sprintf(buf,"%s\n",attr->name);
  52.         return strlen(attr->name)+2;
  53. }
  54. //当对属性文件kobj_config进行写时，执行此函数
  55. ssize_t kobj_test_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count)
  56. {
  57.         printk("havestore\n");
  58.         printk("write: %s\n",buf);
  59.         return count;
  60. }
  61. //定义一个kobj，在模块加载函数中注册
  62. struct kobject kobj;
  63. //模块加载函数
  64. static int kobj_test_init(void)
  65. {
  66.         int ret;
  67.         printk("kboject test init111.\n");
  68.         //初始化并添加一个kobject
  69.         //&kobj==添加的kobject；&ktype==kobject的ktype结构；NULL==该注册的kobject的父kobject,如果为NULL，这表示注册到sys最顶层目录；"kobject_test"==kobject的名字；
  70.         ret=kobject_init_and_add(&kobj,&ktype,NULL,"kobject_test");
  71.         if(ret)
  72.             return -1;
  73.         return 0;
  74. }

  76. //模块注销时执行此函数，删除注册的kobject
  77. static void kobj_test_exit(void)
  78. {
  79.         printk("kobject test exit.\n");
  80.         kobject_del(&kobj);
  81. }
  82.  
  83. module_init(kobj_test_init);
  84. module_exit(kobj_test_exit);
编译完成之后，看看加载之后的效果,执行insmod kobject.ko
操作结果我直接截图了

如我们预期的一样，加载kobject.ko成功之后，在sys/目录下多了一个kobject_test目录，该目录下有一个kobj_config的属性文件。
读kobj_config文件时，程序中的kobj_test_show会得到执行，对kobj_config文件进行写操作时，kobj_test_store函数会得到执行
--------------------------------------------------------------------------------------------------------------------------
kset是嵌入相同类型结构的kobject的集合，kset结构包含一个kobject结构，在sys文件系统上表现出的也是一个目录。和kobject不同的是，kset的目录还可以包含目录，而kobject的目录只能包含属性文件。kset中还包含其子kobject的热插拔处理函数。
kset 结构定义如下：
struct kset {
 struct list_head list; //链接该kset中所有的kobject的链表头
 spinlock_t list_lock;
 struct kobject kobj; //内嵌的kobject
 const struct kset_uevent_ops *uevent_ops; //处理热插拔事件的操作集合
};

struct kset_uevent_ops {
 int (* const filter)(struct kset *kset, struct kobject *kobj); //决定是否将产生事件传递到用户空间，如果返回0，将不传递事件
 const char *(* const name)(struct kset *kset, struct kobject *kobj);// 用于将字符串传递给用户空间的热插拔处理程序
 int (* const uevent)(struct kset *kset, struct kobject *kobj, struct kobj_uevent_env *env); //通过环境变量传递热插拔脚本需要的信息,环境变量存在kobj_uevent_env中
};

下面还是提供一个简单的示例程序，注册两个kset,一个kset_p,一个kset_c,kset_c位于kset_p里面，所以当kset_c加入kset_p时会产生相关热插拔信息

kset.c

  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. #include <linux/kobject.h>
  9.  
  10. MODULE_LICENSE("Dual BSD/GPL");
  11.  
  12. struct kset kset_p;
  13. struct kset kset_c;
  14. void kset_p_release(struct kobject *kobject);
  15. void kset_c_release(struct kobject *kobject);
  16. ssize_t kobj_test_show(struct kobject *kobject, struct attribute *attr,char *buf);
  17. ssize_t kobj_test_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count);


  20. struct sysfs_ops kset_p_sysops =
  21. {
  22.         .show = kobj_test_show,
  23.         .store = kobj_test_store,
  24. };
  25. struct sysfs_ops kset_c_sysops =
  26. {
  27.         .show = kobj_test_show,
  28.         .store = kobj_test_store,
  29. };
  30. //kset_p内嵌kobject的类型信息,这里没有做添加具体属性
  31. struct kobj_type ktype_p =
  32. {
  33.         .release = kset_p_release,
  34.         .sysfs_ops=&kset_p_sysops,
  35. };
  36. //kset_c内嵌kobject的类型信息,这里没有做添加具体属性
  37. struct kobj_type ktype_c =
  38. {
  39.         .release = kset_c_release,
  40.         .sysfs_ops=&kset_c_sysops,
  41. };

  43. void kset_p_release(struct kobject *kobject)
  44. {
  45.         printk("eric_test: kset_p_release .\n");
  46. }
  47. void kset_c_release(struct kobject *kobject)
  48. {
  49.         printk("eric_test: kset_c_release .\n");
  50. }

  52. ssize_t kobj_test_show(struct kobject *kobject, struct attribute *attr,char *buf)
  53. {
  54.         return 0;
  55. }
  56.  
  57. ssize_t kobj_test_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count)
  58. {
  59.         return 0;
  60. }
  61. //决定是否将产生事件传递到用户空间，如果返回0，将不传递事件
  62. //此处永远返回1，表示将产生事件传递到用户空间
  63. int kset_filter(struct kset *kset, struct kobject *kobj)
  64. {
  65.         printk("Filter: kobj %s.\n",kobj->name);
  66.         return 1;
  67. }

  69. // 用于将字符串传递给用户空间的热插拔处理程序，传递的字符串存入buf中
  70. const char *kset_name(struct kset *kset, struct kobject *kobj)
  71. {
  72.         static char buf[20];
  73.         printk("Name: kobj %s.\n",kobj->name);
  74.         sprintf(buf,"%s","kset_name");
  75.         return buf;
  76. }
  77.  //通过环境变量传递热插拔脚本需要的信息,环境变量存在kobj_uevent_env中
  78.  //此处只是将环境变量信息打印出来，并没有添加新的信息
  79. int kset_uevent(struct kset *kset, struct kobject *kobj,struct kobj_uevent_env *env)
  80. {
  81.         int i = 0;
  82.         printk("uevent: kobj %s.\n",kobj->name);

  84.         while( i < env->envp_idx){
  85.                 printk("%s.\n",env->envp[i]);
  86.                 i++;
  87.         }

  89.         return 0;
  90. }

  92. //kset_p热插拔处理程序,这里当注册kset_c时，即将kset_c加入kset_p时，相关函数会执行
  93. struct kset_uevent_ops uevent_ops =
  94. {
  95.         .filter = kset_filter,
  96.         .name = kset_name,
  97.         .uevent = kset_uevent,
  98. };

  100. //模块加载函数
  101. int kset_test_init(void)
  102. {
  103.         int ret;
  104.         
  105.         printk("kset test init1.\n");
  106.         //设置kset_p的名字
  107.         kobject_set_name(&kset_p.kobj,"kset_p");
  108.         //设置kset_p内嵌Kobject的ktype类型，我在3.0.36的代码里运行，必现要加这个，不然会出现内核异常
  109.         kset_p.kobj.ktype=&ktype_p;
  110.         //设置热插拔处理程序
  111.         kset_p.uevent_ops = &uevent_ops;
  112.         //注册kset_p到系统
  113.         ret=kset_register(&kset_p);
  114.         if(ret){
  115.             printk("register kset_p fail\n");
  116.             return -1;
  117.         }
  118.         //设置kset_次的名字
  119.         kobject_set_name(&kset_c.kobj,"kset_c");
  120.         //设置kset_c内嵌Kobject的ktype类型，我在3.0.36的代码里运行，必现要加这个，不然会出现内核异常
  121.         kset_c.kobj.ktype=&ktype_c;
  122.         //设置kset_c内嵌的kobject结构的kset指针执行kset_p，就相当于设置kset_c的父目录为kset_p
  123.         kset_c.kobj.kset = &kset_p;
  124.         //注册kset_c到系统
  125.         ret=kset_register(&kset_c);
  126.         if(ret){
  127.             printk("register kset_c fail\n");
  128.             return -1;
  129.         }
  130.         return 0;
  131. }
  132.  
  133. void kset_test_exit(void)
  134. {
  135.         printk("kset test exit.\n");
  136.         kset_unregister(&kset_p);
  137.         kset_unregister(&kset_c);
  138. }
  139.  
  140. module_init(kset_test_init);
  141. module_exit(kset_test_exit);
编译完成之后，看加载的执行效果
加载程序时相应的热插拔程序得到了执行，同时sys目录下也增加了相应的文件夹
删除kset模块

删除之后的热插拔信息，并没有打印出来，当我再次加载kset时，上传删除kset的热插拔打印信息才打印出来，不解中


最后再贴上编译kobject.c和kset.c的Makefile文件，如要使用该Makefile，请自行修改编译工具链，编译内核代码地址，和编译文件

Makefile

  1. ifneq ($(KERNELRELEASE),)

  3. obj-m := kset.o //要编译的文件

  5. else
  6.     
  7. KDIR := /home/jason/h18/pizza/kernel //运行系统的kernl代码目录
  8. all:
  9.     make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-eabi- //编译链
  10. clean:
  11.     rm -f *.ko *.o *.mod.o *.mod.c *.symvers

  13. endif





阅读(1618) | 评论(0) | 转发(0) |
0

上一篇：linux 定时器的使用

下一篇：Linux设备模型简单实现示例

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

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

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

16024965号-6