RK3568驱动指南｜第八篇 设备树插件-第84章设备树插件参考资料介绍

瑞芯微RK3568芯片是一款定位中高端的通用型SOC，采用22nm制程工艺，搭载一颗四核Cortex-A55处理器和Mali G52 2EE 图形处理器。RK3568 支持4K 解码和 1080P 编码，支持SATA/PCIE/USB3.0 外围接口。RK3568内置独立NPU，可用于轻量级人工智能应用。RK3568 支持安卓 11 和 linux 系统，主要面向物联网网关、NVR 存储、工控平板、工业检测、工控盒、卡拉 OK、云终端、车载中控等行业。

?
【公众号】迅为电子

【粉丝群】824412014（加群获取驱动文档+例程）

【视频观看】嵌入式学习之Linux驱动（第八期_设备树插件_全新升级）_基于RK3568

【购买链接】迅为RK3568开发板瑞芯微Linux安卓鸿蒙ARM核心板人工智能AI主板

第84章设备树插件参考资料介绍

通过上述章节的学习，设备树插件的知识已经学习完了，本章节将介绍设备树插件其他的一些参考资料。

在linux源码中linux_sdk/kernel/Documentation/filesystems/configfs目录下的configfs.txt。

内容解释如下所示：

[什么是configfs?]
configfs是一种基于RAM的文件系统，提供了与sysfs功能相反的功能。sysfs是内核对象的基于文件系统的视图，而configfs是内核对象（或config_items）的基于文件系统的管理器。
使用sysfs时，在内核中创建一个对象（例如，当发现设备时），并将其注册到sysfs中。然后，它的属性会出现在sysfs中，允许用户空间通过readdir(3)/read(2)读取属性。它可能允许通过write(2)修改某些属性。重要的是，对象在内核中创建和销毁，内核控制sysfs表示的生命周期，而sysfs只是对所有这些的一种窗口。
通过显式的用户空间操作（例如mkdir(2)），可以创建一个configfs config_item。通过rmdir(2)销毁它。属性在mkdir(2)时出现，并且可以通过read(2)和write(2)读取或修改。与sysfs类似，readdir(3)查询项目和/或属性的列表。可以使用symlink(2)将项目组合在一起。与sysfs不同，表示的生命周期完全由用户空间驱动。支持项目的内核模块必须响应此操作。
sysfs和configfs可以并且应该在同一系统上同时存在。它们不是彼此的替代品。

【使用configfs】

configfs可以作为模块编译或集成到内核中。您可以通过以下方式访问它：
	mount -t configfs none /config
除非也加载了客户端模块，否则configfs树将为空。这些模块将其项目类型注册为configfs的子系统。一旦加载了客户端子系统，它将显示为/config下的一个或多个子目录。与sysfs一样，configfs树始终存在，无论是否挂载在/config上。
可以通过mkdir(2)创建项目。项目的属性也将同时出现。readdir(3)可以确定属性是什么，read(2)可以查询其默认值，write(2)可以存储新值。不要在一个属性文件中混合多个属性。
configfs有两种类型的属性：

普通属性（Normal attributes）类似于sysfs属性，是小型的ASCII文本文件，最大大小为一页（PAGE_SIZE，在i386上为4096）。最好每个文件只使用一个值，并且与sysfs相同的注意事项也适用。configfs期望write(2)一次存储整个缓冲区。当写入普通configfs属性时，用户空间进程应首先读取整个文件，修改要更改的部分，然后将整个缓冲区写回。
二进制属性（Binary attributes）与sysfs二进制属性类似，但语义上有一些细微的变化。不适用PAGE_SIZE限制，但整个二进制项必须适应单个内核vmalloc的缓冲区。来自用户空间的write(2)调用是缓冲的，并且在最终关闭时将调用属性的write_bin_attribute方法，因此用户空间必须检查close(2)的返回代码以验证操作是否成功完成。为避免恶意用户OOM（Out of Memory）内核，有每个二进制属性的最大缓冲区值。
当需要销毁项目时，使用rmdir(2)将其删除。如果任何其他项目通过symlink(2)链接到它，则无法销毁该项目。可以使用unlink(2)删除链接。

【配置FakeNBD：一个示例】
假设有一个网络块设备（Network Block Device，NBD）驱动程序，允许您访问远程块设备。将其称为FakeNBD。FakeNBD使用configfs进行配置。显然，将有一个方便的程序供系统管理员使用来配置FakeNBD，但某种方式下，该程序必须告知驱动程序。这就是configfs的用武之地。
加载FakeNBD驱动程序时，它会向configfs注册自己。readdir(3)可以看到这一点：
	# ls /config
	fakenbd
可以使用mkdir(2)创建fakenbd连接。名称是任意的，但工具可能会对名称进行一些处理。也许它是一个UUID或磁盘名称：
	# mkdir /config/fakenbd/disk1
	# ls /config/fakenbd/disk1
	target device rw
target属性包含FakeNBD将连接到的服务器的IP地址。device属性是服务器上的设备。可预测的是，rw属性确定连接是只读还是读写。
	# echo 10.0.0.1 > /config/fakenbd/disk1/target
	# echo /dev/sda1 > /config/fakenbd/disk1/device
	# echo 1 > /config/fakenbd/disk1/rw

target属性包含FakeNBD将连接到的服务器的IP地址。device属性是服务器上的设备。可预测的是，rw属性确定连接是只读还是读写。
【使用configfs进行编码】
configfs中的每个对象都是一个config_item。config_item反映了子系统中的一个对象。它具有与该对象上的值相匹配的属性。configfs处理该对象及其属性的文件系统表示，使得子系统只需关注基本的show/store交互。
项目是在config_group内创建和销毁的。组是共享相同属性和操作的项目集合。项目通过mkdir(2)创建，并通过rmdir(2)移除，但configfs会处理这些操作。组具有一组操作来执行这些任务。
子系统是客户端模块的顶层。在初始化过程中，客户端模块向configfs注册子系统，该子系统将在configfs文件系统的顶部显示为一个目录。子系统也是一个config_group，并且可以执行config_group的所有功能。
[struct config_item]

	struct config_item {
		char                    *ci_name;
		char                    ci_namebuf[UOBJ_NAME_LEN];
		struct kref             ci_kref;
		struct list_head        ci_entry;
		struct config_item      *ci_parent;
		struct config_group     *ci_group;
		struct config_item_type *ci_type;
		struct dentry           *ci_dentry;
	};

	void config_item_init(struct config_item *);
	void config_item_init_type_name(struct config_item *,
					const char *name,
					struct config_item_type *type);
	struct config_item *config_item_get(struct config_item *);
	void config_item_put(struct config_item *);

通常，struct config_item被嵌入在一个容器结构中，这个结构实际上代表了子系统正在做的事情。该结构中的config_item部分是对象与configfs进行交互的方式。
无论是在源文件中静态定义还是由父config_group创建，config_item都必须调用其中一个_init()函数。这将初始化引用计数并设置适当的字段。
所有使用config_item的用户都应该通过config_item_get()对其进行引用，并在完成后通过config_item_put()释放引用。
单独一个config_item不能做更多的事情，只能出现在configfs中。通常，子系统希望该项显示和/或存储属性，以及其他一些操作。为此，它需要一个类型。

[struct config_item_type]

	struct configfs_item_operations {
		void (*release)(struct config_item *);
		int (*allow_link)(struct config_item *src,
				  struct config_item *target);
		void (*drop_link)(struct config_item *src,
				 struct config_item *target);
	};

	struct config_item_type {
		struct module                           *ct_owner;
		struct configfs_item_operations         *ct_item_ops;
		struct configfs_group_operations        *ct_group_ops;
		struct configfs_attribute               **ct_attrs;
		struct configfs_bin_attribute		**ct_bin_attrs;
	};
config_item_type的最基本功能是定义可以在config_item上执行的操作。所有动态分配的项目都需要提供ct_item_ops->release()方法。当config_item的引用计数达到零时，将调用此方法。

[struct configfs_attribute]

	struct configfs_attribute {
		char                    *ca_name;
		struct module           *ca_owner;
		umode_t                  ca_mode;
		ssize_t (*show)(struct config_item *, char *);
		ssize_t (*store)(struct config_item *, const char *, size_t);
	};
当config_item希望将属性显示为项目的configfs目录中的文件时，它必须定义一个描述该属性的configfs_attribute。然后将属性添加到以NULL结尾的config_item_type->ct_attrs数组中。当项目出现在configfs中时，属性文件将显示为configfs_attribute->ca_name文件名。configfs_attribute->ca_mode指定文件权限。
如果属性是可读的并提供了一个->show方法，每当用户空间请求对属性进行read(2)时，该方法将被调用。如果属性是可写的并提供了一个->store方法，每当用户空间请求对属性进行write(2)时，该方法将被调用。
[struct configfs_bin_attribute]

	struct configfs_attribute {
		struct configfs_attribute	cb_attr;
		void				*cb_private;
		size_t				cb_max_size;
	};
当需要使用二进制数据块作为文件内容显示在项目的configfs目录中时，可以使用二进制属性（binary attribute）。为此，将二进制属性添加到以NULL结尾的config_item_type->ct_bin_attrs数组中，当项目出现在configfs中时，属性文件将显示为configfs_bin_attribute->cb_attr.ca_name文件名。configfs_bin_attribute->cb_attr.ca_mode指定文件权限。
cb_private成员供驱动程序使用，而cb_max_size成员指定要使用的vmalloc缓冲区的最大大小。
如果二进制属性是可读的，并且config_item提供了ct_item_ops->read_bin_attribute()方法，那么每当用户空间请求对属性进行read(2)时，该方法将被调用。对于write(2)，也会发生相反的情况。读取/写入是缓冲的，因此只会发生单个读取/写入；属性本身不需要关心这一点。
[struct config_group]
config_item不能独立存在。创建config_item的唯一方法是通过在config_group上执行mkdir(2)操作。这将触发创建子项。
	struct config_group {
		struct config_item		cg_item;
		struct list_head		cg_children;
		struct configfs_subsystem 	*cg_subsys;
		struct list_head		default_groups;
		struct list_head		group_entry;
	};

	void config_group_init(struct config_group *group);
	void config_group_init_type_name(struct config_group *group,
					 const char *name,
					 struct config_item_type *type);


config_group结构包含一个config_item。适当配置该项意味着组可以作为一个独立的项进行操作。然而，它还可以做更多的事情：它可以创建子项或子组。这是通过在组的config_item_type上指定的组操作来实现的。

	struct configfs_group_operations {
		struct config_item *(*make_item)(struct config_group *group,
						 const char *name);
		struct config_group *(*make_group)(struct config_group *group,
						   const char *name);
		int (*commit_item)(struct config_item *item);
		void (*disconnect_notify)(struct config_group *group,
					  struct config_item *item);
		void (*drop_item)(struct config_group *group,
				  struct config_item *item);
	};
组通过提供ct_group_ops->make_item()方法来创建子项。如果提供了该方法，它将在组的目录中的mkdir(2)操作中调用。子系统分配一个新的config_item（或更常见的是其容器结构），对其进行初始化，并将其返回给configfs。然后，configfs将填充文件系统树以反映新的项。
如果子系统希望子项本身成为一个组，子系统将提供ct_group_ops->make_group()。其他操作与之相同，在组上使用组的_init()函数。
最后，当用户空间对项或组调用rmdir(2)时，将调用ct_group_ops->drop_item()。由于config_group也是一个config_item，因此不需要单独的drop_group()方法。子系统必须对在项分配时初始化的引用执行config_item_put()。如果子系统没有其他工作要执行，可以省略ct_group_ops->drop_item()方法，configfs将代表子系统对项执行config_item_put()。
重要提示：drop_item()是void类型的，因此无法失败。当调用rmdir(2)时，configfs将从文件系统树中删除该项（假设没有子项）。子系统负责对此作出响应。如果子系统在其他线程中引用该项，则内存是安全的。实际上，该项从子系统的使用中消失可能需要一些时间。但它已经从configfs中消失了。
当调用drop_item()时，项的链接已经被拆除。它不再引用其父项，并且在项层次结构中没有位置。如果客户端在此拆除发生之前需要进行一些清理工作，子系统可以实现ct_group_ops->disconnect_notify()方法。该方法在configfs将项从文件系统视图中删除之后、但在将项从其父组中删除之前调用。与drop_item()一样，disconnect_notify()是void类型的，不会失败。客户端子系统不应在此处删除任何引用，因为它们仍然必须在drop_item()中执行。
只要config_group仍然具有子项，就无法删除它。这在configfs的rmdir(2)代码中实现。不会调用->drop_item()，因为项尚未被删除。rmdir(2)将失败，因为目录不为空。

[struct configfs_subsystem]
子系统通常在module_init时间注册自身。这告诉configfs将子系统显示在文件树中。
	struct configfs_subsystem {
		struct config_group	su_group;
		struct mutex		su_mutex;
	};
	int configfs_register_subsystem(struct configfs_subsystem *subsys);
	void configfs_unregister_subsystem(struct configfs_subsystem *subsys);
	一个子系统由一个顶级的config_group和一个互斥锁组成。config_group是创建子config_item的地方。对于子系统来说，这个组通常是静态定义的。在调用configfs_register_subsystem()之前，子系统必须通过常规的group_init()函数对组进行初始化，并且还必须初始化互斥锁。
当注册调用返回时，子系统将处于活动状态，并且将通过configfs可见。此时，可以调用mkdir(2)，子系统必须准备好接收该调用。
【示例】
这些基本概念的最佳示例是在samples/configfs/configfs_sample.c中的simple_children子系统/组和simple_child项。它展示了一个简单的对象，显示和存储属性，以及一个简单的组来创建和销毁这些子项。
【层次结构导航和子系统互斥锁】
configfs提供了一个额外的功能。由于config_groups和config_items出现在文件系统中，它们按层次结构排列。子系统永远不会触及文件系统的部分，但子系统可能对此层次结构感兴趣。因此，层次结构通过config_group->cg_children和config_item->ci_parent结构成员进行镜像。
子系统可以通过cg_children列表和ci_parent指针遍历子系统创建的树。这可能与configfs对层次结构的管理发生竞争，因此configfs使用子系统互斥锁来保护修改操作。每当子系统想要遍历层次结构时，必须在子系统互斥锁的保护下进行。
在新分配的项尚未链接到该层次结构时，子系统将无法获取互斥锁。类似地，在放弃项尚未取消链接时，它也无法获取互斥锁。这意味着项的ci_parent指针在项位于configfs中时永远不会为NULL，并且项仅在其父项的cg_children列表中存在相同的时间段。这允许子系统在持有互斥锁时信任ci_parent和cg_children。
【通过symlink(2)进行项聚合】

configfs通过group->item父/子关系提供了一个简单的组。然而，通常需要在父/子连接之外进行聚合。这是通过symlink(2)实现的。
config_item可以提供ct_item_ops->allow_link()和ct_item_ops->drop_link()方法。如果存在->allow_link()方法，可以使用config_item作为链接源调用symlink(2)。这些链接仅允许在configfs config_item之间创建。任何在configfs文件系统之外的symlink(2)尝试都将被拒绝。
调用symlink(2)时，将使用源config_item的->allow_link()方法和自身和目标项作为参数。如果源项允许链接到目标项，则返回0。如果源项只希望链接到某种类型的对象（例如，在其自己的子系统中），则可以拒绝链接。
在符号链接上调用unlink(2)时，将通过->drop_link()方法通知源项。与->drop_item()方法一样，这是一个无返回值的函数，无法返回失败。子系统负责响应该更改。
在任何项链接到其他项时，无法删除config_item，也无法在有项链接到它时删除config_item。在configfs中，不允许存在悬空的符号链接。
【自动创建的子组】
新的config_group可能希望具有两种类型的子config_item。虽然可以通过->make_item()中的魔术名称来编码这一点，但更明确的做法是让用户空间看到这种分歧的方法。
configfs提供了一种方法，通过该方法可以在父级创建时自动在其中创建一个或多个子组。因此，mkdir("parent")将导致创建"parent"、"parent/subgroup1"，一直到"parent/subgroupN"。类型为1的项现在可以在"parent/subgroup1"中创建，类型为N的项可以在"parent/subgroupN"中创建。
这些自动创建的子组，或默认组，不排除父组的其他子项。如果存在ct_group_ops->make_group()，可以直接在父组上创建其他子组。
通过向父config_group结构添加它们，configfs子系统可以指定默认组。这是一个关于configfs的C代码示例，它展示了configfs的一些基本概念和用法。
首先，在代码中定义了一个名为"simple_children"的子系统/组和一个名为"simple_child"的项。这个简单的对象展示了如何显示和存储属性，并且使用一个简单的组来创建和销毁这些子项。
configfs中的子系统和组是以层次结构排列的，可以通过config_group->cg_children和config_item->ci_parent来遍历子系统创建的树。为了保护修改操作，configfs使用了子系统互斥锁。
在代码中还使用了symlink(2)函数来创建项之间的链接。config_item可以提供allow_link()和drop_link()方法来控制链接的创建和删除。使用symlink(2)函数创建的链接只允许在configfs中的config_item之间创建，对于configfs文件系统之外的symlink(2)尝试会被拒绝。
此外，代码中还介绍了自动创建的子组的概念。通过在父级创建时自动创建一个或多个子组，可以更方便地组织config_item。这些自动创建的子组不会排除父组的其他子项。
这只是一个简单的示例，用于介绍configfs的基本概念和用法。实际使用configfs时，可能会有更复杂的场景和用法。

Linux内核源码linux_sdk/kernel/samples/configfs目录下的configfs_sample.c，如下所示：

/*
 * vim: noexpandtab ts=8 sts=0 sw=8:
 *
 * configfs_example_macros.c - This file is a demonstration module
 *      containing a number of configfs subsystems.  It uses the helper
 *      macros defined by configfs.h
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 *
 * Based on sysfs:
 * 	sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
 *
 * configfs Copyright (C) 2005 Oracle.  All rights reserved.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>

#include <linux/configfs.h>



/*
 * 01-childless
 *
 * This first example is a childless subsystem.  It cannot create
 * any config_items.  It just has attributes.
 *
 * Note that we are enclosing the configfs_subsystem inside a container.
 * This is not necessary if a subsystem has no attributes directly
 * on the subsystem.  See the next example, 02-simple-children, for
 * such a subsystem.
 */

struct childless {
	struct configfs_subsystem subsys;
	int showme;
	int storeme;
};

static inline struct childless *to_childless(struct config_item *item)
{
	return item ? container_of(to_configfs_subsystem(to_config_group(item)),
			struct childless, subsys) : NULL;
}

static ssize_t childless_showme_show(struct config_item *item, char *page)
{
	struct childless *childless = to_childless(item);
	ssize_t pos;

	pos = sprintf(page, "%d\n", childless->showme);
	childless->showme++;

	return pos;
}

static ssize_t childless_storeme_show(struct config_item *item, char *page)
{
	return sprintf(page, "%d\n", to_childless(item)->storeme);
}

static ssize_t childless_storeme_store(struct config_item *item,
		const char *page, size_t count)
{
	struct childless *childless = to_childless(item);
	unsigned long tmp;
	char *p = (char *) page;

	tmp = simple_strtoul(p, &p, 10);
	if (!p || (*p && (*p != '\n')))
		return -EINVAL;

	if (tmp > INT_MAX)
		return -ERANGE;

	childless->storeme = tmp;

	return count;
}

static ssize_t childless_description_show(struct config_item *item, char *page)
{
	return sprintf(page,
"[01-childless]\n"
"\n"
"The childless subsystem is the simplest possible subsystem in\n"
"configfs.  It does not support the creation of child config_items.\n"
"It only has a few attributes.  In fact, it isn't much different\n"
"than a directory in /proc.\n");
}

CONFIGFS_ATTR_RO(childless_, showme);
CONFIGFS_ATTR(childless_, storeme);
CONFIGFS_ATTR_RO(childless_, description);

static struct configfs_attribute *childless_attrs[] = {
	&childless_attr_showme,
	&childless_attr_storeme,
	&childless_attr_description,
	NULL,
};

static const struct config_item_type childless_type = {
	.ct_attrs	= childless_attrs,
	.ct_owner	= THIS_MODULE,
};

static struct childless childless_subsys = {
	.subsys = {
		.su_group = {
			.cg_item = {
				.ci_namebuf = "01-childless",
				.ci_type = &childless_type,
			},
		},
	},
};


/* ----------------------------------------------------------------- */

/*
 * 02-simple-children
 *
 * This example merely has a simple one-attribute child.  Note that
 * there is no extra attribute structure, as the child's attribute is
 * known from the get-go.  Also, there is no container for the
 * subsystem, as it has no attributes of its own.
 */

struct simple_child {
	struct config_item item;
	int storeme;
};

static inline struct simple_child *to_simple_child(struct config_item *item)
{
	return item ? container_of(item, struct simple_child, item) : NULL;
}

static ssize_t simple_child_storeme_show(struct config_item *item, char *page)
{
	return sprintf(page, "%d\n", to_simple_child(item)->storeme);
}

static ssize_t simple_child_storeme_store(struct config_item *item,
		const char *page, size_t count)
{
	struct simple_child *simple_child = to_simple_child(item);
	unsigned long tmp;
	char *p = (char *) page;

	tmp = simple_strtoul(p, &p, 10);
	if (!p || (*p && (*p != '\n')))
		return -EINVAL;

	if (tmp > INT_MAX)
		return -ERANGE;

	simple_child->storeme = tmp;

	return count;
}

CONFIGFS_ATTR(simple_child_, storeme);

static struct configfs_attribute *simple_child_attrs[] = {
	&simple_child_attr_storeme,
	NULL,
};

static void simple_child_release(struct config_item *item)
{
	kfree(to_simple_child(item));
}

static struct configfs_item_operations simple_child_item_ops = {
	.release		= simple_child_release,
};

static const struct config_item_type simple_child_type = {
	.ct_item_ops	= &simple_child_item_ops,
	.ct_attrs	= simple_child_attrs,
	.ct_owner	= THIS_MODULE,
};


struct simple_children {
	struct config_group group;
};

static inline struct simple_children *to_simple_children(struct config_item *item)
{
	return item ? container_of(to_config_group(item),
			struct simple_children, group) : NULL;
}

static struct config_item *simple_children_make_item(struct config_group *group,
		const char *name)
{
	struct simple_child *simple_child;

	simple_child = kzalloc(sizeof(struct simple_child), GFP_KERNEL);
	if (!simple_child)
		return ERR_PTR(-ENOMEM);

	config_item_init_type_name(&simple_child->item, name,
				   &simple_child_type);

	simple_child->storeme = 0;

	return &simple_child->item;
}

static ssize_t simple_children_description_show(struct config_item *item,
		char *page)
{
	return sprintf(page,
"[02-simple-children]\n"
"\n"
"This subsystem allows the creation of child config_items.  These\n"
"items have only one attribute that is readable and writeable.\n");
}

CONFIGFS_ATTR_RO(simple_children_, description);

static struct configfs_attribute *simple_children_attrs[] = {
	&simple_children_attr_description,
	NULL,
};

static void simple_children_release(struct config_item *item)
{
	kfree(to_simple_children(item));
}

static struct configfs_item_operations simple_children_item_ops = {
	.release	= simple_children_release,
};

/*
 * Note that, since no extra work is required on ->drop_item(),
 * no ->drop_item() is provided.
 */
static struct configfs_group_operations simple_children_group_ops = {
	.make_item	= simple_children_make_item,
};

static const struct config_item_type simple_children_type = {
	.ct_item_ops	= &simple_children_item_ops,
	.ct_group_ops	= &simple_children_group_ops,
	.ct_attrs	= simple_children_attrs,
	.ct_owner	= THIS_MODULE,
};

static struct configfs_subsystem simple_children_subsys = {
	.su_group = {
		.cg_item = {
			.ci_namebuf = "02-simple-children",
			.ci_type = &simple_children_type,
		},
	},
};


/* ----------------------------------------------------------------- */

/*
 * 03-group-children
 *
 * This example reuses the simple_children group from above.  However,
 * the simple_children group is not the subsystem itself, it is a
 * child of the subsystem.  Creation of a group in the subsystem creates
 * a new simple_children group.  That group can then have simple_child
 * children of its own.
 */

static struct config_group *group_children_make_group(
		struct config_group *group, const char *name)
{
	struct simple_children *simple_children;

	simple_children = kzalloc(sizeof(struct simple_children),
				  GFP_KERNEL);
	if (!simple_children)
		return ERR_PTR(-ENOMEM);

	config_group_init_type_name(&simple_children->group, name,
				    &simple_children_type);

	return &simple_children->group;
}

static ssize_t group_children_description_show(struct config_item *item,
		char *page)
{
	return sprintf(page,
"[03-group-children]\n"
"\n"
"This subsystem allows the creation of child config_groups.  These\n"
"groups are like the subsystem simple-children.\n");
}

CONFIGFS_ATTR_RO(group_children_, description);

static struct configfs_attribute *group_children_attrs[] = {
	&group_children_attr_description,
	NULL,
};

/*
 * Note that, since no extra work is required on ->drop_item(),
 * no ->drop_item() is provided.
 */
static struct configfs_group_operations group_children_group_ops = {
	.make_group	= group_children_make_group,
};

static const struct config_item_type group_children_type = {
	.ct_group_ops	= &group_children_group_ops,
	.ct_attrs	= group_children_attrs,
	.ct_owner	= THIS_MODULE,
};

static struct configfs_subsystem group_children_subsys = {
	.su_group = {
		.cg_item = {
			.ci_namebuf = "03-group-children",
			.ci_type = &group_children_type,
		},
	},
};

/* ----------------------------------------------------------------- */

/*
 * We're now done with our subsystem definitions.
 * For convenience in this module, here's a list of them all.  It
 * allows the init function to easily register them.  Most modules
 * will only have one subsystem, and will only call register_subsystem
 * on it directly.
 */
static struct configfs_subsystem *example_subsys[] = {
	&childless_subsys.subsys,
	&simple_children_subsys,
	&group_children_subsys,
	NULL,
};

static int __init configfs_example_init(void)
{
	int ret;
	int i;
	struct configfs_subsystem *subsys;

	for (i = 0; example_subsys[i]; i++) {
		subsys = example_subsys[i];

		config_group_init(&subsys->su_group);
		mutex_init(&subsys->su_mutex);
		ret = configfs_register_subsystem(subsys);
		if (ret) {
			printk(KERN_ERR "Error %d while registering subsystem %s\n",
			       ret,
			       subsys->su_group.cg_item.ci_namebuf);
			goto out_unregister;
		}
	}

	return 0;

out_unregister:
	for (i--; i >= 0; i--)
		configfs_unregister_subsystem(example_subsys[i]);

	return ret;
}

static void __exit configfs_example_exit(void)
{
	int i;

	for (i = 0; example_subsys[i]; i++)
		configfs_unregister_subsystem(example_subsys[i]);
}

module_init(configfs_example_init);
module_exit(configfs_example_exit);
MODULE_LICENSE("GPL");

上面的驱动文件，大家可以好好分析下代码。至此，设备树模型课程学习完毕。