Linux设备模型 (3)_linux attr show buffer多大-CSDN博客

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

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

 
    1struct kobj_attribute { 
 
    2    struct attribute attr; 
 
    3    ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr, 
 
    4            char *buf); 
 
    5    ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr, 
 
    6             const char *buf, size_t count); 
 
    7};

每一个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来实现上述的操作。

 
    01/* default kobject attribute operations */
 
    02static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr, 
 
    03                  char *buf) 
 
    04{ 
 
    05    struct kobj_attribute *kattr; 
 
    06    ssize_t ret = -EIO; 
 
    07  
 
    08    kattr = container_of(attr, struct kobj_attribute, attr); 
 
    09    if (kattr->show) 
 
    10        ret = kattr->show(kobj, kattr, buf); 
 
    11    return ret; 
 
    12} 
 
    13  
 
    14static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr, 
 
    15                   const char *buf, size_t count) 
 
    16{ 
 
    17    struct kobj_attribute *kattr; 
 
    18    ssize_t ret = -EIO; 
 
    19  
 
    20    kattr = container_of(attr, struct kobj_attribute, attr); 
 
    21    if (kattr->store) 
 
    22        ret = kattr->store(kobj, kattr, buf, count); 
 
    23    return ret; 
 
    24} 
 
    25  
 
    26const struct sysfs_ops kobj_sysfs_ops = { 
 
    27    .show   = kobj_attr_show, 
 
    28    .store  = kobj_attr_store, 
 
    29}; 
 
    30  
 
    31static void dynamic_kobj_release(struct kobject *kobj) 
 
    32{ 
 
    33    pr_debug("kobject: (%p): %s/n", kobj, __func__); 
 
    34    kfree(kobj); 
 
    35} 
 
    36  
 
    37static struct kobj_type dynamic_kobj_ktype = { 
 
    38    .release    = dynamic_kobj_release, 
 
    39    .sysfs_ops  = &kobj_sysfs_ops, 
 
    40};

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

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

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

 
    1struct my_attribute { 
 
    2        struct attribute attr; 
 
    3        ssize_t (*show)(struct my_kobj *obj, struct my_attribute *attr,  
 
    4                        char *buf); 
 
    5        ssize_t (*store)(struct my_kobj *obj, struct my_attribute *attr,  
 
    6                        const char *buf, size_t count); 
 
    7};

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

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

 
    01static ssize_t my_attr_show(struct kobject *kobj, struct attribute *attr, 
 
    02                  char *buf) 
 
    03{ 
 
    04    struct my_attribute *my_attr; 
 
    05    ssize_t ret = -EIO; 
 
    06  
 
    07    my_attr = container_of(attr, struct my_attribute, attr); 
 
    08    if (my_attr->show) 
 
    09        ret = my_attr->show(container_of(kobj, struct my_kobj, kobj),  
 
    10                my_attr, buf); 
 
    11    return ret; 
 
    12} 
 
    13  
 
    14static ssize_t my_attr_store(struct kobject *kobj, struct attribute *attr, 
 
    15                   const char *buf, size_t count) 
 
    16{ 
 
    17    struct my_attribute *my_attr; 
 
    18    ssize_t ret = -EIO; 
 
    19  
 
    20    my_attr = container_of(attr, struct my_attribute, attr); 
 
    21    if (my_attr->store) 
 
    22        ret = my_attr->store(container_of(kobj, struct my_kobj, kobj),  
 
    23                my_attr, buf, count); 
 
    24    return ret; 
 
    25}

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

 
    01ssize_t name_show(struct my_kobj *obj, struct my_attribute *attr, char *buffer) 
 
    02{ 
 
    03    return sprintf(buffer, "%s/n", kobject_name(&obj->kobj)); 
 
    04} 
 
    05  
 
    06ssize_t val_show(struct my_kobj *obj, struct my_attribute *attr, char *buffer) 
 
    07{ 
 
    08    return sprintf(buffer, "%d/n", obj->val); 
 
    09} 
 
    10  
 
    11ssize_t val_store(struct my_kobj *obj, struct my_attribute *attr,  
 
    12        const char *buffer, size_t size) 
 
    13{ 
 
    14    sscanf(buffer, "%d", &obj->val); 
 
    15  
 
    16    return size; 
 
    17}

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

 
    1struct my_attribute name_attribute = __ATTR(name, 0444, name_show, NULL); 
 
    2struct my_attribute val_attribute = __ATTR(val, 0666, val_show, val_store); 
 
    3  
 
    4struct attribute *my_attrs[] = { 
 
    5    &name_attribute.attr,  
 
    6    &val_attribute.attr, 
 
    7    NULL, 
 
    8};

其中，宏__ATTR的定义如下：

 
    1#define __ATTR(_name,_mode,_show,_store) { / 
 
    2    .attr = {.name = __stringify(_name), .mode = _mode },   / 
 
    3    .show   = _show,                    / 
 
    4    .store  = _store,                   / 
 
    5}

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

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

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

 
    1struct attribute_group my_group = { 
 
    2    .name     = "mygroup", 
 
    3    .attrs    = my_attrs, 
 
    4};

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

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

本例创建的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，反之亦然。