内核集合与对象例程

/* 文件名：sysfs_test.c */
/* 说明：内核集合与对象例程 */

#include <linux/module.h>

MODULE_LICENSE("GPL");

#define SZ_STRING 30 /* 字符串的最大长度 */
#define NR_KOBJS 3 /* 内核对象的个数 */

/* 仿照内核的 kobj_attr_show 函数 */
static ssize_t test_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)
        ret = kattr->show(kobj, kattr, buf);
    return ret;
}

/* 仿照内核的 kobj_attr_store 函数 */
static ssize_t test_attr_store(struct kobject *kobj, struct attribute *attr,
        const char *buf, size_t count)
{
    struct kobj_attribute *kattr;
    ssize_t ret = -EIO;
    kattr = container_of(attr, struct kobj_attribute, attr);
    if (kattr->store)
        ret = kattr->store(kobj, kattr, buf, count);
    return ret;
}

/* 仿照内核的 kobj_sysfs_ops 变量 */
static struct sysfs_ops test_sysfs_ops = {
    .show    = test_attr_show,
    .store    = test_attr_store,
};

/* 内核对象的释放函数 */
static void test_release(struct kobject *kobj)
{
    kfree(kobj);
}

/* 属性 name 的 show 函数 */
static ssize_t test_name_show(struct kobject *kobj,
        struct kobj_attribute *attr, char *buf)
{
    return sprintf(buf, "%s\n", kobject_name(kobj));
}

/* 属性 name 的 store 函数，因为是只读属性，因此直接返回错误 */
static ssize_t test_name_store(struct kobject *kobj,
        struct kobj_attribute *attr, const char *buf, size_t len)
{
    return -EACCES; /* 错误号表示无权限 */
}

/* 属性 name 的定义 */
static struct kobj_attribute test_attr_name =
        __ATTR(name, S_IRUGO, test_name_show, test_name_store);

/* 用于保存属性 string 对应的字符串 */
static char test_string[SZ_STRING] = "test\n";

/* 属性 string 的 show 函数 */
static ssize_t test_string_show(struct kobject *kobj,
        struct kobj_attribute *attr, char *buf)
{
    return sprintf(buf, test_string);
}

/* 属性 string 的 store 函数 */
static ssize_t test_string_store(struct kobject *kobj,
        struct kobj_attribute *attr, const char *buf, size_t len)
{
    if (len >= SZ_STRING) len = SZ_STRING-1; /* 限制写的长度 */
    memcpy(test_string, buf, len); /* 复制数据 */
    test_string[len] = '\0'; /* 字符串结尾 */
    return len;
}

/* 属性 string 的定义 */
static struct kobj_attribute test_attr_string =
        __ATTR(string, S_IRUGO|S_IWUGO, test_string_show, test_string_store);

/* 对象的默认属性 */
static struct attribute *test_default_attr[] = {
    &test_attr_name.attr,
    &test_attr_string.attr,
    NULL,
};

/* 对象的类型 */
static struct kobj_type test_kobj_type = {
    .release = test_release, /* 释放函数 */
    .sysfs_ops = &test_sysfs_ops, /* 属性操作 */
    .default_attrs = test_default_attr /* 默认属性 */
};

/* 用于保存动态创建的内核集合的指针 */
static struct kset *kset;

/* 模块的初始化函数 */
static __init int sysfs_test_init(void)
{
    int i; /* 循环变量 */
    int err; /* 用于暂存错误码 */
    struct kobject *kobj, *next; /* 循环变量 */
    pr_debug("sysfs_test_init: be called.\n");
    /* 创建并注册内核集合，由于没有父对象，将成为顶级子系统 */
    if ((kset = kset_create_and_add("test", NULL, NULL)) == NULL) {
        pr_debug("sysfs_test_init: kset_create_and_add ERR!\n");
        err = -ENOMEM;
        goto kset_fail;
    }
    /* 为 kset 集合动态创建一个属性，使用 name 属性的定义 */
    if ((err = sysfs_create_file(&kset->kobj, &test_attr_name.attr))) {
        pr_debug("sysfs_test_init: sysfs_create_file ERR!\n");
        goto sysfs_fail;
    }
    /* 注册 NR_KOBJS 个内核对象，都属于 kset 集合 */
    for (i = 0; i < NR_KOBJS; i++) {
        /* 分配内存 */
        kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL);
        if (!kobj) {
            pr_debug("sysfs_test_init: kzalloc ERR!\n");
            err = -ENOMEM;
            goto kobject_fail;
        }
        /* 设置所属集合 */
        kobj->kset = kset;
        /* 初始化并注册 */
        err = kobject_init_and_add(kobj, &test_kobj_type, NULL, "obj%d", i);
        if (err) {
            pr_debug("sysfs_test_init: kobject_register ERR = %d\n", err);
            kfree(kobj);
            goto kobject_fail;
        }
        /* 发送事件 */
        kobject_uevent(kobj, KOBJ_ADD);
    }
    return 0;
kobject_fail:
    list_for_each_entry_safe(kobj, next, &kset->list, entry)
        kobject_put(kobj);
sysfs_fail:
    kset_unregister(kset);
kset_fail:
    return err;
}
module_init(sysfs_test_init);

/* 模块的退出函数 */
static __exit void sysfs_test_exit(void)
{
    struct kobject *kobj, *next;
    pr_debug("sysfs_test_exit: be called.\n");
    /* 首先清理集合中的所有对象 */
    list_for_each_entry_safe(kobj, next, &kset->list, entry)
        kobject_put(kobj);
    /* 然后注销集合 */
    kset_unregister(kset);
}
module_exit(sysfs_test_exit);

# 文件名：Makefile

# 说明：内核集合与对象例程 Makefile



# 模块名

MOD_NAME := sysfs_test



# 模块源码（不能出现与模块名相同的文件名）

SRCS := \



EXTRA_CFLAGS = -DDEBUG



OBJS := $(SRCS:.c=.o)



ifeq ($(KERNELRELEASE),)



KERNELDIR ?= /lib/modules/$(shell uname -r)/build

PWD := $(shell pwd)



default:

$(MAKE) -C $(KERNELDIR) M=$(PWD) modules



clean:

-rm -f $(MOD_NAME).ko

-rm -f $(MOD_NAME).o

-rm -f $(OBJS)

-rm -rf .tmp_versions

-rm -f .*.cmd

-rm -f *.mod.c

-rm -f *.mod.o

-rm -f Module.symvers

-rm -f modules.order



else



$(MOD_NAME)-objs := $(OBJS)

obj-m := $(MOD_NAME).o



endif