Linux设备模型4 kobj_attribute

Vane Zhang

已于 2023-09-04 19:23:10 修改

阅读量338

点赞数

分类专栏： linux内核文章标签： linux

于 2023-09-04 19:14:12 首次发布

原文链接：https://blog.csdn.net/shenwanjiang111/article/details/52414648

版权

linux内核专栏收录该内容

10 篇文章 0 订阅

订阅专栏

在上文Linux设备模型-3-_Kobject 实例中，我们介绍到如何使用default attribute。Default attribute使用很方便，但不够灵活。比如上篇文章在Kobject一节中提到的那个例子，name和val这两个attribute使用同一个show/store函数来访问，如果attribute非常多，show/store函数里的分支就会很凌乱。

为了解决这个问题，我们可以参考内核提供的kobj_attribute。在内核里，kobj_attibute是这样定义的：

struct kobj_attribute {
    struct attribute attr;
    ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
            char *buf);
    ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
             const char *buf, size_t count);
};

每一个attribute会对应自己的show/store函数，这样就极大的提高了灵活性。可是，在上一篇文章中我们的认知是，sysfs是通过kobject里的kobj_type->sysfs_ops来读写attribute的，那如果要利用kobj_attribute中的show/store来读写attribute的话，就必须在kobj_type->sysfs_ops里指定。Linux内核提供了一个默认的kobj_type类型dynamic_kobj_ktype来实现上述的操作。

/* default kobject attribute operations */
static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,char *buf)
{
    struct kobj_attribute *kattr;
    ssize_t ret = -EIO;

    kattr = container_of(attr, struct kobj_attribute, attr);
    if (kattr->show)
        ret = kattr->show(kobj, kattr, buf);

    return ret;
}

static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,const char *buf, size_t count)
{
    struct kobj_attribute *kattr;
    ssize_t ret = -EIO;

    kattr = container_of(attr, struct kobj_attribute, attr);
    if (kattr->store)
        ret = kattr->store(kobj, kattr, buf, count);
    return ret;
}

const struct sysfs_ops kobj_sysfs_ops = {
    .show   = kobj_attr_show,
    .store  = kobj_attr_store,
};

static void dynamic_kobj_release(struct kobject *kobj)
{
    pr_debug("kobject: (%p): %s\n", kobj, __func__);
    kfree(kobj);
}

static struct kobj_type dynamic_kobj_ktype = {
    .release    = dynamic_kobj_release,
    .sysfs_ops  = &kobj_sysfs_ops,
};

kobj_attribute是内核提供给我们的一种更加灵活的处理attribute的方式，但是它还不够。只有当我们使用kobject_create来创建kobject时，使用kobj_attribute才比较方便，但大部分情况下，我们是把kobject内嵌到自己的结构里，此时就无法直接使用内核提供的dynamic_kobj_ktype，因此，我们需要创建自己的kobj_attribute。

本文接下来将围绕一个实例来看看如何创建自己的kobj_attribute。这个sample code是基于上篇文章kobject中的例子修改而来的，看过那个例子的读者应该会比较轻松。

首先，我们需要定义自己的attribute：

struct my_attribute {
        struct attribute attr;

        ssize_t (*show)(struct my_kobj *obj, struct my_attribute *attr,char *buf);
        ssize_t (*store)(struct my_kobj *obj, struct my_attribute *attr,const char *buf, size_t count);
};

在my_attribute里，我们的show/store直接操作my_kobj，这样更加方便。

参考Linux内核，kobj_type里的sysfs_ops这样定义：

static ssize_t my_attr_show(struct kobject *kobj, struct attribute *attr,char *buf)
{
    struct my_attribute *my_attr;
    ssize_t ret = -EIO;

    my_attr = container_of(attr, struct my_attribute, attr);
    if (my_attr->show)
        ret = my_attr->show(container_of(kobj, struct my_kobj, kobj),
                my_attr, buf);
    return ret;
}

static ssize_t my_attr_store(struct kobject *kobj, struct attribute *attr,const char *buf, size_t count)
{
    struct my_attribute *my_attr;
    ssize_t ret = -EIO;

    my_attr = container_of(attr, struct my_attribute, attr);
    if (my_attr->store)
        ret = my_attr->store(container_of(kobj, struct my_kobj, kobj),my_attr, buf, count);
    return ret;
}

下面就可以分别对name和val两个attribute定义自己的show/store。name这个attribute是只读的，只要为它定义show即可。

ssize_t name_show(struct my_kobj *obj, struct my_attribute *attr, char *buffer)
{
    return sprintf(buffer, "%s\n", kobject_name(&obj->kobj));
}
ssize_t val_show(struct my_kobj *obj, struct my_attribute *attr, char *buffer)
{
    return sprintf(buffer, "%d\n", obj->val);
}
ssize_t val_store(struct my_kobj *obj, struct my_attribute *attr,const char *buffer, size_t size)
{
    sscanf(buffer, "%d", &obj->val);

    return size;
}

接下来，利用内核提供的宏__ATTR来初始化my_attribute，并建立attribute数组。

struct my_attribute name_attribute = __ATTR(name, 0444, name_show, NULL);
struct my_attribute val_attribute = __ATTR(val, 0666, val_show, val_store);

struct attribute *my_attrs[] = {
    &name_attribute.attr,
    &val_attribute.attr,
    NULL,
};

其中，宏__ATTR的定义如下：

#define __ATTR(_name,_mode,_show,_store) { \
    .attr = {.name = __stringify(_name), .mode = _mode },   \
    .show   = _show,                    \
    .store  = _store,                   \
}

在module_init里，我们调用sysfs_create_files来把attribute增加到sysfs中。

retval = sysfs_create_files(&obj->kobj,(const struct attribute **)my_attrs);
if (retval) {
    // ...
}

在kobject对应的目录里，还可以创建子目录，Linux内核里是用attribute_group来实现。在本例中，我们可以这么做：

struct attribute_group my_group = {
    .name     = "mygroup",
    .attrs    = my_attrs,
};

然后在module_init里调用sysfs_create_group来添加。

retval = sysfs_create_group(&obj->kobj, &my_group);
if (retval) {
    // ...
}

本例创建的attribute_group中包含的attribute也是my_attrs，所以在子目录mygroup下的文件和mykobj目录下的文件完全一致。

最后我们得到的目录结构是这样的。

mykobj/
    |-- mygroup
    |   |-- name
    |   `-- val
    |-- name
    `-- val

完成这个实例之后，你可以用命令echo 2 > /sys/mykobj/val来修改mykobj下的val文件，可以观察到/sys/mykobj/mygroup/val的内容也会变成2，反之亦然。

详细代码如下：

#include <linux/device.h>       /* 包含内核对象模型的数据结构的定义及辅助函数 */
#include <linux/module.h>       
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>         /* 包含 kcalloc(),kzalloc()函数等 */
 
MODULE_AUTHOR("Tupelo Shen");
MODULE_LICENSE("Dual BSD/GPL");
 
/*
 * 定义container_of的简便方法
 */
#define to_my_kobj(data)        container_of(data, struct my_kobj, kobj)
 
/*
 * 自定义内核对象结构
 */
struct my_kobj {
    int val;
    struct kobject kobj;
};

// 自定义属性
struct my_attribute {
    struct attribute attr;
 
    ssize_t (*show)(struct my_kobj *obj, struct my_attribute *attr, char *buf);
    ssize_t (*store)(struct my_kobj *obj, struct my_attribute *attr,
        const char *buf, size_t count);
};

/* 
 * 分别为name和val两个属性定义自己的show/store函数。
 * name这个属性是只读的，只要为它定义show即可
 */
ssize_t name_show(struct my_kobj *obj, struct my_attribute *attr, char *buffer)
{
    return sprintf(buffer, "%s\n", kobject_name(&obj->kobj));
}
ssize_t val_show(struct my_kobj *obj, struct my_attribute *attr, char *buffer)
{
    return sprintf(buffer, "%d\n", obj->val);
}
ssize_t val_store(struct my_kobj *obj, struct my_attribute *attr,
    const char *buffer, size_t size)
{
    sscanf(buffer, "%d", &obj->val);
 
    return size;
}

/*
 * 定义name和val属性
 */
struct my_attribute name_attribute = __ATTR(name, 0444, name_show, NULL);
struct my_attribute val_attribute = __ATTR(val, 0666, val_show, val_store);

struct attribute *my_attrs[] = {
    &name_attribute.attr,
    &val_attribute.attr,
    NULL,
};

/*
 * 用户空间调用读写函数时的属性显示和存储函数
 */
static ssize_t my_attr_show(struct kobject *kobj, struct attribute *attr, 
    char *buffer)
{
    struct my_attribute *my_attr;
    ssize_t ret = -EIO;

    my_attr = container_of(attr, struct my_attribute, attr);
    if(my_attr->show)
        ret = my_attr->show(container_of(kobj,struct my_kobj, kobj), my_attr, 
                            buffer);
    return ret;
}
 
static ssize_t my_attr_store(struct kobject *kobj, struct attribute *attr, 
    const char *buffer, size_t size)
{
    struct my_attribute *my_attr;
    ssize_t ret = -EIO;

    my_attr = container_of(attr, struct my_attribute, attr);
    if(my_attr->store)
        ret = my_attr->store(container_of(kobj, struct my_kobj, kobj), my_attr, 
            buffer, size);
    return ret;
}
 
struct sysfs_ops my_sysfsops = {
    .show = my_attr_show,
    .store = my_attr_store,
};

struct attribute_group my_group = {
    .name     = "mygroup",
    .attrs    = my_attrs,
}; 

/*
 * 定义两个内核对象，它们的层次结构如下： 
 *
 *   mykobj/
 *   |-- mygroup
 *   | |-- name
 *   | `-- val
 *   |-- name
 *   `-- val
 */ 
struct my_kobj *obj;
struct kobj_type my_type;
 
void obj_release(struct kobject *kobj)
{
    struct my_kobj *my_kobj_free = to_my_kobj(kobj);
    printk(KERN_INFO "my_kobj_release\n");
    kfree(my_kobj_free);
}

/*
 * 初始化内核对象，完成创建并添加
 */ 
static int __init my_kobj_init(void)
{
    int retval = 0;

    printk(KERN_INFO "mykobj_init\n");
 
    obj = (struct my_kobj *)kzalloc(sizeof(struct my_kobj), GFP_KERNEL);
    if (!obj) {
        return -ENOMEM;
    }
    obj->val = 1;    
 
    my_type.release = obj_release;
    // my_type.default_attrs = my_attrs;
    my_type.sysfs_ops = &my_sysfsops;

    // 父节点-在这儿为/sys/kernel/
    kobject_init_and_add(&obj->kobj, &my_type, kernel_kobj, "mykobj");

    // 创建多个属性文件name和val
    retval = sysfs_create_files(&obj->kobj,(const struct attribute **)my_attrs);
    if (retval)
    {
        printk(KERN_INFO "create obj attribute failed!\n");
        kobject_put(&obj->kobj);
        return retval;
    }

    // 对于一个给定的对象，创建属性组
    retval = sysfs_create_group(&obj->kobj, &my_group);
    if (retval) {
        printk(KERN_INFO "create obj attribute group failed!\n");
    }

    return retval;
}
 
static void __exit my_kobj_exit(void)
{
    printk(KERN_INFO "mykobj_exit\n");
     
    kobject_del(&obj->kobj);
    kobject_put(&obj->kobj);
 
    return;
}
 
module_init(my_kobj_init);
module_exit(my_kobj_exit);