102 kobj_type

一、kobj_type：用户空间的法宝

为 kobject 对象 构建多个 属性文件（这些属性文件都是共用 kobj_attr_show 和 kobj_attr_store 读写接口）；
这两个函数接口内部最终会根据函数参数 struct attribute 调用到我们自己实现的函数。

为 每个属性文件 设置 具体操作接口（在上面两个统一的操作接口里面，会进一步去调用每个 attribute属性 文件具体的操作接口）;
具体操作接口需要我们自己去实现。

虚拟文件系统vfs的 inode对象 与sysfs的 kernfs_node对象 的绑定过程（虚拟文件系统不能识别 kernfs_node）。

二、重点

关注属性文件具体操作接口的赋值过程。

关注open()、read()、write函数操作 sysfs中的文件 的底层机制。

struct kobject 对应的是 sysfs 中的目录项；
attribute 属性文件对应的是 sysfs 目录项中的文件；

三、第一阶段：属性文件操作接口赋值

1、sysfs_create_group()函数

fs/sysfs/group.c

创建 kobject 对应的 属性文件 ，并且将 属性文件 和 各自的具体的操作接口 绑定起来。

int sysfs_create_group(struct kobject *kobj,
		       const struct attribute_group *grp)
{
	return internal_create_group(kobj, 0, grp);
}

• attribute_group结构体：

  include/linux/sysfs.h

struct attribute_group {
	/* 设置 attribute_group 的名称 */
	const char		*name;
	umode_t			(*is_visible)(struct kobject *,
					      struct attribute *, int);
	umode_t			(*is_bin_visible)(struct kobject *,
						  struct bin_attribute *, int);
	/* 重点关注 */
	struct attribute	**attrs;
	struct bin_attribute	**bin_attrs;
};

• struct attribute结构体：

  include/linux/sysfs.h

struct attribute {
	/* 设置属性文件的文件名 */
	const char		*name;
	/* 设置属性文件的权限 */
	umode_t			mode;
	...
};

• kobj_attribute结构体

若仅依靠 struct attribute 来创建属性文件，这个属性文件是没有自己的独立操作接口的，因此需要对 struct attricbute 进行上一层的封装，称为 struct kobj_attribute。

struct kobj_attribute {
	/* 继承一个 struct 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);
	...
};

2、internal_create_group()函数

fs/sysfs/group.c

return internal_create_group(kobj, 0, grp);

static int internal_create_group(struct kobject *kobj, int update,
				 const struct attribute_group *grp)
{
	struct kernfs_node *kn;
	kuid_t uid;
	kgid_t gid;
	int error;
	
	...
	if (grp->name)
	...
	else
		/* 获取 kobject 的目录项 */
		kn = kobj->sd;
    ...
    /* uid 和 pid 用来设置属性文件的 uid 和 pid */
    error = create_files(kn, kobj, uid, gid, grp, update);
    ...
}	

3、create_files()函数

fs/sysfs/group.c

static int create_files(struct kernfs_node *parent, struct kobject *kobj,
			kuid_t uid, kgid_t gid,
			const struct attribute_group *grp, int update)
{
	struct attribute *const *attr;
	struct bin_attribute *const *bin_attr;
	int error = 0, i;
	/* 判断 */
	if (grp->attrs) {
		/* 遍历 grp 里面的 struct attribute */
		for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++) {
			/* 属性文件的权限 */
			umode_t mode = (*attr)->mode;
			...
			/* parent 为 kernfs_node 目录节点 */
			error = sysfs_add_file_mode_ns(parent, *attr, false,
						       mode, uid, gid, NULL);
			...
			}
	...
}

4、sysfs_add_file_mode_ns()函数

fs/sysfs/file.c

int sysfs_add_file_mode_ns(struct kernfs_node *parent,
			   const struct attribute *attr, bool is_bin,
			   umode_t mode, kuid_t uid, kgid_t gid, const void *ns)
{
	struct lock_class_key *key = NULL;
	const struct kernfs_ops *ops;
	struct kernfs_node *kn;
	loff_t size;
	/* 传入的是 false，成立 */
	if (!is_bin) {
		/* priv 指向 kobject，即获取目录项节点对应的 kobject。
		 * 此处获取 kobject 的目的是为了获取 其成员 ktype 下的
		 * sysfs_ops 操作集。
		 */
		struct kobject *kobj = parent->priv;
		/* 其实就是 kobj_sysfs_ops，之前初始化好的 */
		const struct sysfs_ops *sysfs_ops = kobj->ktype->sysfs_ops;
		...
		if (sysfs_ops->show && sysfs_ops->store) {
			if (mode & SYSFS_PREALLOC)
				ops = &sysfs_prealloc_kfops_rw;
			else
				/* 走这个分支 */
				ops = &sysfs_file_kfops_rw;
		else if
			...
		}
	...
	/* 此函数会真正创建属性文件 
	 * parent：kobject对应的目录节点
	 * attr->name：用来设置属性文件的名字
	 * mode&0777 设置文件权限
	 */
	kn = __kernfs_create_file(parent, attr->name, mode & 0777, uid, gid,
				  size, ops, (void *)attr, ns, key);
    ...
}

• kernfs_ops节点的操作函数

static const struct kernfs_ops sysfs_file_kfops_rw = {
	.seq_show	= sysfs_kf_seq_show,
	.write		= sysfs_kf_write,
};

5、__kernfs_create_file()函数

struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
					 const char *name,
					 umode_t mode, kuid_t uid, kgid_t gid,
					 loff_t size,
					 const struct kernfs_ops *ops,
					 void *priv, const void *ns,
					 struct lock_class_key *key)
{
	struct kernfs_node *kn;
	unsigned flags;
	int rc;

	flags = KERNFS_FILE;
	/* 新建一个  kernfs_node 属性文件节点 
	 * 设置上一层的节点是 parent，就是上一层的 kobject->sd
	 */
	kn = kernfs_new_node(parent, name, (mode & S_IALLUGO) | S_IFREG,
			     uid, gid, flags);
	if (!kn)
		return ERR_PTR(-ENOMEM);
	/* 文件节点 操作接口赋值 */
	kn->attr.ops = ops;
	kn->attr.size = size;
	kn->ns = ns;
	/* 文件属性赋值给它，struct attribute 
	 * 一个 
	 */
	kn->priv = priv;
	
	if (ops->seq_show)
		kn->flags |= KERNFS_HAS_SEQ_SHOW;
	...
}

四、第二阶段：open()\read()\write()的底层机制

上面只是创建了 kernfs_node 节点并进行了初始化，并没有关联 inode。
调用了 open 之后才开始进行关联。
主要是依靠 kernfs_init_inode。

1、kernfs_init_inode()函数

static void kernfs_init_inode(struct kernfs_node *kn, struct inode *inode)
{
	kernfs_get(kn);
	/* 让 inode->i_private 指向 kernfs_node */
	inode->i_private = kn;
	inode->i_mapping->a_ops = &kernfs_aops;
	inode->i_op = &kernfs_iops;
	inode->i_generation = kn->id.generation;

	set_default_inode_attr(inode, kn->mode);
	kernfs_refresh_inode(kn, inode);

	/* 判断sysfs的kernels_node类型 */
	switch (kernfs_type(kn)) {
	case KERNFS_DIR:
		inode->i_op = &kernfs_dir_iops;
		/* 这个操作集在下面定义了 */
		inode->i_fop = &kernfs_dir_fops;
		if (kn->flags & KERNFS_EMPTY_DIR)
			make_empty_dir_inode(inode);
		break;
	/* 走这条路 */
	case KERNFS_FILE:
		inode->i_size = kn->attr.size;
		/* 文件的操作接口，详见下 */
		inode->i_fop = &kernfs_file_fops;
		break;
	case KERNFS_LINK:
		inode->i_op = &kernfs_symlink_iops;
		break;
	default:
		BUG();
	}

	unlock_new_inode(inode);
}

const struct file_operations kernfs_file_fops = {
	.read		= kernfs_fop_read,
	.write		= kernfs_fop_write,
	.llseek		= generic_file_llseek,
	.mmap		= kernfs_fop_mmap,
	/* open 最终会调用此成员 */
	.open		= kernfs_fop_open,
	.release	= kernfs_fop_release,
	.poll		= kernfs_fop_poll,
	.fsync		= noop_fsync,
};

2、kernfs_fop_open()函数

/* 第二个参数 file 保存在进程控制块中 */
static int kernfs_fop_open(struct inode *inode, struct file *file)
{
	/* 前面已经设置 inode->i_private 指向 kernfs_node 节点了 */
	struct kernfs_node *kn = inode->i_private;
	struct kernfs_open_file *of;
	...
	of = kzalloc(sizeof(struct kernfs_open_file), GFP_KERNEL);
	...
	/* kernfs_open_file 保存 kernfs_node */
	of->kn = kn;
	/* 进程的 struct file 赋值给 of->file */
	of->file = file;
	...
	/* 这个 ops 就是前面初始化的 sysfs_file_kfops_rw */
	if (ops->seq_show)
		/* seq_open 详见下 
		 * kernfs_seq_ops 详见下
		 */
		error = seq_open(file, &kernfs_seq_ops);
	...
	/*struct file的私有指针赋值给of->seq_file */
	of->seq_file = file->private_data;
	/* of赋值给of->seq_file->private */
	of->seq_file->private = of;
	...
 }

static const struct seq_operations kernfs_seq_ops = {
	.start = kernfs_seq_start,
	.next = kernfs_seq_next,
	.stop = kernfs_seq_stop,
	.show = kernfs_seq_show,
};

3、seq_open

int seq_open(struct file *file, const struct seq_operations *op)
{
	struct seq_file *p;

	WARN_ON(file->private_data);

	p = kmem_cache_zalloc(seq_file_cache, GFP_KERNEL);
	if (!p)
		return -ENOMEM;
	/* file 里保存 seq_file */
	file->private_data = p;
	...
	p->op = op;
	...
}

4、kernfs_fop_read()函数

static ssize_t kernfs_fop_read(struct file *file, char __user *user_buf,
			       size_t count, loff_t *ppos)
{
	struct kernfs_open_file *of = kernfs_of(file);
	/* 判断 kernfs_node 属性文件节点的 flag 
	 * 之前有设置这个 flag
	 */
	if (of->kn->flags & KERNFS_HAS_SEQ_SHOW)
		return seq_read(file, user_buf, count, ppos);
	else
		return kernfs_file_direct_read(of, user_buf, count, ppos);
}

5、kernfs_of()函数

static struct kernfs_open_file *kernfs_of(struct file *file)
{
	return ((struct seq_file *)file->private_data)->private;
}

6、seq_read()函数

ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
	struct seq_file *m = file->private_data;
	...
	err = m->op->show(m, p);
	...
	err = copy_to_user(buf, m->buf, n);
	...
}

7、kernfs_seq_show()函数

static int kernfs_seq_show(struct seq_file *sf, void *v)
{
	struct kernfs_open_file *of = sf->private;
	...
	return of->kn->attr.ops->seq_show(sf, v);
}

8、sysfs_kf_seq_show()函数

static int sysfs_kf_seq_show(struct seq_file *sf, void *v)
{
	struct kernfs_open_file *of = sf->private;
	struct kobject *kobj = of->kn->parent->priv;
	const struct sysfs_ops *ops = sysfs_file_ops(of->kn);
	ssize_t count;
	char *buf;
	/* 获取可用 buf 空间 */
	count = seq_get_buf(sf, &buf);
	if (count < PAGE_SIZE) {
		seq_commit(sf, -1);
		return 0;
	}
	memset(buf, 0, PAGE_SIZE);

	/*
	 * Invoke show().  Control may reach here via seq file lseek even
	 * if @ops->show() isn't implemented.
	 * 调用 kobject -> kobj_type -> sys_fops -> show。
	 * 前面已经将这个 show 成员初始化成了 kobj_attr_show。
	 */
	if (ops->show) {
		count = ops->show(kobj, of->kn->priv, buf);
		if (count < 0)
			return count;
	}

	/*
	 * The code works fine with PAGE_SIZE return but it's likely to
	 * indicate truncated result or overflow in normal use cases.
	 */
	if (count >= (ssize_t)PAGE_SIZE) {
		printk("fill_read_buffer: %pS returned bad count\n",
				ops->show);
		/* Try to struggle along */
		count = PAGE_SIZE - 1;
	}
	seq_commit(sf, count);
	return 0;
}

9、sysfs_file_ops()函数

static const struct sysfs_ops *sysfs_file_ops(struct kernfs_node *kn)
{
	/* parent 指向上一层 kobject，priv指向一开始构造的 kobject */
	struct kobject *kobj = kn->parent->priv;

	if (kn->flags & KERNFS_LOCKDEP)
		lockdep_assert_held(kn);
	return kobj->ktype ? kobj->ktype->sysfs_ops : NULL;
}

10、seq_get_buf()函数

static inline size_t seq_get_buf(struct seq_file *m, char **bufp)
{
	BUG_ON(m->count > m->size);
	if (m->count < m->size)
		/* 注意struct seq_file 的 buf成员用于
		 * 存放属性文件的读写内容。
		 * buf此处加上一个偏移值，此值是属性文件已经读写完的字节数量。
		 */
		*bufp = m->buf + m->count;
	else
		*bufp = NULL;

	return m->size - m->count;
}

11、kobj_attr_show()函数

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)
		/* 这个 show 函数需要我们在用户空间初始化 */
		ret = kattr->show(kobj, kattr, buf);
	return ret;
}