Linux kobject和kset

Kobject实现了基本的面向对象管理机制，它与sysfs文件系统密切关联。在内核中注册的每个kobject对象对应sysfs文件系统中的一个目录。

struct 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, struct kobject *parent, const char *fmt,…)
初始化kobject，并将其注册到linux系统

void kobject_del(struct kobject *kobj);
删除kobject对象

struct kobject *kobject_get(struct kobject *kobj);
将kobject对象的引用计数加1，同时返回该对象指针

void kobject_put(struct kobject *kobj);
将kobject对象的引用计数减1，如果引用计数为0，则调用release方法释放该kobject对象

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 {
char *name;
struct module *owener;
mode_t mode;
};
struct attribute:对应于kobject目录下的一个文件，name成员就是文件名。
struct sysfs_ops {
ssize_t (*show)(struct kobject *,struct atttribute *,char *);
ssizt_t (*store)(struct kobject *,struct attribute *,const char *, size_t)
}；
show 当用户读属性文件时，该函数被调用，该函数将属性值存入buffer中返回给用户态
store 当用户写属性文件时，该函数被调用，用于存储用户传入的属性值

范例：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/kthread.h>
#include <linux/kobject.h>

MODULE_LICENSE("GPL");

struct kobject kobj;


ssize_t kobject_show(struct kobject *kobj, struct attribute *attr, char *buf);
ssize_t kobject_store(struct kobject *kobj, struct attribute * attr, const char *buf, size_t size);
void obj_test_release(struct kobject *kobj);

struct sysfs_ops obj_test_sysops =
{
    .show = kobject_show,
    .store = kobject_store,
};
struct attribute test_attr1 =
{
    .name = "kobj_config",
    .mode = S_IRWXUGO,
};
struct attribute test_attr2 =
{
    .name = "kobj_config02",
    .mode = S_IRWXUGO,
};
struct attribute *def_attrs[] =
{
    &test_attr1,
    NULL,
};
struct kobj_type ktype = {
    .release = obj_test_release,
    .sysfs_ops = &obj_test_sysops,
    .default_attrs = def_attrs,
};

void obj_test_release(struct kobject *kobj)
{
    printk("call obj test release......\n");
}
ssize_t kobject_show(struct kobject *kobj, 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 kobject_store(struct kobject *kobj, struct attribute * attr, const char *buf, size_t size)
{
    printk("have store\n");
    printk("write %s\n",buf);
    return size;
}

static int __init mykobject_init(void)
{
        printk("call %s\n", __FUNCTION__);
        kobject_init_and_add(&kobj, &ktype, NULL, "kobject_test04");

        return 0;
}


static void __exit mykobject_exit(void)
{
    printk("call %s\n", __FUNCTION__);
}


module_init(mykobject_init);
module_exit(mykobject_exit);

kset是具有相同类型的kobject的集合，在sysfs中体现成一个目录，在内核中用如下数据结构表示：
struct kset
{
struct list_head list; //连接该kset中所有kobject的链表头
spinlock_t list_lock;
struct kobject kobj; //内嵌的kobject
struct kset_uevent_ops *uevent_ops; // 处理热插拔事件的操作事件
}
struct kset_uevent_ops
{
//决定是否将事件传递到用户空间，filter返回0，表示将不传递事件
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状态发生变化（加入、移动）时，这三个函数将被调用。

注册一个kset
int kset_register(struct kset *kset);
注销一个kset
void kset_unregister(struct kset *kset);

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

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/kthread.h>
#include <linux/kobject.h>

MODULE_LICENSE("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;
}

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

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,
    .uevent = kset_uevent,
};

static int __init kset_test_init(void)
{
        printk("call %s\n", __FUNCTION__);
        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;
}


static void __exit kset_test_exit(void)
{
    printk("call %s\n", __FUNCTION__);
    kset_unregister(&kset_p);
    kset_unregister(&kset_c);
}