kobject&kset

sysfs文件系统

“sysfs is a ram-based filesystem initially based on ramfs. It provides a means to export kernel data structures, their attributes, and the linkages between them to userspace.”

---documentation/filesystems/sysfs.txt

（ramdisk is also ram-based filesystem。ramdisk是一种磁盘模拟的技术，ramdisk之上实际运行的文件系统是ext2、ext3、ext4，除此之外，还有proc，proc也是基于内存的文件系统，proc文件系统提供一个接口给用户，让用户能够查看系统运行的一些状态信息，让用户可以修改内核的一些参数，比如说，printk的打印区别可以通过proc来修改。）

Linux2.6内核引入了sysfs文件系统。sysfs被看成是与proc同类别的文件系统。sysfs把连接在系统上的设备和总线组织成分级的文件，使其从用户空间可以访问到。sysfs被加载在/sys/目录下，它的子目录包括：

·block：在系统中发现的每个块设备在该目录下对应一个子目录。每个子目录中又包含一些属性文件，它们描述了这个块设备的各方面属性，如：设备大小。（loop块设备是使用文件来模拟的）

·bus：在内核中注册的每条总线在该目录下对应一个子目录，如：ide pci scsi usb pcmcia。其中每个总线目录内又包含两个子目录：devices和driver，devices目录包含了在整个系统中发现的属于该总线类型的设备，drivers目录包含了注册到该总线的所有驱动。

·class：将设备按照功能进行的分类，如/sys/class/net目录下包含了所有网络接口。

·devices：包含系统所有的设备。

·kernel：内核中的配置参数。

·module：系统中所有模块的信息。

·firmware：系统中的固件。

·fs：描述系统中的文件系统。

·power：系统中电源选项。

kobject

kboject实现了基本的面向对象管理机制，是构成Linux2.6设备模型的核心结构。它与sysfs文件系统紧密相连，在内核中注册的每个kobject对象对应sysfs文件系统中的一个目录。它类似于C++中的基类，kobject常被嵌入于其他类型（即：容器）中。如bus，devices，driver是都是典型的容器。这些容器通过kobject连接起来，形成了一个树状接口。

struct kobject{
    const char *name;
    struct list_head entry;
    struct kobject *parent; /* 指向父对象 */
    struct kset *kset;
    struct kobj_type *ktype;
    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;
};

kobject操作

void kobject_init(struct kobject *kobj)

初始化kobject结构

int kobject_add(struct kobject *kobj)

将kobject对象注册到Linux系统

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

初始化kobject，并将其注册到linux系统

void kobject_del(struct kobject *kobj)

从Linux系统中删除kobject对象

struct kobject *kobject_get(struct kobject *kobj)

将kobject对象的引用计数加1，同时返回该对象指针

void kobjec_put(struct kobject *kobj)

将kobject对象的引用计数减1，如果引用计数降为0，则调用release方法释放该kobject对象

struct kobj_type

kobject的ktype成员是一个指向kobj_type结构的指针，该结构中记录了kobject对象的一些属性。

struct kobj_type{
    void (*release)(struct kobject *kobj);
    struct sysfs_ops *sysfs_ops;
    struct attribute **default_attrs;
};

release：用于释放kobject占用的资源，当kobject的引用计数为0时被调用。

struct attribute

struct attribute{
    char *name; /* 属性文件名 */
    struct module *owner;
    mode_t mode; /* 属性的保护位 */
};

struct attribute（属性）：对应于kobject的目录下的一个文件，name成员就是文件名。

struct sysfs_ops

struct sysfs_ops{
    ssize_t (*show)(struct kobject*, struct attribute *, char *);
    ssize_t (*store)(struct kobject*, struct attribute *, const char *, size_t);
};

show：当用户读属性文件时，该函数被调用，该函数将属性值存入buffer中返回给用户态；

store：当用户写属性文件时，该函数被调用，用于存储用户传入的属性值。

 

kobject内核模块代码：

#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/stat.h>

MODULE_AUTHOR("David Xie");
MODULE_LICENSE("Dual BSD/GPL");

void obj_test_release(struct kobject *kobject);
ssize_t kobj_test_show(struct kobject *kobject, struct attribute *attr,char *buf);
ssize_t kobj_test_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count);

struct attribute test_attr = {
        .name = "kobj_config", //②
        .mode = S_IRWXUGO,
};

static struct attribute *def_attrs[] = {
        &test_attr,
        NULL,
};


struct sysfs_ops obj_test_sysops =
{
        .show = kobj_test_show,
        .store = kobj_test_store,
};

struct kobj_type ktype =
{
        .release = obj_test_release,
        .sysfs_ops=&obj_test_sysops,
        .default_attrs=def_attrs,
};

void obj_test_release(struct kobject *kobject)
{
        printk("eric_test: release .\n");
}

ssize_t kobj_test_show(struct kobject *kobject, struct attribute *attr,char *buf) //③
{
        printk("have show.\n");
        printk("attrname:%s.\n", attr->name);
        sprintf(buf,"%s\n",attr->name);
        return strlen(attr->name)+2;
}

ssize_t kobj_test_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count)
{
        printk("havestore\n");
        printk("write: %s\n",buf);
        return count;
}

struct kobject kobj;
static int kobj_test_init()
{
        printk("kboject test init.\n");
        kobject_init_and_add(&kobj,&ktype,NULL,"kobject_test"); //①
        return 0;
}

static int kobj_test_exit()
{
        printk("kobject test exit.\n");
        kobject_del(&kobj);
        return 0;
}

module_init(kobj_test_init);
module_exit(kobj_test_exit);

 

测试：

Step 1：检测/sys/目录下是否生成kobject_test目录；（对应于//①）
Step 2：检测/sys/kobject_test/目录下是否生成kobj_config文件；（对应//②）
Step 3：检测当读kobj_config文件时打印的信息；（对应//③）

kset

kset是具有相同类型的kobject的集合，在sysfs中体现成一个目录，在内核中用kset数据结构表示，定义为：

struct kset{
    struct list_head list; /* 连接该kset中所有kobject的链表头 */
    spinlock_t list_lock;
    struct kobject kobj; /* 内嵌的kobject */
    struct kset_uevent_ops *uevent_ops; /* 处理热拔插事件的操作集合 */
}

kset操作

int kset_register(struct kset *kset)

在内核中注册一个kset

void kset_unregister(struct kset *kset)

从内核中注销一个kset

热插拔事件

在Linux系统中，当系统配置发生变化时，如：添加kset到系统、移动kobject，一个通知会从内核空间发送到用户空间，这就是热拔插事件。热拔插事件会导致用户空间中的处理程序（如udev，mdev）被调用，这些处理程序会通过加载驱动程序，创建设备节点等来响应热拔插事件。

操作集合

struct kset_uevent_ops{
    int (*filter)(struct kset *kset, struct kobject *kobj);
    const char *(*name)(struct kset *kset, struct kobject *kobj);
    int (*uevent)(struct kset *kset, struct kobject *kobj, struct kobj_uevent_env *env);
}

这三个函数什么时候调用？

当该kset所管理的kobject和kset状态发生变化时（如被加入，移动），这三个函数将被调用。（例：kobject_uevent调用）

这三个函数的功能是什么？

filter：决定是否将事件传递到用户空间。如果filter返回0，将不传递事件。（例：uevent_filter）

name：用于将字符串传递给用户空间的热拔插处理程序。

uevent：将用户空间需要的参数添加到环境变量中。（例：dev_uevent）

 

kobject内核模块代码：

#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/stat.h>
#include <linux/kobject.h>

MODULE_AUTHOR("David Xie");
MODULE_LICENSE("Dual BSD/GPL");

struct kset kset_p;
struct kset kset_c;

int kset_filter(struct kset *kset, struct kobject *kobj)
{
        printk("Filter: kobj %s.\n",kobj->name);
        return 1;
}

const char *kset_name(struct kset *kset, struct kobject *kobj)
{
        static char buf[20];
        printk("Name: kobj %s.\n",kobj->name);
        sprintf(buf,"%s","kset_name");
        return buf;
}

int kset_uevent(struct kset *kset, struct kobject *kobj,struct kobj_uevent_env *env)
{
        int i = 0;
        printk("uevent: kobj %s.\n",kobj->name);

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

        return 0;
}

struct kset_uevent_ops uevent_ops =
{
        .filter = kset_filter,
        .name   = kset_name,
        .uevent = kset_uevent,
};

int kset_test_init()
{
        printk("kset test init.\n");
        kobject_set_name(&kset_p.kobj,"kset_p");
        kset_p.uevent_ops = &uevent_ops;
        kset_register(&kset_p);

        kobject_set_name(&kset_c.kobj,"kset_c");
        kset_c.kobj.kset = &kset_p;
        kset_register(&kset_c);
        return 0;
}

int kset_test_exit()
{
        printk("kset test exit.\n");
        kset_unregister(&kset_p);
        kset_unregister(&kset_c);
        return 0;
}

module_init(kset_test_init);
module_exit(kset_test_exit);

测试：

/sys/kset_p/kset_c