Linux设备管理模型-02：sysfs

Leo-夜空

已于 2024-01-20 19:07:37 修改

阅读量1k

点赞数 20

分类专栏： C 文章标签： linux 嵌入式

于 2024-01-20 19:04:20 首次发布

本文链接：https://blog.csdn.net/weixin_43104399/article/details/135720088

版权

C 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本文详细介绍了sysfs在Linux内核中的作用，包括如何使用sysfs控制GPIO和如何完善sysfs属性文件的读写操作。通过示例代码展示了如何创建、读写和管理自定义sysfs属性，以及在kset和kobject上下文中实现这些功能。

摘要由CSDN通过智能技术生成

上一篇文: 设备管理模型中的基础数据结构

sysfs

sysfs是用于导出内核对象的文件系统，它是一个基于ram的文件系统，最初基于ramfs。
sysfs通常挂载在/sys目录下。它提供了一种层次结构来表示设备、驱动程序和总线之间的关系，以及设备属性的信息。用户和管理者可以使用sysfs来查询和配置设备的状态和属性。

如果定义了CONFIG_SYSFS，那么sysfs总是编译进内核。

~ # ls /sys
block     class     devices   fs        module
bus       dev       firmware  kernel    power

sysfs中的目录树是由kobject和kset组织而成的。
对于每一个注册到系统的kobject，都会在sysfs中创建一个对应的目录，他是kobject父对象的子目录，以此像用户空间表达内部对象层级。
相同的kset下有多个kobject，kset又由链表连接，他们共同组成了这个目录树。

一个kset下的kobject可以有相同的ktype，也可以不同。

目录	用途
block
bus	包含内核中各种总线类型的扁平化布局，每个目录下都分别包含`devices` 和 `drivers` 两个目录。
class
dev	包含 2 个目录: char 和 block，它们里面是 `<major>:<minor>` 格式指向设备的符号链。
devices	包含表示设备树的一个文件系统，它直接映射至内部内核设备树，即 `struct device` 层级
firmware	包含硬件固件相关信息
fs	包含针对一些文件系统的目录，每个需要导出属性的文件系统都必须在/fs下
kernel	包含内核信息和控制接口
module
power

1 使用sysfs控制GPIO

make menuconfig 确保 Device Drivers > LED Support 没有 LED Class Support（如果使用LED做实验），并且Device Drivers > GPIO Support 已使能。

GPIO1_0 : (1 - 1) * 32 + 0 = 0
如下命令导出GPIO1_0
echo 0 > /sys/class/gpio/export

GPIOX_N引脚：(X - 1) * 32 + N

[root@qemu_imx6ul:/sys/class/gpio]# ls
export       gpiochip0    gpiochip32   gpiochip96
gpio0        gpiochip128  gpiochip64   unexport
[root@qemu_imx6ul:/sys/class/gpio]# ls gpio0
active_low  direction   power       uevent
device      edge        subsystem   value

echo out > /sys/class/gpio/gpio0/direction
echo 1 > /sys/class/gpio/gpio0/value

2 sysfs编程

2.1 完善sysfs属性文件的读写操作

上一篇文kset例程中只有kset和kobject的目录组织关系，它还需要能够读写控制才比较完整。本节基于该例程完善了kobject在sysfs的各种行为。

在1.2节的例程中仅定义了kobj_type的release方法，属性的通用读写操作也在kobj_type中：

#include <linux/kobject.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>

MODULE_LICENSE("GPL");

struct foo_obj {
	struct kobject kobj;
	int foo;
	int baz;
	int bar;
};
/* 从类型为kobj的结构体成员的指针x，获取该foo_obj类型结构体的指针 */
#define to_foo_obj(x) container_of(x, struct foo_obj, kobj)

/* 自定义属性，继承自attribute */
struct foo_attribute {
	struct attribute attr; /* 包含name 和 mode 成员变量*/
	ssize_t (*show)(struct foo_obj *foo, struct foo_attribute *attr, char *buf);
	ssize_t (*store)(struct foo_obj *foo, struct foo_attribute *attr, const char *buf, size_t count);
};
#define to_foo_attr(x) container_of(x, struct foo_attribute, attr)

/*
 * 每当与已注册kobject关联的sysfs文件上的show函数被用户调用时，这个函数就会被sysfs调用。
 * 需要把传入的kobj转置为自己的kobj子类，然后调用这个特定对象的show函数 */
static ssize_t foo_attr_show(struct kobject *kobj,
			     struct attribute *attr,
			     char *buf)
{
	struct foo_attribute *attribute;
	struct foo_obj *foo;

	attribute = to_foo_attr(attr);
	foo = to_foo_obj(kobj);

	if (!attribute->show)
		return -EIO;
	
	return attribute->show(foo, attribute, buf);
}

/* 通过sysfs写入属性文件时被调用 */
static ssize_t foo_attr_store(struct kobject *kobj,
			      struct attribute *attr,
			      const char *buf, size_t len)
{
	struct foo_attribute *attribute;
	struct foo_obj *foo;

	attribute = to_foo_attr(attr);
	foo = to_foo_obj(kobj);

	if (!attribute->store)
		return -EIO;

	return attribute->store(foo, attribute, buf, len);
}

/* Our custom sysfs_ops that we will associate with our ktype later on */
static const struct sysfs_ops foo_sysfs_ops = {
	.show = foo_attr_show,
	.store = foo_attr_store,
};

/* 属性的读取函数，每个属性可以有不同的读取 */
static ssize_t var_show(struct foo_obj *foo_obj, struct foo_attribute *attr,
		      char *buf)
{
	int var;
	if (strcmp(attr->attr.name, "len_attr") == 0)
		var = foo_obj->foo;
	else if (strcmp(attr->attr.name, "derict_attr") == 0)
		var = foo_obj->baz;
	else
		var = foo_obj->bar;
	
	return sprintf(buf, "%d\n", var);
}
/* 属性的写入函数，每个属性可以有不同的写入 */
static ssize_t var_store(struct foo_obj *foo_obj, struct foo_attribute *attr,
		       const char *buf, size_t count)
{
	int var, ret;

	ret = kstrtoint(buf, 10, &var);
	if (ret < 0)
		return ret;

	if (strcmp(attr->attr.name, "len_attr") == 0)
		foo_obj->foo = var;
	else if (strcmp(attr->attr.name, "derict_attr") == 0)
		foo_obj->baz = var;
	else
		foo_obj->bar = var;
	
	return count;
}
/* Sysfs attributes cannot be world-writable.   
 * __ATTR(name, mode, show, store) : 生成一个包含属性的结构体，以及相关的访问函数。
 * 这样，可以将属性与对应的读写函数关联起来，并在 sysfs 中创建相应的属性文件，用于读取或写入属性值。*/
static struct foo_attribute foo_attribute =
	__ATTR(len_attr, 0664, var_show, var_store);
static struct foo_attribute baz_attribute =
	__ATTR(derict_attr, 0664, var_show, var_store);
static struct foo_attribute bar_attribute =
	__ATTR(depth_attr, 0664, var_show, var_store);

/*
 * Create a group of attributes so that we can create and destroy them all
 * at once.
 */
static struct attribute *foo_default_attrs[] = {
	&foo_attribute.attr,
	&baz_attribute.attr,
	&bar_attribute.attr,
	NULL,	/* need to NULL terminate the list of attributes */
};

static void foo_release(struct kobject *kobj)
{
	struct foo_obj *foo;

	foo = to_foo_obj(kobj);
	kfree(foo);
}

/* 可以定义所属kset的kobject的一些行为到default_attrs和sysfs_ops属性中 */
static struct kobj_type foo_ktype = {
    .sysfs_ops = &foo_sysfs_ops,
    .release = foo_release,
    .default_attrs = foo_default_attrs,
};

static struct kset *example_kset;
static struct foo_obj *foo_obj;
static struct foo_obj *bar_obj;
static struct foo_obj *baz_obj;

static struct foo_obj *create_foo_obj(const char *name)
{
	struct foo_obj *foo;
	int retval;

	/* allocate the memory for the whole object */
	foo = kzalloc(sizeof(*foo), GFP_KERNEL);
	if (!foo)
		return NULL;
	
	/* 初始化kobject之前先确定所属kset */
	foo->kobj.kset = example_kset;

	/* 初始化kobject添加到kernel中，并关联ktype，会在sysfs中创建名为name的kobject文件夹
	 * 第三个参数是父kobj，由于已确定kset，写为NULL */
	retval = kobject_init_and_add(&foo->kobj, &foo_ktype, NULL, "%s", name);
	if (retval) {
		kobject_put(&foo->kobj);
		return NULL;
	}
	/* 通知用户空间有一个新的内核对象（kobject）已经被添加到 sysfs 中。
	 * 这对于用户空间的监控和管理工具来说是很有用的 */
	kobject_uevent(&foo->kobj, KOBJ_ADD);

	return foo;
}

static void destroy_foo_obj(struct foo_obj *foo)
{
	kobject_put(&foo->kobj);
}

static int __init example_init(void)
{
    /* 创建一个名为 "kset_example" 的kset, 路径在/sys/kernel/ */
    example_kset = kset_create_and_add("kset_example", NULL, kernel_kobj);
    if (!example_kset)
    	return -ENOMEM;
    /* 在已定义的kset下新增kobject */
    foo_obj = create_foo_obj("foo");
    if (!foo_obj)
    	goto foo_error;
    
    bar_obj = create_foo_obj("bar");
    if (!bar_obj)
    	goto bar_error;
    
    baz_obj = create_foo_obj("baz");
    if (!baz_obj)
    	goto baz_error;
    
    return 0;

baz_error:
	destroy_foo_obj(bar_obj);
bar_error:
	destroy_foo_obj(foo_obj);
foo_error:
	kset_unregister(example_kset);
	return -EINVAL;
}

static void __exit example_exit(void)
{
	destroy_foo_obj(baz_obj);
	destroy_foo_obj(bar_obj);
	destroy_foo_obj(foo_obj);
	kset_unregister(example_kset);
}

MODULE_AUTHOR("LUKEKE");        // 作者
MODULE_DESCRIPTION("kset test"); // 描述
MODULE_ALIAS("kset Learn");   // 别名

module_init(example_init);
module_exit(example_exit);

测试解果如下

[root@qemu_imx6ul:/sys/kernel/kset_example]# ls
bar  baz  foo
[root@qemu_imx6ul:/sys/kernel/kset_example]# ls baz
depth_attr   derict_attr  len_attr
[root@qemu_imx6ul:/sys/kernel/kset_example/foo]# cd foo & ls
depth_attr   derict_attr  len_attr
[root@qemu_imx6ul:/sys/kernel/kset_example/foo]# echo 5 > depth_attr 
[root@qemu_imx6ul:/sys/kernel/kset_example/foo]# cat depth_attr 
5
[root@qemu_imx6ul:/sys/kernel/kset_example/foo]# echo 3 > derict_attr 
[root@qemu_imx6ul:/sys/kernel/kset_example/foo]# cat derict_attr 
3

除了上述通过kobject_init_and_add设置ktype的方式创建属性文件，也可以在kobject_create_and_add("my_kobject", kernel_kobj)之后使用sysfs_create_files(my_kobject, attrs)创建属性文件。

属性读写的简单描述如下图所示：
sysfs属性文件读写