sysfs文件系统

2021-10-27 07:26:03

sysfs

Linux的设备模型采用sysfs表示。将设备的树状的结构反映到用户空间。

用户空间可以修改文件属性来修改设备的属性值。

sysfs的设计基于kobject和kset。同时，sysfs是基于VFS的虚拟文件系统，重载了file_operations和dir_operations。

所以，先从kobject和kset入手，然后再依次阅读file_operations和dir_operations。

kobject

kobject的作用是一个"连接件"。

下面是kobject的一个使用场景:

struct cdev {
       struct kobject kobj;
       struct module *owner;
       const struct file_operations *ops;
       struct list_head list;
       dev_t dev;
       unsigned int count;
   };

kobject作为“连接件”被使用者包含，作用相当于stl::list的基类。

kobject结构体

struct kobject {
        const char*name;
        struct list_headentry;
        struct kobject*parent;
        struct kset*kset;
        struct kobj_type*ktype;
        struct sysfs_dirent*sd;
        struct krefkref;
        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;
    };

初始化

1) set all fields to 0, 这一步会被使用kobject的结构体调用，如cdev。
2) kobject_init()初始化列表头部和引用计数为1， 具体是在kobject_init_internal中做的:

kobject_init() -> kobject_init_internal()
          {
              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;
          }

3) 设置name

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

kobject中的引用计数

get

kobject_get() -> kref_get():
    
    void kref_get(struct kref *kref)
    {
        WARN_ON(!atomic_read(&kref->refcount));
        atomic_inc(&kref->refcount);
        smp_mb__after_atomic_inc();
    }

put

void kobject_put(struct kobject *kobj)
     {
         if (kobj) {
             if (!kobj->state_initialized)
                 WARN(1, KERN_WARNING "kobject: '%s' (%p): is not "
                     "initialized, yet kobject_put() is being "
                     "called.\n", kobject_name(kobj), kobj);
             kref_put(&kobj->kref, kobject_release);
         }
     }

在kref_put的第二个参数是kobject的引用计数为0时的析构函数，kref_put里会原子的减1，如果为0，会调用析构函数。

int kref_put(struct kref *kref, void (*release)(struct kref *kref))
     {
         WARN_ON(release == NULL);
         WARN_ON(release == (void (*)(struct kref *))kfree);
         if (atomic_dec_and_test(&kref->refcount)) {
             release(kref);
             return 1;
         }
         return 0;
     }

kobject_release() 根据ktype找到这个kobj对应的真正的类型，所属的析构函数。

struct kobj_type {
        void (*release)(struct kobject *kobj);
        const struct sysfs_ops *sysfs_ops;
        struct attribute **default_attrs;
        const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
        const void *(*namespace)(struct kobject *kobj);
    };

kobj的继承层次，Ksets, subsystem(已经被移除)

kobj之间的层次关系可以通过两种方式表达：parent指针 和 kset.

parent 指针

通过parent指针可以表达树状的关系。
 但，parent更多的用来表示sysfs文件系统的树状关系。

Ksets

struct kset {
         struct list_head list;
         spinlock_t list_lock;
         struct kobject kobj;
         const struct kset_uevent_ops *uevent_ops;
     };

一个ksets是相同类型的kobj的集合。
 ksets只有在sysfs中才能发挥作用。
 一个ksets被加入到系统，在sysfs下面就会有一个目录项与之对应。

int kobject_add(struct kobject *kobj, struct kobject *parent, const char *fmt, ...)
     {
     
         1) 根据fmt生成name。
            retval = kobject_set_name_vargs(kobj, fmt, vargs);
         2) 如果kobj->kset非空，把kobj加入到kobj->kset尾部。
             if (kobj->kset) {
                if (!parent)
                    parent = kobject_get(&kobj->kset->kobj);
                kobj_kset_join(kobj);
                kobj->parent = parent;
             }
         3) 在sysfs文件系统中创建节点，同时根据kobj->ktype->default_attrs[]生成对应的文件。
            error = create_dir(kobj);
     }

subsystem

struct subsystem {
         struct kset kset;
         struct rw_semaphore rwsem;
     };

subsystem是对kset的简单的封装，rw_semaphore保护kset的链表操作。
 
 看一下系统中的subsys有哪些：
 max@max-gentoo ~/Code/Kernel/linux-3.19 $ ls /sys/
 block  bus  class  dev  devices  firmware  fs  kernel  module  power
 在2.6.28以后subsystem经过讨论，被认为是冗余的，kset就可以完全表示sysfs目录，kobject可以表示属性文件。
 所以不做深究了。

sysfs_dirent

kset，kobject是如何和VFS对接起来的呢？cgroup对接VFS的方式一样，通过dentry->d_fsdata，d_fsdata指向具体文件系统的实体。
插入一张图说明sysfs_dirent在sysfs目录树中的作用（我不是原创）‘

sysfs文件系统

struct sysfs_dirent {
         atomic_ts_count;
         atomic_ts_active;
         struct sysfs_dirent*s_parent;
         
         const char*s_name;
         
         union {
             struct sysfs_elem_dirs_dir;
             struct sysfs_elem_symlinks_symlink;
             struct sysfs_elem_attrs_attr;
             struct sysfs_elem_bin_attrs_bin_attr;
         };
         
         unsigned ints_flags;
         ino_ts_ino;
         umode_ts_mode;
         struct sysfs_inode_attrs *s_iattr;
     };

sysfs文件系统中每个节点都是一个sysfs_dirent表示。

sysfs的初始化

int __init sysfs_init(void)
   {
        int err = -ENOMEM;
        sysfs_dir_cachep = kmem_cache_create("sysfs_dir_cache",
                                              sizeof(struct sysfs_dirent),
                                              0, 0, NULL);
        err = sysfs_inode_init();
        err = register_filesystem(&sysfs_fs_type);
        
        if (!err) {
                sysfs_mount = kern_mount(&sysfs_fs_type);
                if (IS_ERR(sysfs_mount)) {
                        printk(KERN_ERR "sysfs: could not mount!\n");
                        err = PTR_ERR(sysfs_mount);
                        sysfs_mount = NULL;
                        unregister_filesystem(&sysfs_fs_type);
                        goto out_err;
                }
        }
    }

1) kmem_cache_create
   创建一个分配sysfs_dirent的slab。
2) sysfs_inode_init();
3) register_filesystem(&sysfs_fs_type);
   向系统注册sysfs的文件系统类型。

static struct file_system_type sysfs_fs_type = {
           .name                = "sysfs",
           .get_sb                = sysfs_get_sb,
           .kill_sb        = kill_anon_super,
       };

4) sysfs_mount = kern_mount(&sysfs_fs_type);
   挂载sysfs_fs_type文件系统。

kern_mount 最终会调用sysfs_fs_type中的get_sb()完成注册过程。

static int sysfs_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data, struct vfsmount *mnt)
   {
       return get_sb_single(fs_type, flags, data, sysfs_fill_super, mnt);
   }

get_sb_single()会调用sysfs_fill_super():

static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
   {
       struct inode *inode;
       struct dentry *root;
       sb->s_blocksize = PAGE_CACHE_SIZE;
       sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
       sb->s_magic = SYSFS_MAGIC;
       sb->s_op = &sysfs_ops;
       sb->s_time_gran = 1;
       sysfs_sb = sb;
       mutex_lock(&sysfs_mutex);
       inode = sysfs_get_inode(&sysfs_root);
       mutex_unlock(&sysfs_mutex);
       if (!inode) {
           pr_debug("sysfs: could not get root inode\n");
           return -ENOMEM;
       }
       root = d_alloc_root(inode);
       if (!root) {
           pr_debug("%s: could not get root dentry!\n",__func__);
           iput(inode);
           return -ENOMEM;
       }
       root->d_fsdata = &sysfs_root;
       sb->s_root = root;
       return 0;
   }

1) 初始化sb，并把sb赋值给全局的sysfs_sb。

2) sysfs_get_inode(&sysfs_root);

获取一个inode节点，并且初始化inode中的i_op回调函数。

3) root = d_alloc_root(inode);

在以"/"为父节点，分配dentry。

sysfs的查找

文件系统的查找最终是调用dentry->i_op->lookup().这个i_op是在sysfs_init_inode中初始化的:

inode->i_op = &sysfs_dir_inode_operations;

所以，在sysfs目录树中的查找是通过sysfs_dir_inode_operations中定义的sysfs_lookup函数来完成的。

sysfs_lookup中的查找最终落实到sysfs_find_dirent上:

struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd, const unsigned char *name)
   {
       struct rb_node *p = parent_sd->s_dir.name_tree.rb_node;
       
       while (p) {
           int c;
           #define noderb_entry(p, struct sysfs_dirent, name_node)
           c = strcmp(name, node->s_name);
           if (c < 0) {
               p = node->name_node.rb_left;
           } else if (c > 0) {
               p = node->name_node.rb_right;
           } else {
               return node;
           }
           #undef node
       }
       
       return NULL;
   }

可以看到在sysfs目录树中的路径比较是通过比较字符串 sysfs_dirent->s_name来完成的。

所以，sysfs目录树中的目录名dentry->d_fsdata->s_name。

sysfs创建目录

在linux设备模型中，每注册一个kobject，就会为之创建一个目录。

int sysfs_create_dir(struct kobject * kobj)
   {
       struct sysfs_dirent *parent_sd, *sd;
       int error = 0;
       
       BUG_ON(!kobj);
       
       if (kobj->parent)
           parent_sd = kobj->parent->sd;
       else
           parent_sd = &sysfs_root;
       
       error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);
       if (!error)
           kobj->sd = sd;
       return error;
   }

可以看到如果kobj->parent没有指定，则用全局的sysfs_root。然后调用create_dir完成sysfs目录树下的目录创建。

static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd, const char *name, struct sysfs_dirent **p_sd)
   {
         umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
         struct sysfs_addrm_cxt acxt;
         struct sysfs_dirent *sd;
         int rc;
         sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
         if (!sd)
             return -ENOMEM;
         sd->s_dir.kobj = kobj;
         sysfs_addrm_start(&acxt, parent_sd);
         rc = sysfs_add_one(&acxt, sd);
         sysfs_addrm_finish(&acxt);
         if (rc == 0)
             *p_sd = sd;
         else
             sysfs_put(sd);
         return rc;
   }

1) 首先申请一个sysfs_dirent结构体。

2) 然后调用sysfs_add_one 把sd加入到父节点下面。sysfs_link_sibling(sd)。

sysfs创建属性文件

sysfs目录树下的每一个文件都是一个kobj的属性。

int sysfs_add_file_mode(struct sysfs_dirent *dir_sd, const struct attribute *attr, int type, mode_t amode)
   {
       umode_t mode = (amode & S_IALLUGO) | S_IFREG;
       struct sysfs_addrm_cxt acxt;
       struct sysfs_dirent *sd;
       int rc;
       
       sd = sysfs_new_dirent(attr->name, mode, type);
       if (!sd)
           return -ENOMEM;
       sd->s_attr.attr = (void *)attr;
       
       sysfs_addrm_start(&acxt, dir_sd);
       rc = sysfs_add_one(&acxt, sd);
       sysfs_addrm_finish(&acxt);
       
       if (rc)
           sysfs_put(sd);
       
       return rc;
   }

过程和创建目录大致相同，不同点是创建目录时的父节点是上一层节点，创建属性文件时的节点就是kobj对应的sysfs_dirent。

sysfs打开和读写操作

sysfs文件的读写函数是在sysfs_init_inode时设置的。

const struct file_operations sysfs_file_operations = {
       .read= sysfs_read_file,
       .write= sysfs_write_file,
       .llseek= generic_file_llseek,
       .open= sysfs_open_file,
       .release= sysfs_release,
       .poll= sysfs_poll,
   };

sysfs文件打开

static int sysfs_open_file(struct inode *inode, struct file *file)
   {
       struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
       struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
       struct sysfs_buffer *buffer;
       const struct sysfs_ops *ops;
       if (!sysfs_get_active_two(attr_sd))
           return -ENODEV;
       ops = kobj->ktype->sysfs_ops;
       
       buffer = kzalloc(sizeof(struct sysfs_buffer), GFP_KERNEL);
       mutex_init(&buffer->mutex);
       buffer->needs_read_fill = 1;
       buffer->ops = ops;
       
       file->private_data = buffer;
       error = sysfs_get_open_dirent(attr_sd, buffer);
       sysfs_put_active_two(attr_sd);
       return 0;
   }

1) 根据dentry->d_fsdata找到sysfs_dirent。

2) 根据sysfs_dirent找到父节点的kobj，这个结构里存储了操作这个文件的函数指针。

3) 申请sysfs_buffer，并把操作文件的函数指针ops赋值给buffer->ops。

4) 最后把buffer赋值给file->private_data。

文件的写入

static ssize_t
    sysfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
    {
        struct sysfs_buffer * buffer = file->private_data;
        ssize_t len;
        
        mutex_lock(&buffer->mutex);
        len = fill_write_buffer(buffer, buf, count);
        if (len > 0)
            len = flush_write_buffer(file->f_path.dentry, buffer, len);
        if (len > 0)
            *ppos += len;
        mutex_unlock(&buffer->mutex);
        return len;
    }

1) file->private_data
   首先从file中找到在open过程中申请的sysfs_buffer。
   这个buffer里有操作文件的ops。
2) fill_write_buffer
   申请一个page，并且把用户空间的buf拷贝过来。

fill_write_buffer(struct sysfs_buffer * buffer, const char __user * buf, size_t count)
       {
           int error;
           if (!buffer->page)
               buffer->page = (char *)get_zeroed_page(GFP_KERNEL);
           error = copy_from_user(buffer->page,buf,count);
           buffer->needs_read_fill = 1;
           buffer->page[count] = 0;
           return error ? -EFAULT : count;
       }

3) flush_write_buffer
   与设备模型交互，进行实质性的写入操作。

flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
       {
           struct sysfs_dirent *attr_sd = dentry->d_fsdata;
           struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
           const struct sysfs_ops * ops = buffer->ops;
           int rc;
           if (!sysfs_get_active_two(attr_sd))
               return -ENODEV;
           rc = ops->store(kobj, attr_sd->s_attr.attr, buffer->page, count);
           sysfs_put_active_two(attr_sd);
           return rc;
       }

最终调用kobject->ktype->ops->store()，这样就和VFS完全融合在一起了。

码农公寓