linux：/sys/xxx 读写节点使用方法

最新推荐文章于 2024-04-30 16:57:57 发布
最新推荐文章于 2024-04-30 16:57:57 发布
阅读量2.2k 收藏 7
点赞数 1
分类专栏： RK3399 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27809619/article/details/121117720
版权

公众号

欢迎扫码关注本人微信公众号：公众号上分享更多嵌入式知识和资料，分享个人学习嵌入式的心得体会。欢迎大家一起来玩呀。
在这里插入图片描述

/sys/xxx读写节点

在 /sys 中生成节点，用于应用层从驱动中获取数据，或者将数据写到驱动层中，比如点亮LED灯或者获取GPIO的值的高低电平。

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

#include <linux/delay.h>
#include <linux/err.h>

#include <linux/of_gpio.h>
#include <linux/gpio.h>

#include <linux/platform_device.h>
#include <asm/irq.h>
#include <asm/io.h>

#include <linux/delay.h>

#include <dt-bindings/gpio/gpio.h>

#ifdef CONFIG_OF
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#endif

struct taishan_gpio_dev{
     struct platform_device *pdev;

     int power_switch_gpio;           //电源关断器控制IO
     int power_switch_gpio_direction;
     
     int out_switch_gpio;            //输出短路器控制IO
     int out_switch_gpio_direction; 
     
     int relays1_gpio;               //继电器输出控制IO
     int relays1_gpio_direction;
     int relays2_gpio;
     int relays2_gpio_direction;
     int relays3_gpio;
     int relays3_gpio_direction;
     int relays4_gpio;
     int relays4_gpio_direction;

     int flame_sensor_gpio;
     int smoke_sensor_gpio;
};

static struct taishan_gpio_dev *ptaishan_dev = NULL;

static ssize_t power_switch_gpio_store(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count) {
              
    struct taishan_gpio_dev *pdata = ptaishan_dev;            
    if (buf[0] == '0') {
        pdata->power_switch_gpio_direction = 0;
        gpio_direction_output(pdata->power_switch_gpio, pdata->power_switch_gpio_direction);
    }else if (buf[0] == '1') {
        pdata->power_switch_gpio_direction = 1;
        gpio_direction_output(pdata->power_switch_gpio, pdata->power_switch_gpio_direction);
    }    

    printk(KERN_ERR "power_switch_gpio_store %d \n",pdata->power_switch_gpio_direction);   
    return count;
}

static ssize_t out_switch_gpio_store(struct device *dev, struct device_attribute *attr,
            const char *buf, size_t count) {
            
    struct taishan_gpio_dev *pdata = ptaishan_dev;            
    if (buf[0] == '0') {
        pdata->out_switch_gpio_direction = 0;
        gpio_direction_output(pdata->out_switch_gpio, pdata->out_switch_gpio_direction);
    }else if (buf[0] == '1') {
        pdata->out_switch_gpio_direction = 1;
        gpio_direction_output(pdata->out_switch_gpio, pdata->out_switch_gpio_direction);
    }    

    printk(KERN_ERR "out_switch_gpio_store %d \n",pdata->out_switch_gpio_direction);   
    return count;
}

static ssize_t relays1_gpio_store(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count) {
              
    struct taishan_gpio_dev *pdata = ptaishan_dev;            
    if (buf[0] == '0') {
        pdata->relays1_gpio_direction = 0;
        gpio_direction_output(pdata->relays1_gpio, pdata->relays1_gpio_direction);
    }else if (buf[0] == '1') {
        pdata->relays1_gpio_direction = 1;
        gpio_direction_output(pdata->relays1_gpio, pdata->relays1_gpio_direction);
    }    

    printk(KERN_ERR "relays1_gpio_store %d \n",pdata->relays1_gpio_direction);   
    return count;
}

static ssize_t relays2_gpio_store(struct device *dev, struct device_attribute *attr,
            const char *buf, size_t count) {
            
    struct taishan_gpio_dev *pdata = ptaishan_dev;            
    if (buf[0] == '0') {
        pdata->relays2_gpio_direction = 0;
        gpio_direction_output(pdata->relays2_gpio, pdata->relays2_gpio_direction);
    }else if (buf[0] == '1') {
        pdata->relays2_gpio_direction = 1;
        gpio_direction_output(pdata->relays2_gpio, pdata->relays2_gpio_direction);
    }    

    printk(KERN_ERR "relays2_gpio_store %d \n",pdata->out_switch_gpio_direction);   
    return count;
}


static ssize_t relays3_gpio_store(struct device *dev, struct device_attribute *attr,
             const char *buf, size_t count) {
             
    struct taishan_gpio_dev *pdata = ptaishan_dev;            
    if (buf[0] == '0') {
        pdata->relays3_gpio_direction = 0;
        gpio_direction_output(pdata->relays3_gpio, pdata->relays3_gpio_direction);
    }else if (buf[0] == '1') {
        pdata->relays3_gpio_direction = 1;
        gpio_direction_output(pdata->relays3_gpio, pdata->relays3_gpio_direction);
    }    

    printk(KERN_ERR "relays3_gpio_store %d \n",pdata->relays3_gpio_direction);   
    return count;
}


static ssize_t relays4_gpio_store(struct device *dev, struct device_attribute *attr,
             const char *buf, size_t count) {
             
    struct taishan_gpio_dev *pdata = ptaishan_dev;            
    if (buf[0] == '0') {
        pdata->relays4_gpio_direction = 0;
        gpio_direction_output(pdata->relays4_gpio, pdata->relays4_gpio_direction);
    }else if (buf[0] == '1') {
        pdata->relays4_gpio_direction = 1;
        gpio_direction_output(pdata->relays4_gpio, pdata->relays4_gpio_direction);
    }    

    printk(KERN_ERR "relays4_gpio_store %d \n",pdata->relays4_gpio_direction);   
    return count;
}

static ssize_t flame_sensor_gpio_show(struct device *dev, struct device_attribute *attr, char *buf) {
    struct taishan_gpio_dev *pdata = ptaishan_dev; 
    int gpio_value = 0;

    gpio_value = gpio_get_value(pdata->flame_sensor_gpio);
    
    return snprintf(buf, PAGE_SIZE, "%d\n",
			gpio_value);
}

static ssize_t smoke_sensor_gpio_show(struct device *dev, struct device_attribute *attr, char *buf) {
    struct taishan_gpio_dev *pdata = ptaishan_dev; 
    int gpio_value = 0;

    gpio_value = gpio_get_value(pdata->smoke_sensor_gpio);
    
    return snprintf(buf, PAGE_SIZE, "%d\n",
			gpio_value);
}



static struct device_attribute taishan_gpio1_attr[] = {
    __ATTR(power_switch_gpio, 0664, NULL, power_switch_gpio_store),
    
	__ATTR(out_switch_gpio, 0664, NULL,   out_switch_gpio_store),
	
	__ATTR(relays1_gpio, 0664, NULL,      relays1_gpio_store),
	__ATTR(relays2_gpio, 0664, NULL,      relays2_gpio_store),
	__ATTR(relays3_gpio, 0664, NULL,      relays3_gpio_store),
	__ATTR(relays4_gpio, 0664, NULL,      relays4_gpio_store),
	
	__ATTR(flame_sensor_gpio, 0664, flame_sensor_gpio_show,NULL),
	__ATTR(smoke_sensor_gpio, 0664, smoke_sensor_gpio_show,NULL),
};

static void taishan_gpio_init_sysfs(struct device *dev)
{
	int i, ret;
	for (i = 0; i < ARRAY_SIZE(taishan_gpio1_attr); i++) {
		ret = sysfs_create_file(&dev->kobj,
					&taishan_gpio1_attr[i].attr);
		if (ret)
			dev_err(dev, "create charger node(%s) error\n",
				taishan_gpio1_attr[i].attr.name);
	}
}

static int taishan_gpio_dt(struct taishan_gpio_dev *pdata) {
    int gpio;
    int ret;
    enum of_gpio_flags flags;
    struct device *dev = &pdata->pdev->dev;
    struct device_node *node = dev->of_node;
    
    gpio = of_get_named_gpio_flags(node, "power_switch_gpio", 0, &flags);
	if (gpio_is_valid(gpio))
	{
	    pdata->power_switch_gpio           = gpio;
	    pdata->power_switch_gpio_direction = (flags == GPIO_ACTIVE_HIGH)? 1:0;	    
	    printk(KERN_ERR"power_switch_gpio: %d\n", pdata->power_switch_gpio);
	    
	    ret = devm_gpio_request(dev,gpio, "power_switch_gpio");
	    if (ret) {
			printk("Failed to get power_switch_gpio gpio.\n");
		}
    }

    gpio = of_get_named_gpio_flags(node, "out_switch_gpio", 0, &flags);
	if (gpio_is_valid(gpio))
	{
	    pdata->out_switch_gpio           = gpio;
	    pdata->out_switch_gpio_direction = (flags == GPIO_ACTIVE_HIGH)? 1:0;	    
	    printk(KERN_ERR"out_switch_gpio: %d\n", pdata->out_switch_gpio);
	    
	    ret = devm_gpio_request(dev,gpio, "out_switch_gpio");
	    if (ret) {
			printk("Failed to get out_switch_gpio gpio.\n");
		}
    }

    gpio = of_get_named_gpio_flags(node, "relays1_gpio", 0, &flags);
	if (gpio_is_valid(gpio))
	{
	    pdata->relays1_gpio           = gpio;
	    pdata->relays1_gpio_direction = (flags == GPIO_ACTIVE_HIGH)? 1:0;	    
	    printk(KERN_ERR"relays1_gpio: %d\n", pdata->relays1_gpio);
	    
	    ret = devm_gpio_request(dev,gpio, "relays1_gpio");
	    if (ret) {
			printk("Failed to get relays1_gpio gpio.\n");
		}
    }


    gpio = of_get_named_gpio_flags(node, "relays2_gpio", 0, &flags);
	if (gpio_is_valid(gpio))
	{
	    pdata->relays2_gpio           = gpio;
	    pdata->relays2_gpio_direction = (flags == GPIO_ACTIVE_HIGH)? 1:0;	    
	    printk(KERN_ERR"relays2_gpio: %d\n", pdata->relays2_gpio);
	    
	    ret = devm_gpio_request(dev,gpio, "relays2_gpio");
	    if (ret) {
			printk("Failed to get relays2_gpio gpio.\n");
		}
    }

    gpio = of_get_named_gpio_flags(node, "relays3_gpio", 0, &flags);
	if (gpio_is_valid(gpio))
	{
	    pdata->relays3_gpio           = gpio;
	    pdata->relays3_gpio_direction = (flags == GPIO_ACTIVE_HIGH)? 1:0;	    
	    printk(KERN_ERR"relays3_gpio: %d\n", pdata->relays3_gpio);
	    
	    ret = devm_gpio_request(dev,gpio, "relays3_gpio");
	    if (ret) {
			printk("Failed to get relays3_gpio gpio.\n");
		}
    }


    gpio = of_get_named_gpio_flags(node, "relays4_gpio", 0, &flags);
	if (gpio_is_valid(gpio))
	{
	    pdata->relays4_gpio           = gpio;
	    pdata->relays4_gpio_direction = (flags == GPIO_ACTIVE_HIGH)? 1:0;	    
	    printk(KERN_ERR"relays4_gpio: %d\n", pdata->relays4_gpio);
	    
	    ret = devm_gpio_request(dev,gpio, "relays4_gpio");
	    if (ret) {
			printk("Failed to get relays4_gpio gpio.\n");
		}
    }


    gpio = of_get_named_gpio_flags(node, "flame_sensor_gpio", 0, &flags);
	if (gpio_is_valid(gpio))
	{
	    pdata->flame_sensor_gpio        = gpio;
	    printk(KERN_ERR"flame_sensor_gpio: %d\n", pdata->flame_sensor_gpio);
	    
	    ret = devm_gpio_request(dev,gpio, "flame_sensor_gpio");
	    if (ret) {
			printk("Failed to get flame_sensor_gpio gpio.\n");
		}

		ret = gpio_direction_input(gpio);
		if (ret) {
			printk("Failed to set flame_sensor_gpio gpio.\n");
		}
    }

    gpio = of_get_named_gpio_flags(node, "smoke_sensor_gpio", 0, &flags);
	if (gpio_is_valid(gpio))
	{
	    pdata->smoke_sensor_gpio        = gpio;
	    printk(KERN_ERR"smoke_sensor_gpio: %d\n", pdata->smoke_sensor_gpio);
	    
	    ret = devm_gpio_request(dev,gpio, "smoke_sensor_gpio");
	    if (ret) {
			printk("Failed to get smoke_sensor_gpio gpio.\n");
		}

		ret = gpio_direction_input(gpio);
		if (ret) {
			printk("Failed to set flame_sensor_gpio gpio.\n");
		}
    }

    return 0;
}

static void taishan_gpio_set_default(struct taishan_gpio_dev *pdata) {

    if (pdata->power_switch_gpio) {
        gpio_direction_output(pdata->power_switch_gpio, pdata->power_switch_gpio_direction);
    }

    if (pdata->out_switch_gpio) {
        gpio_direction_output(pdata->out_switch_gpio, pdata->out_switch_gpio_direction);
    }

    if (pdata->relays1_gpio) {
        gpio_direction_output(pdata->relays1_gpio, pdata->relays1_gpio_direction);
    }

    if (pdata->relays2_gpio) {
        gpio_direction_output(pdata->relays2_gpio, pdata->relays2_gpio_direction);
    }

    if (pdata->relays3_gpio) {
        gpio_direction_output(pdata->relays3_gpio, pdata->relays3_gpio_direction);
    }

    if (pdata->relays4_gpio) {
        gpio_direction_output(pdata->relays4_gpio, pdata->relays4_gpio_direction);
    }
}


static int taishan_gpio_probe(struct platform_device *pdev) {
     printk(KERN_ALERT "%s \n",__func__);      
     ptaishan_dev = kmalloc(sizeof(struct taishan_gpio_dev), GFP_KERNEL);
     if (ptaishan_dev == NULL) {
        printk(KERN_ERR"kmalloc struct taishan_gpio_dev err \n");
        return -ENOMEM;
     }

     memset(ptaishan_dev, 0, sizeof(struct taishan_gpio_dev));

     ptaishan_dev->pdev = pdev;

     taishan_gpio_dt(ptaishan_dev);
     taishan_gpio_set_default(ptaishan_dev);
     taishan_gpio_init_sysfs(&ptaishan_dev->pdev->dev);
     
     printk(KERN_ALERT "%s end !!!!!\n",__func__);
     return 0;
}



static struct of_device_id taishan_gpio_of_match[] = {
	{ .compatible = "taishan_gpio" },
	{ }
};


static struct platform_driver taishan_gpio_driver = {
	.driver		= {
		.name		= "taishan_gpio",
		.of_match_table	= of_match_ptr(taishan_gpio_of_match),
	},
	.probe		= taishan_gpio_probe,
};


module_platform_driver(taishan_gpio_driver);

MODULE_AUTHOR("FenDa Ltd System Application Group");
MODULE_DESCRIPTION("taishan gpio driver");
MODULE_LICENSE("GPL");

应用层节点生成sys/xxxxx

在/sys/devices/platform/taishan-gpio 路径下可以看到会生成如下的节点：
power_switch_gpio
out_switch_gpio
relays1_gpio
relays2_gpio
relays3_gpio
relays4_gpio
flame_sensor_gpio
smoke_sensor_gpio
每一个节点代表一个GPIO引脚

rk3399:/sys/devices/platform/taishan-gpio # ls -la
total 0
drwxr-xr-x   3 root root    0 2013-01-18 08:50 .
drwxr-xr-x 142 root root    0 2013-01-18 08:50 ..
lrwxrwxrwx   1 root root    0 2021-10-26 06:57 driver -> ../../../bus/platform/drivers/taishan_gpio
-rw-r--r--   1 root root 4096 2021-10-26 06:57 driver_override
-rw-rw-r--   1 root root 4096 2021-10-26 06:57 flame_sensor_gpio
-r--r--r--   1 root root 4096 2021-10-26 06:57 modalias
lrwxrwxrwx   1 root root    0 2021-10-26 06:57 of_node -> ../../../firmware/devicetree/base/taishan-gpio
-rw-rw-r--   1 root root 4096 2021-10-26 06:57 out_switch_gpio
drwxr-xr-x   2 root root    0 2013-01-18 08:50 power
-rw-rw-r--   1 root root 4096 2021-10-26 06:57 power_switch_gpio
-rw-rw-r--   1 root root 4096 2021-10-26 06:57 relays1_gpio
-rw-rw-r--   1 root root 4096 2021-10-26 06:57 relays2_gpio
-rw-rw-r--   1 root root 4096 2021-10-26 06:57 relays3_gpio
-rw-rw-r--   1 root root 4096 2021-10-26 06:57 relays4_gpio
-rw-rw-r--   1 root root 4096 2021-10-26 06:57 smoke_sensor_gpio
lrwxrwxrwx   1 root root    0 2021-10-26 06:57 subsystem -> ../../../bus/platform
-rw-r--r--   1 root root 4096 2013-01-18 08:50 uevent

应用层使用方法

使用cat命令 cat节点可以获取GPIO的值，下面的例子中获取到1，表示高电平
rk3399:/sys/devices/platform/taishan-gpio # cat smoke_sensor_gpio
1
使用echo命令给节点写入1，让relays1_gpio这个gpio输出高电平
rk3399:/sys/devices/platform/taishan-gpio # echo 1 > relays1_gpio
嵌入式知识大讲堂
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux 读sysfs文件,Linux文件系统之sysfs
weixin_28278377的博客
04-28 517
上图表示的是一个kobject的层次结构.dentry的d_fsdata字段指定该结点所表示的sysfs_dirent.sysfs_dirent.s_parent表示它的父kobject. sysfs_dirent.s_sibling表示它的兄弟结点. sysfs_dirent.s_dir.children表示它所属的子节点.从上图可知.如果要遍历一个结点下面的子结点,只需要找到sysfs_dir...
Linux驱动直接读写节点的方法总结
IMGDX的博客
05-26 1372
本文主要描述Linux内核在使用过程中需要直接通过命令读写某个变量的值或者执行某个函数的方法，实现用户空间与内核空间的直接交互。
2024年Linux最全Linux下 sys目录介绍(1)
最新发布
2301_79054215的博客
04-30 563
这是内核设备按照总线类型分层放置的目录结构，/sys/devices中的所有设备都是连接于某种总线之下的，bus子目录下的每种具体总线之下可以找到每个具体设备的符号链接，一般来说每个子目录(总线类型)下包含两个子目录，一个是 devices，另一个是drivers；该目录下存放主次设备号文件，其中分成字符设备、块设备的主次设备号码(major:minor)组成的文件名，该文件是链接文件并且链接到其真实的设备(/sys/devices)。每个设备类型子目录下都是这种设备类型的各种具体设备的。
Linux的c编程-文件节点的打开与读写操作
技术交流
05-12 3298
1、open(打开文件) 相关函数 read，write，fcntl，close，link，stat，umask，unlink，fopen 表头文件 #include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> 定义函数 int open( const char * pathname, int flags); int open( const char * pathname,int flags, mode_t mo
Linux设备属性节点读写操作----cat 、echo
路过的熊的博客
02-12 1643
1. 具体实现代码如下： // drv_attr.c #include <linux/module.h> #include <linux/init.h> #include <linux/platform_device.h> #include <linux/gpio.h> #include <linux/delay.h> #include <linux/regulator/consumer.h> #include <sound/so
linux 读取设备节点值
embedwince的专栏
12-10 2956
int HalValueLoad(void) {  int fdd;     char rbuf[1]={'\0'};     char wbuf1[1]={'1'}; //字符'1'的ASCII码是49     char wbuf2[1]={'0'}; //字符'0'的ASCII码是48     static uint8 uHalValue = 0;    fdd= open(
2021-03-02 Linux C语言读写节点代码-读写背光值brightness为例
海月汐辰
03-02 1510
Linux C语言读写节点代码-读写背光值brightness为例 一、adb 读写背光节点 /sys/class/backlight/backlight/brightness 二、C语言读写该节点代码。 static int write_int(char const *path, int value) { int fd; static int already_warned; already_warned = 0; LO...
程序员需要经常刷题吗-glide:https://github.com/Masterminds/glide
07-01
需要程序员经常刷题吗回购镜像来自 ...golang.org/x/sys/unix ，使用 glide 应该是： 滑翔镜组 滑翔获取 golang.org/x/sys/unix 但结果是glide会将 sys 目录导出到 golang.org/x/sys/unix。 我们会看到go
Linux下core文件的使用方法详解
01-10
通常在 Linux 下遇到程序异常退出或者中止，我们都会使用 core 文件进行分析，其中包含了程序运行时的内存，寄存器，堆栈指针等信息，格式为 ELF ，可以理解是程序工作当前状态转储成一个文件，通过工具分析这个文件...
golang.org/x/sys/windows
07-19
golang.org/x/sys/windows
Linux_leds.rar_Linux/Unix编程
09-20
例如，一个名为"led0"的LED设备会有一个"/sys/class/leds/led0"的目录，包含各种控制LED状态的文件，如`brightness`（亮度）、`trigger`（触发器）等。用户可以通过读写这些文件来改变LED的状态。 三、字符设备文件...
Linux动态启用/禁用超线程技术的方法详解
09-14
这个脚本首先定义了一个变量`HYPERTHREADING`来控制是否启用超线程，然后通过循环遍历`/sys/devices/system/cpu/cpuX`目录下的所有CPU节点，读取`thread_siblings_list`文件以确定逻辑核心的关系。如果当前CPUID与`...
linux 脚本给设备节点权限,[Linux] I2C设备读写及文件节点创建
weixin_30051655的博客
05-07 642
Linux Kernel Version：3.0.35Platform：Freescale DSA2L通过I2C读取VGA屏的EDID信息(主要是分辨率)，解析后喂给CH7036芯片(LVDS转VGA，DVI，HDMI芯片)，提供文件节点给User Space。代码流程由于EDID协议规定I2C的读取Slave地址为0x50，所以先添加Device注册代码：i2c.h#define I2C_BOA...
Linux kernel sysfs device_attribute节点的创建和读写分析
zsyf33078的专栏
03-25 2163
sysfs device_attribute节点的创建和读写分析 内核版本：5.4。
linux 驱动 节点随便目录,Linux驱动与设备节点简介 & Android内核与Linux内核的区别...
weixin_29161719的博客
04-29 252
一、驱动驱动是内核的一部分，作为直接访问物理硬件的一个软件层，用于应用程序与物理硬件设备通信。内核包含多种驱动，如WIFI、USB、Audio、蓝牙、相机、显示驱动。二、设备(1)设备驱动程序三类：字符设备驱动程序、块设备驱动程序、网络设备驱动程序；(2)对应Linux三类设备：字符设备、块设备、网络设备；(3)常见字符设备：鼠标、键盘、串口、控制台等；(4)常见块设备：各种硬盘、flash磁盘、...
RK3568平台 sys虚拟文件系统添加节点_ch423 driver
2401_83641443的博客
04-05 347
2008年发布的EXT4是EXT系列中最新版本的文件系统。在保持向前兼容性的同时，它引入了许多新特性，如支持更大的文件和分区、更快的读写速度以及更好地处理碎片等特点。：EXT系列文件系统采用日志技术来防止出现文件系统损坏或异常情况时数据丢失或者损坏，保证数据的完整性和一致性。**5. 兼容性：**EXT文件系统被广泛用于Linux操作系统中，并且可以在其他类Unix系统中进行兼容和交互操作。
记录Sys节点创建的总结
weixin_44560716的博客
03-07 524
然后cd /sys/devices/virtual/mytest_class/mytest_device下出现direction文件。// 出现在/sys/devices/platform/平台设备名/demo。} //在mytest_device设备目录下创建一个my_device_test属性文件。
Linux驱动开发：7、设备-自动创建设备节点
遇雪长安的博客
10-18 7046
在前面两小节中，我们学习到了设备注册。可以将一个设备驱动注册到内核中。设备注册完成后，还需要通过mknod指令在用户空间中手动创建该驱动对应的设备节点。该命令在执行是不会检查参数的合法性。也不会检查设备驱动是否存在。如果系统中所有的驱动都通过该方法创建设备节点，就会出现一个问题。当设备未接入时，就可能会出现很多的设备节点。实际上Linux内核为我们提供了一组函数，可以在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点，当然前提条件是用户空间移植了udev。
linux sysfs open,sysfs文件系统之读写文件
weixin_33598481的博客
05-25 704
上面的文章分析了sysfs中文件的创建过程,既然文件已经建立起来了,读写它才是我们最终的目的撒,本文就来看看sysfs是咋个通过VFS接口读写sysfs下的文件.sysfs属性文件操作方法在函数sysfs_init_inode()中初始化了sysfs属性文件的操作方法为sysfs_file_operations,下面就拿属性文件操作方法分析sysfs文件读写流程.const struct file...
root@DeltaOS:/sys/kernel/debug/dynamic_debug/control 怎么使用的
04-11
在Linux系统中/sys/kernel/debug/dynamic_debug/control是一个于动态调试的接口文件。它可以用来控制内核模块的调试信息输出级别和过滤条件。下面是使用该接口的一步骤： 1. 打开终端并root权限登录到系统。 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值