linux kset subsystem 3.10内核,sysfs源码笔记

sysfs就是linux中/sys/下的所有内容，官方文档中sysfs的定义如下：

sysfs 是一个最初基于 ramfs 且位于内存的文件系统。它提供导出内核

数据结构及其属性，以及它们之间的关联到用户空间的方法。只要内核配置中定义了 CONFIG_SYSFS ，sysfs 总是被编译进内核。你可

通过以下命令挂载它:

mount -t sysfs sysfs /sys

本文的代码是基于centos7，linux内核3.10

一、sysfs在linux中是什么样的

在linux中的/sys/目录下，可以看到很多子目录：

/block 所有的块设备

/bus 系统中所有的总线

/class 设备类型(比如scsi_class)

/device 系统中的所有设备

/driver 内核注册的驱动程序

之后可以看到，sysfs在linux的中的文件夹、文件全都是“虚拟出来的”，对文件的读写，不是真的读写，而是对函数的调用

二、sysfs的骨骼：kobject， kset， subsystem

sysfs在linux中的目录结构是怎么构造出来的，秘密就kobject、kset和subsystem中：

kobject sysfs最基本的结构体，对应sysfs中的一个目录，提供引用计数等重要功能(kobject.h中定义)

kset 一系列的kobject的集合，kobject的顶层类(kobject.h中定义)

subsystem 一系列的kset的集合，在3.10内核中已经没有subsystem的结构体了，变成了在drivers/base.h中定义的device_private和subsys_private结构体，不过这个概念还是存在于内核代码中，只是本质上也是管理几个kset。

kobject和kset的结构体如下：

struct kobject {

const char *name; //名称

struct list_head entry;

struct kobject *parent;

struct kset *kset; //属于哪个keset

struct kobj_type *ktype; //relase\store\show函数，用于sysfs调用

struct sysfs_dirent *sd; //kobject的基础：目录

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;

};

需要说明的几点：

*sd 是kobject的基石，最终sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR); 目录就是这样创建出来的(file.c中定义)

*kset 指向一个kset

kref 调用kobject_get()会增加引用计数，调用kobject_put()会减少引用计数，减少到0会release这个kobj

kset:

struct kset {

struct list_head list; //保存了一些列的kobject的列表

spinlock_t list_lock;

struct kobject kobj; //keset继承了kobj

const struct kset_uevent_ops *uevent_ops;

};

需要说明的几点：

kset这个结构体本身比较简单，而且其本身也继承了一个kobject，所以kset自己也是一个目录

subsystem也是一个kset，sys/目录下的bus、class的目录，就是一个subsystem

关于kset和kobject的关系，有一个经典的图，如下：

Paste_Image.png

三、kobject、kset的处理函数

关于kobject的几个处理函数如下(kobject.c中定义)：

初始化一个kobject函数

void kobject_init(struct kobject *kobj, struct kobj_type *ktype)

{

char *err_str;

if (!kobj) {

err_str = "invalid kobject pointer!";

goto error;

}

if (!ktype) {

err_str = "must have a ktype to be initialized properly!\n";

goto error;

}

if (kobj->state_initialized) {

/* do not error out as sometimes we can recover */

printk(KERN_ERR "kobject (%p): tried to init an initialized "

"object, something is seriously wrong.\n", kobj);

dump_stack();

}

kobject_init_internal(kobj);//真正的初始化

kobj->ktype = ktype;//赋值ktype

return;

error:

printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);

dump_stack();

}

static void kobject_init_internal(struct kobject *kobj)

{

if (!kobj)

return;

kref_init(&kobj->kref); //初始化引用计数

//初始化几个状态变量

INIT_LIST_HEAD(&kobj->entry);

kobj->state_in_sysfs = 0;

kobj->state_add_uevent_sent = 0;

kobj->state_remove_uevent_sent = 0;

kobj->state_initialized = 1;

}

kobject_add：将一个kobject链接到一个父节点上(比如说kset的kobject节点)

并创建kobject的目录！

int kobject_add(struct kobject *kobj, struct kobject *parent, const char *fmt, ...)

{

va_list args;

int retval;

if (!kobj)

return -EINVAL;

if (!kobj->state_initialized) {

printk(KERN_ERR "kobject '%s' (%p): tried to add an "

"uninitialized object, something is seriously wrong.\n",

kobject_name(kobj), kobj);

dump_stack();

return -EINVAL;

}

va_start(args, fmt);

retval = kobject_add_varg(kobj, parent, fmt, args);//调用kobject_add_varg

va_end(args);

return retval;

}

static int kobject_add_varg(struct kobject *kobj, struct kobject *parent, const char *fmt, va_list vargs)

{

int retval;

retval = kobject_set_name_vargs(kobj, fmt, vargs);

if (retval) {

printk(KERN_ERR "kobject: can not set name properly!\n");

return retval;

}

kobj->parent = parent; //链接上父节点

return kobject_add_internal(kobj);//调用kobject_add_internal

}

static int kobject_add_internal(struct kobject *kobj)

{

int error = 0;

struct kobject *parent;

if (!kobj)

return -ENOENT;

if (!kobj->name || !kobj->name[0]) {

WARN(1, "kobject: (%p): attempted to be registered with empty "

"name!\n", kobj);

return -EINVAL;

}

parent = kobject_get(kobj->parent);

/* join kset if set, use it as parent if we do not already have one */

//如果kobj有kset,parent指向kset的kobject

if (kobj->kset) {

if (!parent)

parent = kobject_get(&kobj->kset->kobj);

kobj_kset_join(kobj);

kobj->parent = parent;

}

pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",

kobject_name(kobj), kobj, __func__,

parent ? kobject_name(parent) : "",

kobj->kset ? kobject_name(&kobj->kset->kobj) : "");

//调用kobj中的sd去创建一个目录

error = create_dir(kobj);

if (error) {

kobj_kset_leave(kobj);

kobject_put(parent);

kobj->parent = NULL;

/* be noisy on error issues */

if (error == -EEXIST)

WARN(1, "%s failed for %s with "

"-EEXIST, don't try to register things with "

"the same name in the same directory.\n",

__func__, kobject_name(kobj));

else

WARN(1, "%s failed for %s (error: %d parent: %s)\n",

__func__, kobject_name(kobj), error,

parent ? kobject_name(parent) : "'none'");

} else

kobj->state_in_sysfs = 1;

return error;

}

kset的初始化

void kset_init(struct kset *k)

{

kobject_init_internal(&k->kobj);//初始化kset自己的kobject，创建kset的目录

INIT_LIST_HEAD(&k->list); //初始化一个列表保存链接上来的kobject

spin_lock_init(&k->list_lock);

}

kset注册函数，调用kset_init,kobject_add_internal后再调用kobject_uvent通知用户空间

kobject_uevent_env函数比较难懂,具体来说就是触发某个事件，把事件写在env里面，然后通知用户空间。

int kset_register(struct kset *k)

{

int err;

if (!k)

return -EINVAL;

kset_init(k); //初始化kobject

err = kobject_add_internal(&k->kobj);//将keset自己的kobject链接到自己的kset

if (err)

return err;

kobject_uevent(&k->kobj, KOBJ_ADD);//通知用户空间

return 0;

}

int kobject_uevent(struct kobject *kobj, enum kobject_action action)

{

return kobject_uevent_env(kobj, action, NULL);

}

int kobject_uevent_env(struct kobject *kobj, enum kobject_action action, char *envp_ext[])

{

struct kobj_uevent_env *env;

const char *action_string = kobject_actions[action];

const char *devpath = NULL;

const char *subsystem;

struct kobject *top_kobj;

struct kset *kset;

const struct kset_uevent_ops *uevent_ops;

int i = 0;

int retval = 0;

/* search the kset we belong to */

top_kobj = kobj;

kset = top_kobj->kset;

uevent_ops = kset->uevent_ops; //kset结构体中的uevent_ops函数,热插拔函数！！！

//如果是原始的subsystem

/* originating subsystem */

if (uevent_ops && uevent_ops->name)

subsystem = uevent_ops->name(kset, kobj);

else

subsystem = kobject_name(&kset->kobj);

if (!subsystem) {

pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the "

"event to drop!\n", kobject_name(kobj), kobj,

__func__);

return 0;

}

/* environment buffer */

env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);

if (!env)

return -ENOMEM;

/* complete object path */

devpath = kobject_get_path(kobj, GFP_KERNEL);

if (!devpath) {

retval = -ENOENT;

goto exit;

}

/* default keys */

retval = add_uevent_var(env, "ACTION=%s", action_string); //action_string='add'

if (retval)

goto exit;

retval = add_uevent_var(env, "DEVPATH=%s", devpath);

if (retval)

goto exit;

retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);

if (retval)

goto exit;

........省略

retval = call_usermodehelper(argv[0], argv, env->envp, UMH_WAIT_EXEC);

}

三、sysfs的例子

源码在https://github.com/martinezjavier/ldd3/tree/master/lddbus

可以看一个sysfs的例子，来自于ldd3中的lddbus示例，目标是在/sys/bus中创建一个自定义的bus，以及在/sys/device/下创建ldd0的块设备

1.创建一个device

//device结构体中包含一个struct kobject kobj;

struct device ldd_bus = {

.init_name = "ldd0",

.release = ldd_bus_release

};

//注册这个device

ret = device_register(&ldd_bus);

//实际上这个函数和kobject_init和kobject_add是完全对应的，在device下创建ldd0块设备

int device_register(struct device *dev)

{

device_initialize(dev);

return device_add(dev);

}

2.创建一个bus_type

struct bus_type ldd_bus_type = {

.name = "ldd",

.match = ldd_match, //两个自定义函数

.uevent = ldd_uevent,

};

//bus_type的完整结构体，在Device.h中定义

struct bus_type {

const char *name;

const char *dev_name;

struct device *dev_root; //这里有一个device的结构体

struct bus_attribute *bus_attrs;

struct device_attribute *dev_attrs;

struct driver_attribute *drv_attrs;

int (*match)(struct device *dev, struct device_driver *drv);

int (*uevent)(struct device *dev, struct kobj_uevent_env *env);

int (*probe)(struct device *dev);

int (*remove)(struct device *dev);

void (*shutdown)(struct device *dev);

int (*suspend)(struct device *dev, pm_message_t state);

int (*resume)(struct device *dev);

const struct dev_pm_ops *pm;

struct iommu_ops *iommu_ops;

struct subsys_private *p;

struct lock_class_key lock_key;

};

3.在bus下，会创建一个ldd的文件夹，这里会有subsystem的概念，在ldd内通过subsys创建driver和device的目录，

static int __init ldd_bus_init(void)

{

int ret;

//注册bus_type

ret = bus_register(&ldd_bus_type);

if (ret)

return ret;

//创建属性

if (bus_create_file(&ldd_bus_type, &bus_attr_version))

printk(KERN_NOTICE "Unable to create version attribute\n");

//创建了ldd0的块设备

ret = device_register(&ldd_bus);

if (ret)

printk(KERN_NOTICE "Unable to register ldd0\n");

return ret;

}

//注册bus_type

int bus_register(struct bus_type *bus)

{

int retval;

struct subsys_private *priv; //subsystem的概念在这里体现的，bus_type中继承了subsys_private

struct lock_class_key *key = &bus->lock_key;

priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);

if (!priv)

return -ENOMEM;

priv->bus = bus;

bus->p = priv;

BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);

retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name); //用bus的name“ldd”来命令priv中的kset：subsys

if (retval)

goto out;

priv->subsys.kobj.kset = bus_kset;

priv->subsys.kobj.ktype = &bus_ktype;

priv->drivers_autoprobe = 1;

retval = kset_register(&priv->subsys);//注册subsystem的kset，创建了ldd的文件夹

if (retval)

goto out;

retval = bus_create_file(bus, &bus_attr_uevent);

if (retval)

goto bus_uevent_fail;

priv->devices_kset = kset_create_and_add("devices", NULL,

&priv->subsys.kobj);//创建device文件夹

if (!priv->devices_kset) {

retval = -ENOMEM;

goto bus_devices_fail;

}

priv->drivers_kset = kset_create_and_add("drivers", NULL,

&priv->subsys.kobj);//创建driver文件夹

if (!priv->drivers_kset) {

retval = -ENOMEM;

goto bus_drivers_fail;

}

INIT_LIST_HEAD(&priv->interfaces);

__mutex_init(&priv->mutex, "subsys mutex", key);

klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);

klist_init(&priv->klist_drivers, NULL, NULL);

retval = add_probe_files(bus);//在bus下，创建ldd文件夹

if (retval)

goto bus_probe_files_fail;

retval = bus_add_attrs(bus);

if (retval)

goto bus_attrs_fail;

pr_debug("bus: '%s': registered\n", bus->name);

return 0;

}

四、sysfs的叶子 —— attribute

之前说到一个kobject就是sysfs中的一个目录，一个kset是一组目录，现在看看sysfs中的一个目录/sys/bus/cpu/

/devices/ 目录

/drivers/ 目录

drivers_autoprobe 文件

drivers_probe 文件

uevent 文件

可以看到除了两个目录(在结构体subsys_private中定义的kset)之外，还有三个文件，这三个文件在sysfs中是如何实现的？实际上这是sysfs中的属性的概念。

//sysfs.h中定义

struct attribute {

const char *name; //定义了文件名称

umode_t mode;

}

在lddbus的实例代码中，需要在ldd文件夹下创建一个文件，需要定义一个bus_attribute的结构体，其原型如下：

struct bus_attribute {

struct attribute attr; //继承了attribute结构体

ssize_t (*show)(struct bus_type *bus, char *buf);

ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);

};

这个结构体定义了两个函数，show和store，分别代表了对这个文件的读和写操作，在实例中定义了一个show函数，显示一个version的字符串：

static ssize_t show_bus_version(struct bus_type *bus, char *buf)

{

return snprintf(buf, PAGE_SIZE, "%s\n", Version);

}

最后创建一个bus_attribute的结构体：

//这里有个技巧，利用BUS_ATTR的宏定义，生成一个名叫bus_attr_version的bus_attribute结构体，store函数为空，传入show函数

static BUS_ATTR(version, S_IRUGO, show_bus_version, NULL);

将这个结构体注册在bus_type中：

bus_create_file(&ldd_bus_type, &bus_attr_version)

就可以看到/sys/bus/ldd/version这个文件了，cat这个文件得的正是show_bus_version函数返回的内容。