本文主要是介绍Linux设备模型(八) - sysfs,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
一,sysfs目录介绍
sysfs是一个基于内存的虚拟的文件系统,有kernel提供,挂载到/sys目录下,负责以设备树的形式向user space提供直观的设备和驱动信息。
sysfs以不同的视角展示当前系统接入的设备:
/sys/block 历史遗留问题,存放块设备,提供一设备名(如sda)到/sys/devices的符号链接;
/sys/bus 按总线类型分类,在某个总线目录之下可以找到链接该总线的设备的符号链接,指向/sys/devices. 某个总线目录之下的drivers目录包含了该总线所需的所有驱动的符号链接。对应kernel中的struct bus_type;
/sys/calss 按设备功能分类,如输入设备在/sys/class/input之下,图形设备在/sys/class/graphics之下,是指向/sys/devices的符号链接。 对应kernel中的struct class
/sys/dev 按设备驱动程序分层(字符设备 块设备),提供以major:minor为名到/sys/devices的符号链接。 对应Kernel中的struct device_driver;
/sys/devices 包含所有被发现的注册在各种总线上的各种物理设备。 所有物理设备都按其在总线上的拓扑结构来显示,除了platform devices和system devices。 platform devices 一般是挂载在芯片内部高速或者低速总线上的各种控制器和外设,能被CPU直接寻址。 system devices不是外设,而是芯片内部的核心结构,比如CPU,timer等。对应kernel中的strcut device;
/sys/firmware 提供对固件的查询和操作接口(关于固件有专用于固件加载的一套api);
/sys/fs 描述当前加载的文件系统,提供文件系统和文件系统已挂载的设备信息;
/sys/kernel 提供kernel所有可调整参数,但大多数可调整参数依然存放在sysctl(/proc/sys/kernel);
/sys/module 所有加载模块(包括内联、编译进kernel、外部的模块)信息,按模块类型分类;
/sys/power 电源选项,可用于控制整个机器的电源状态,如写入控制命令进行关机、重启等;
sysfs支持多视角查看,通过符号链接,同样的信息可出现在多个目录下。
以硬盘sda为例,既可以在块设备目录/sys/block下找到,又可以在/sys/devices/pci0000:00/0000:00:10.0/host32/target32:0:0/下找到。
二,sysfs与kobject的关系
sysfs的信息来源是kobject层次结构,读一个sysfs文件,就是动态的从kobject结构提取信息,生成文件。
每一个Kobject,都会对应sysfs中的一个目录。因此在将Kobject添加到Kernel时,create_dir接口会调用sysfs文件系统的创建目录接口,创建和Kobject对应的目录,相关的代码如下:
static int create_dir(struct kobject *kobj)
{const struct kobj_type *ktype = get_ktype(kobj);const struct kobj_ns_type_operations *ops;int error;error = sysfs_create_dir_ns(kobj, kobject_namespace(kobj)); //创建dirif (error)return error;error = populate_dir(kobj); //使用default attributes填充dirif (error) {sysfs_remove_dir(kobj);return error;}if (ktype) {error = sysfs_create_groups(kobj, ktype->default_groups); //使用default_groups填充dirif (error) {sysfs_remove_dir(kobj);return error;}}... ...
}/**
* sysfs_create_dir_ns - create a directory for an object with a namespace tag
* @kobj: object we're creating directory for
* @ns: the namespace tag to use
*/
int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
{struct kernfs_node *parent, *kn;kuid_t uid;kgid_t gid;if (WARN_ON(!kobj))return -EINVAL;if (kobj->parent)parent = kobj->parent->sd;elseparent = sysfs_root_kn;if (!parent)return -ENOENT;kobject_get_ownership(kobj, &uid, &gid);kn = kernfs_create_dir_ns(parent, kobject_name(kobj),S_IRWXU | S_IRUGO | S_IXUGO, uid, gid,kobj, ns); //调用文件系统操作接口创建dirif (IS_ERR(kn)) {if (PTR_ERR(kn) == -EEXIST)sysfs_warn_dup(parent, kobject_name(kobj));return PTR_ERR(kn);}kobj->sd = kn;return 0;
}
三,attribute
1,attribute功能概述
所谓的attibute,就是内核空间和用户空间进行信息交互的一种方法。例如某个driver定义了一个变量,却希望用户空间程序可以修改该变量,以控制driver的运行行为,那么就可以将该变量以sysfs attribute的形式开放出来。
Linux内核中,attribute分为普通的attribute和二进制attribute,如下:
msm_kernel\include\linux\sysfs.h
struct attribute {const char *name;umode_t mode;
#ifdef CONFIG_DEBUG_LOCK_ALLOCbool ignore_lockdep:1;struct lock_class_key *key;struct lock_class_key skey;
#endif
};struct bin_attribute {struct attribute attr;size_t size;void *private;ssize_t (*read)(struct file *, struct kobject *, struct bin_attribute *,char *, loff_t, size_t);ssize_t (*write)(struct file *, struct kobject *, struct bin_attribute *,char *, loff_t, size_t);int (*mmap)(struct file *, struct kobject *, struct bin_attribute *attr,struct vm_area_struct *vma);
};
struct attribute为普通的attribute,使用该attribute生成的sysfs文件,只能用字符串的形式读写。而struct bin_attribute在struct attribute的基础上,增加了read、write等函数,因此它所生成的sysfs文件可以用任何方式读写。
2,attribute文件创建
/sys/bus/i2c # cat /sys/bus/i2c/drivers_autoprobe
1
有这样一个sysfs node,当bus register的时候,drivers_autoprobe node会被创建出来,用来表示 device和device driver是否自动执行probe的操作,看一下这个attribute的创建过程。
2.1 /sys/bus/i2c/drivers_autoprobe sysfs node创建流程
bus_register(struct bus_type *bus) //msm_kernel\drivers\base\bus.c
struct subsys_private *priv;
priv->subsys.kobj.ktype = &bus_ktype; //bus_ktype
----add_probe_files(bus);
--------bus_create_file(bus, &bus_attr_drivers_autoprobe);
------------sysfs_create_file(&dev->kobj, &attr->attr);
----------------sysfs_create_file_ns(kobj, attr, NULL);
--------------------sysfs_add_file_mode_ns(kobj->sd, attr, false, attr->mode, uid, gid, ns);
------------------------kn = __kernfs_create_file(parent, attr->name, mode & 0777, uid, gid, size, ops, (void *)attr, ns, key);
----------------------------kn->priv = priv; //(void *)attr
----------------------------kernfs_add_one(kn);
--------------------------------kernfs_link_sibling(kn);
关键代码解析:
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;if (!is_bin) {struct kobject *kobj = parent->priv;const struct sysfs_ops *sysfs_ops = kobj->ktype->sysfs_ops;/* every kobject with an attribute needs a ktype assigned *///如果从属的kobject(就是attribute文件所在的目录)没有ktype,或者没有ktype->sysfs_ops指针,是不允许它注册任何attribute的if (WARN(!sysfs_ops, KERN_ERR"missing sysfs attribute operations for kobject: %s\n",kobject_name(kobj)))return -EINVAL;if (sysfs_ops->show && sysfs_ops->store) {if (mode & SYSFS_PREALLOC)ops = &sysfs_prealloc_kfops_rw; //判断ktype->sysfs_ops中的操作函数,确定kernfs_ops ops支持哪些操作,只读/只写/读写elseops = &sysfs_file_kfops_rw;} else if (sysfs_ops->show) {if (mode & SYSFS_PREALLOC)ops = &sysfs_prealloc_kfops_ro;elseops = &sysfs_file_kfops_ro;} else if (sysfs_ops->store) {if (mode & SYSFS_PREALLOC)ops = &sysfs_prealloc_kfops_wo;elseops = &sysfs_file_kfops_wo;} elseops = &sysfs_file_kfops_empty;size = PAGE_SIZE;} else {struct bin_attribute *battr = (void *)attr;if (battr->mmap)ops = &sysfs_bin_kfops_mmap;else if (battr->read && battr->write)ops = &sysfs_bin_kfops_rw;else if (battr->read)ops = &sysfs_bin_kfops_ro;else if (battr->write)ops = &sysfs_bin_kfops_wo;elseops = &sysfs_file_kfops_empty;size = battr->size;}#ifdef CONFIG_DEBUG_LOCK_ALLOCif (!attr->ignore_lockdep)key = attr->key ?: (struct lock_class_key *)&attr->skey;
#endifkn = __kernfs_create_file(parent, attr->name, mode & 0777, uid, gid,size, ops, (void *)attr, ns, key);if (IS_ERR(kn)) {if (PTR_ERR(kn) == -EEXIST)sysfs_warn_dup(parent, attr->name);return PTR_ERR(kn);}return 0;
}/**
* __kernfs_create_file - kernfs internal function to create a file
* @parent: directory to create the file in
* @name: name of the file
* @mode: mode of the file
* @uid: uid of the file
* @gid: gid of the file
* @size: size of the file
* @ops: kernfs operations for the file
* @priv: private data for the file
* @ns: optional namespace tag of the file
* @key: lockdep key for the file's active_ref, %NULL to disable lockdep
*
* Returns the created node on success, ERR_PTR() value on error.
*/
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;kn = kernfs_new_node(parent, name, (mode & S_IALLUGO) | S_IFREG,uid, gid, flags);if (!kn)return ERR_PTR(-ENOMEM);kn->attr.ops = ops; // kernfs_node ops操作函数初始化 #1kn->attr.size = size;kn->ns = ns;kn->priv = priv; //kernfs_node私有数据赋值,这里是struct attribute *attr,后续读写attribute的时候会用到#ifdef CONFIG_DEBUG_LOCK_ALLOCif (key) {lockdep_init_map(&kn->dep_map, "kn->active", key, 0);kn->flags |= KERNFS_LOCKDEP;}
#endif/** kn->attr.ops is accesible only while holding active ref. We* need to know whether some ops are implemented outside active* ref. Cache their existence in flags.*/if (ops->seq_show)kn->flags |= KERNFS_HAS_SEQ_SHOW;if (ops->mmap)kn->flags |= KERNFS_HAS_MMAP;if (ops->release)kn->flags |= KERNFS_HAS_RELEASE;rc = kernfs_add_one(kn);if (rc) {kernfs_put(kn);return ERR_PTR(rc);}return kn;
}
2.2 bus_ktype
如果从属的kobject(就是attribute文件所在的目录)没有ktype,或者没有ktype->sysfs_ops指针,是不允许它注册任何attribute的。
drivers/base/bus.c:
static struct kobj_type bus_ktype = {.sysfs_ops = &bus_sysfs_ops,.release = bus_release,
};static const struct sysfs_ops bus_sysfs_ops = {.show = bus_attr_show, // #2.store = bus_attr_store,
};#define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr,char *buf)
{struct bus_attribute *bus_attr = to_bus_attr(attr);struct subsys_private *subsys_priv = to_subsys_private(kobj);ssize_t ret = 0;if (bus_attr->show)ret = bus_attr->show(subsys_priv->bus, buf); // #3return ret;
}static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,const char *buf, size_t count)
{struct bus_attribute *bus_attr = to_bus_attr(attr);struct subsys_private *subsys_priv = to_subsys_private(kobj);ssize_t ret = 0;if (bus_attr->store)ret = bus_attr->store(subsys_priv->bus, buf, count);return ret;
}
2.3 bus_attribute
struct bus_attribute {struct attribute attr;ssize_t (*show)(struct bus_type *bus, char *buf);ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
};static ssize_t drivers_autoprobe_show(struct bus_type *bus, char *buf)
{return sysfs_emit(buf, "%d\n", bus->p->drivers_autoprobe);
}static ssize_t drivers_autoprobe_store(struct bus_type *bus,const char *buf, size_t count)
{if (buf[0] == '0')bus->p->drivers_autoprobe = 0;elsebus->p->drivers_autoprobe = 1;return count;
}static BUS_ATTR_RW(drivers_autoprobe);
ATTR 宏展开:
#define BUS_ATTR_RW(_name) \struct bus_attribute bus_attr_##_name = __ATTR_RW(_name)
#define BUS_ATTR_RO(_name) \struct bus_attribute bus_attr_##_name = __ATTR_RO(_name)
#define BUS_ATTR_WO(_name) \struct bus_attribute bus_attr_##_name = __ATTR_WO(_name)#define __ATTR(_name, _mode, _show, _store) { \.attr = {.name = __stringify(_name), \.mode = VERIFY_OCTAL_PERMISSIONS(_mode) }, \.show = _show, \.store = _store, \
}#define __ATTR_PREALLOC(_name, _mode, _show, _store) { \.attr = {.name = __stringify(_name), \.mode = SYSFS_PREALLOC | VERIFY_OCTAL_PERMISSIONS(_mode) },\.show = _show, \.store = _store, \
}#define __ATTR_RO(_name) { \.attr = { .name = __stringify(_name), .mode = 0444 }, \.show = _name##_show, \
}#define __ATTR_RO_MODE(_name, _mode) { \.attr = { .name = __stringify(_name), \.mode = VERIFY_OCTAL_PERMISSIONS(_mode) }, \.show = _name##_show, \
}#define __ATTR_RW_MODE(_name, _mode) { \.attr = { .name = __stringify(_name), \.mode = VERIFY_OCTAL_PERMISSIONS(_mode) }, \.show = _name##_show, \.store = _name##_store, \
}#define __ATTR_WO(_name) { \.attr = { .name = __stringify(_name), .mode = 0200 }, \.store = _name##_store, \
}#define __ATTR_RW(_name) __ATTR(_name, 0644, _name##_show, _name##_store)
3,应用程序read sysfs属性文件是如何调用到属性文件的show函数的
3.1 cat sysfs节点流程
SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count) //fs/read_write.c
----ksys_read(fd, buf, count);
--------vfs_read(f.file, buf, count, ppos);
------------.read_iter = kernfs_fop_read_iter //fs/kernfs/file.c
----------------seq_read_iter(iocb, iter);
--------------------struct seq_file *m = iocb->ki_filp->private_data;
--------------------p = m->op->start(m, &m->index);
--------------------m->op->show(m, p);
------------------------.show = kernfs_seq_show
----------------------------of->kn->attr.ops->seq_show(sf, v);
--------------------------------.seq_show = sysfs_kf_seq_show,
------------------------------------const struct sysfs_ops *ops = sysfs_file_ops(of->kn);
----------------------------------------ops->show(kobj, of->kn->priv, buf);
--------------------------------------------.show = bus_attr_show, //msm_kernel\drivers\base\bus.c
------------------------------------------------struct bus_attribute *bus_attr = to_bus_attr(attr);
------------------------------------------------bus_attr->show(subsys_priv->bus, buf);
----------------------------------------------------drivers_autoprobe_show(struct bus_type *bus, char *buf)msm_kernel\fs\kernfs\file.c
const struct file_operations kernfs_file_fops = {.read_iter = kernfs_fop_read_iter,.write_iter = kernfs_fop_write_iter,.llseek = generic_file_llseek,.mmap = kernfs_fop_mmap,.open = kernfs_fop_open,.release = kernfs_fop_release,.poll = kernfs_fop_poll,.fsync = noop_fsync,.splice_read = generic_file_splice_read,.splice_write = iter_file_splice_write,
};msm_kernel\fs\kernfs\file.c
static const struct seq_operations kernfs_seq_ops = {.start = kernfs_seq_start,.next = kernfs_seq_next,.stop = kernfs_seq_stop,.show = kernfs_seq_show,
};msm_kernel\fs\sysfs\file.c
static const struct kernfs_ops sysfs_file_kfops_ro = {.seq_show = sysfs_kf_seq_show,
};
3.2 dump log
eg:
cat /sys/bus/i2c/drivers_autoprobe10-18 05:40:09.284 8993 8993 I Call trace:
10-18 05:40:09.284 8993 8993 I : dump_backtrace.cfi_jt+0x0/0x8
10-18 05:40:09.284 8993 8993 I : dump_stack_lvl+0xe4/0x180
10-18 05:40:09.284 8993 8993 I : drivers_autoprobe_show+0x28/0x5c
10-18 05:40:09.285 8993 8993 I : bus_attr_show+0x40/0x8c
10-18 05:40:09.285 8993 8993 I : sysfs_kf_seq_show+0xbc/0x158
10-18 05:40:09.285 8993 8993 I : kernfs_seq_show+0x54/0x9c
10-18 05:40:09.285 8993 8993 I : seq_read_iter+0x174/0x698
10-18 05:40:09.285 8993 8993 I : kernfs_fop_read_iter+0x70/0x2dc
10-18 05:40:09.285 8993 8993 I : vfs_read+0x2ec/0x368
10-18 05:40:09.285 8993 8993 I : ksys_read+0x7c/0xf0
10-18 05:40:09.285 8993 8993 I : __arm64_sys_read+0x20/0x30
10-18 05:40:09.285 8993 8993 I : el0_svc_common+0xd8/0x27c
10-18 05:40:09.285 8993 8993 I : el0_svc+0x38/0x9c
10-18 05:40:09.285 8993 8993 I : el0_sync_handler+0x8c/0xf0
10-18 05:40:09.285 8993 8993 I : el0_sync+0x1b4/0x1c0
3.3 关键代码解析
1)当user space read drivers_autoprobe节点的时候,会触发系统调用
SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
{return ksys_read(fd, buf, count);
}
然后会由VFS转到 file_operations 的read操作。
2)在kernfs_fop_open函数中,initialize sequential file
static int kernfs_fop_open(struct inode *inode, struct file *file)
{struct kernfs_node *kn = inode->i_private;struct kernfs_root *root = kernfs_root(kn);const struct kernfs_ops *ops;struct kernfs_open_file *of;bool has_read, has_write, has_mmap;int error = -EACCES;if (!kernfs_get_active(kn))return -ENODEV;ops = kernfs_ops(kn);has_read = ops->seq_show || ops->read || ops->mmap;has_write = ops->write || ops->mmap;has_mmap = ops->mmap;/* see the flag definition for details */if (root->flags & KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK) {if ((file->f_mode & FMODE_WRITE) &&(!(inode->i_mode & S_IWUGO) || !has_write))goto err_out;if ((file->f_mode & FMODE_READ) &&(!(inode->i_mode & S_IRUGO) || !has_read))goto err_out;}... .../** Always instantiate seq_file even if read access doesn't use* seq_file or is not requested. This unifies private data access* and readable regular files are the vast majority anyway.*/if (ops->seq_show)error = seq_open(file, &kernfs_seq_ops); //initialize sequential file, sets @file, associating it with a sequence described by @opelseerror = seq_open(file, NULL);if (error)goto err_free;of->seq_file = file->private_data;of->seq_file->private = of;/* seq_file clears PWRITE unconditionally, restore it if WRITE */if (file->f_mode & FMODE_WRITE)file->f_mode |= FMODE_PWRITE;... ...
}
3)
static int kernfs_seq_show(struct seq_file *sf, void *v)
{struct kernfs_open_file *of = sf->private;of->event = atomic_read(&of->kn->attr.open->event);return of->kn->attr.ops->seq_show(sf, v); //在attribute节点创建的过程中赋值,上文#1的位置
}
4)可供选择的kernfs_ops
static const struct kernfs_ops sysfs_file_kfops_empty = {
};static const struct kernfs_ops sysfs_file_kfops_ro = {.seq_show = sysfs_kf_seq_show,
};static const struct kernfs_ops sysfs_file_kfops_wo = {.write = sysfs_kf_write,
};static const struct kernfs_ops sysfs_file_kfops_rw = {.seq_show = sysfs_kf_seq_show,.write = sysfs_kf_write,
};static const struct kernfs_ops sysfs_prealloc_kfops_ro = {.read = sysfs_kf_read,.prealloc = true,
};static const struct kernfs_ops sysfs_prealloc_kfops_wo = {.write = sysfs_kf_write,.prealloc = true,
};static const struct kernfs_ops sysfs_prealloc_kfops_rw = {.read = sysfs_kf_read,.write = sysfs_kf_write,.prealloc = true,
};
5)找到 sysfs_ops
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;/* acquire buffer and ensure that it's >= PAGE_SIZE and clear */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.*/if (ops->show) {count = ops->show(kobj, of->kn->priv, buf); //上文#2处定义了show函数if (count < 0)return count;}
kobj->ktype->sysfs_ops :
/*
* Determine ktype->sysfs_ops for the given kernfs_node. This function
* must be called while holding an active reference.
*/
static const struct sysfs_ops *sysfs_file_ops(struct kernfs_node *kn)
{struct kobject *kobj = kn->parent->priv;if (kn->flags & KERNFS_LOCKDEP)lockdep_assert_held(kn);return kobj->ktype ? kobj->ktype->sysfs_ops : NULL;
}
6)
终于在上文#3处调用到了drivers_autoprobe的show函数。
4,bus_attribute/device_attribute/driver_attribute
所有需要使用attribute的模块,都不会直接定义struct attribute变量,而是通过一个自定义的数据结构,该数据结构的一个成员是struct attribute类型的变量,并提供show和store回调函数。然后在该模块ktype所对应的struct sysfs_ops变量中,实现该本模块整体的show和store函数,并在被调用时,转接到自定义数据结构(struct class_attribute)中的show和store函数中。这样,每个atrribute文件,实际上对应到一个自定义数据结构变量中了。
4.1 bus_attribute
struct bus_attribute {struct attribute attr;ssize_t (*show)(struct bus_type *bus, char *buf);ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
};
4.2 device_attribute
/* interface for exporting device attributes */
struct device_attribute {struct attribute attr;ssize_t (*show)(struct device *dev, struct device_attribute *attr,char *buf);ssize_t (*store)(struct device *dev, struct device_attribute *attr,const char *buf, size_t count);
};//device_attribute 节点创建举例
static ssize_t map_seg7_show(struct device *dev,struct device_attribute *attr,char *buf)
{memcpy(buf, &txx9_seg7map, sizeof(txx9_seg7map));return sizeof(txx9_seg7map);
}static ssize_t map_seg7_store(struct device *dev,struct device_attribute *attr,const char *buf, size_t size)
{if (size != sizeof(txx9_seg7map))return -EINVAL;memcpy(&txx9_seg7map, buf, size);return size;
}
static DEVICE_ATTR(map_seg7, 0600, map_seg7_show, map_seg7_store);error = device_create_file(tx_7segled_subsys.dev_root, &dev_attr_map_seg7);
4.3 driver_attribute
/* sysfs interface for exporting driver attributes */
struct driver_attribute {struct attribute attr;ssize_t (*show)(struct device_driver *driver, char *buf);ssize_t (*store)(struct device_driver *driver, const char *buf,size_t count);
};//driver_attribute 节点创建举例
static ssize_t new_id_show(struct device_driver *driver, char *buf)
{struct usb_driver *usb_drv = to_usb_driver(driver);return usb_show_dynids(&usb_drv->dynids, buf);
}static ssize_t new_id_store(struct device_driver *driver,const char *buf, size_t count)
{struct usb_driver *usb_drv = to_usb_driver(driver);return usb_store_new_id(&usb_drv->dynids, usb_drv->id_table, driver, buf, count);
}
static DRIVER_ATTR_RW(new_id);error = driver_create_file(&usb_drv->drvwrap.driver,&driver_attr_new_id);
参考链接:
Linux kernel sysfs device_attribute节点的创建和读写分析_如何在kernel中读取节点-CSDN博客
Linux设备模型(4)_sysfs
这篇关于Linux设备模型(八) - sysfs的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!