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