韦东山Linux驱动入门实验班(1)hello驱动

2023年 8月 7日 35.6k 0

前言

(1)学习韦东山老师的Linux,因为他讲的很精简,以至于很多人听不懂。接下来我讲介绍韦东山老师的驱动实验班的第一个Hello程序。

(2)注意,请先学习完视频再来看这个教程!本文仅供入门学习!如需深入,请搜索其他博客!

(3)gitee仓库;GitHub仓库;

代码

先上代码,代码增加了注释。如果仅看注释就能够理解的话,就没必要再花时间往下看了。具体代码在我仓库里面。

驱动代码

/* 说明 : 
 	*1,本代码是学习韦东山老师的驱动入门视频所写,增加了注释。
 	*2,采用的是UTF-8编码格式,如果注释是乱码,需要改一下。
 	*3,这是驱动层代码
 * 作者 : CSDN风正豪
*/



#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

static int major; //主设备号,用于最后的驱动卸载

/*
 *传入参数 :
	 *node :
	 *filp :
 *返回参数 : 如果成功返回0
*/
static int hello_open (struct inode *node, struct file *filp)
{
	/*__FILE__ :表示文件
	 *__FUNCTION__ :当前函数名
	 *__LINE__ :在文件的哪一行
	*/
    printk("%s %s %dn",__FILE__,__FUNCTION__, __LINE__);
    return 0;
}

/*
 *传入参数 :
	 *filp :要读的文件
	 *buf :读的数据放在哪里
	 *size :读多大数据
	 *offset :偏移值(一般不用)
 *返回参数 :读到的数据长度	
*/
static	ssize_t hello_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
	/*__FILE__ :表示文件
	 *__FUNCTION__ :当前函数名
	 *__LINE__ :在文件的哪一行
	*/
    printk("%s %s %dn",__FILE__,__FUNCTION__, __LINE__);
    return size;
}

/*
 *传入参数 :
	 *filp :要写的文件
	 *buf :写入的数据来自于buf
	 *size :写多大数据
	 *offset :偏移值(一般不用)
 *返回参数 :写的数据长度	
*/
static	ssize_t hello_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
	/*__FILE__ :表示文件
	 *__FUNCTION__ :当前函数名
	 *__LINE__ :在文件的哪一行
	*/
    printk("%s %s %dn",__FILE__,__FUNCTION__, __LINE__);
    return size;
}

/*作用 : 应用程序关闭的时候调用这个函数
 *传入参数 :
	 *node :
	 *filp :要关闭的文件
 *返回参数 :成功返回0	
*/
static	int hello_release (struct inode *node, struct file *filp)
{
	/*__FILE__ :表示文件
	 *__FUNCTION__ :当前函数名
	 *__LINE__ :在文件的哪一行
	*/
    printk("%s %s %dn",__FILE__,__FUNCTION__, __LINE__);
    return 0;
}

//1,构造 file_operations 
static const struct file_operations  hello_drv = {
    .owner      = THIS_MODULE,
	.read		= hello_read,
	.write		= hello_write,
	.open		= hello_open,
    .release    = hello_release
};

//2,注册驱动(注意,我们在入口函数中注册)

//在命令行输入insmod命令,就是注册驱动程序。之后就会进入这个入口函数
//3,入口函数
static int  hello_init(void)
{
	/*将hello_drv这个驱动放在内核的第n项,中间传入的名字不重要,第三个是要告诉内核的驱动
	 *因为我们不知道第n项是否已经存放了其他驱动,就可以放在第0项,然后让系统自动往后遍历存放到空的地方
	 *major为最终存放的第n项,等下卸载程序需要使用。如果不卸载程序,可以不管这个
	*/
    major = register_chrdev(0,"100ask_hello",&hello_drv);
	//如果成功注册驱动,打印
	printk("insmod success!n");
    return 0;
}

//在命令行输入rmmod命令,就是注册驱动程序。之后就会进入这个出口函数
//4,出口函数
static void  hello_exit(void)
{
	//卸载驱动程序
	//第一个参数是主设备号,第二个是名字
    unregister_chrdev(major,"100ask_hello");
	//如果成功卸载驱动,打印
	printk("rmmod success!n");
}


module_init(hello_init); //确认入口函数
module_exit(hello_exit); //确认出口函数

/*最后我们需要在驱动中加入 LICENSE 信息和作者信息,其中 LICENSE 是必须添加的,否则的话编译的时候会报错,作者信息可以添加也可以不添加
 *这个协议要求我们代码必须免费开源,Linux遵循GPL协议,他的源代码可以开放使用,那么你写的内核驱动程序也要遵循GPL协议才能使用内核函数
 *因为指定了这个协议,你的代码也需要开放给别人免费使用,同时可以根据这个协议要求很多厂商提供源代码
 *但是很多厂商为了规避这个协议,驱动源代码很简单,复杂的东西放在应用层
*/
MODULE_LICENSE("GPL"); //指定模块为GPL协议
MODULE_AUTHOR("CSDN:qq_63922192");  //表明作者,可以不写

应用层代码

/* 说明 : 
 	*1,本代码是学习韦东山老师的驱动入门视频所写,增加了注释。
 	*2,采用的是UTF-8编码格式,如果注释是乱码,需要改一下。
 	*3,这是应用层代码
 * 作者 : CSDN风正豪
*/



#include 
#include 
#include 
#include 
#include 
#include 

/* 作用:输入三个参数表示向/dev/xxx文件中写入数据,输入非三个数据,表示向/dev/xxx文件中读取数据。
 * 写 : ./hello_test /dev/xxx 100ask
 * 读 : ./hello_test /dev/xxx
 */
int main(int argc,char** argv)
{
    int fd,len;    //fd:存放文件描述符;len:存放写入字符个数
    char buf[100]; //存放文件中的字符
	//如果输入参数小于2个,打印本程序使用方法
    if(argc < 2)
    {
        printf("Usage:n");
        printf("%s  [string]n",argv[0]);
        return -1;
    }

    //打开/dev/xxx文件(设备节点),返回一个文件描述符,我们之后可以直接根据这个文件描述符来操作设备节点,间接操作驱动
    fd = open(argv[1],O_RDWR);
	//如果打开失败
    if(fd < 0)
    {
        printf("can not open file %sn",argv[1]);
        return -1;
    }

    //如果输入参数为3个,表示写入数据
    if(argc == 3)
    {
		//因为strlen计算字符串长度不会包括'',所以需要+1
        len = write(fd,argv[2],strlen(argv[2])+1);
		//打印出写入字符个数
        printf("write ret = %dn",len);
    }
    //否则为读取数据
    else
    {
		//读入100个字符
        len =read(fd,buf,100);
		//无论传入多少个数据,最多都只会读100个字符
        buf[99] = '';
		//打印读取到的字符
        printf("read str : %sn",buf);
    }

    //关闭文件
    close(fd);
    return 0;
}

前置知识

(1)因为本人也是刚学不久,所以可能会有讲的有所偏差的地方。请及时指正,谢谢了。

(2)首先我们通常都是在Linux的终端上打开一个可执行文件,然后可执行文件就会执行程序。那么这个可执行文件做了什么呢?

(3)可执行文件先是在应用层读取程序,其中会有很多库函数,库函数是属于内核之中。而内核又会往下调用驱动层程序。最终驱动层控制具体硬件。

其实应用程序到库是比较容易理解的,比如我们刚学习C语言的时候,使用了printf,scanf等等这些函数。而这些函数就在库中。

库可以和系统内核相连接,具体怎么实现的我也不太清楚。

我们写了一个驱动程序,就需要告诉内核,这个过程叫做注册。我们注册了驱动之后,内核里面就会有这个驱动程序的信息,然后上层应用就可以调用。

(4)听起来是不是很懵,我也很懵。不过不要怕,我们只需要知道,咱们需要编写两个程序,一个是驱动层的,一个是应用层的,最后驱动层需要注册进入内核,应用层才能够使用。其他的先不要管。

(5)我们在应用层调用read函数,对应驱动层的read函数。write函数和write函数对应。open函数和open函数对应。close函数和release函数对应(这个为什么不一样我也不清楚)。

(6)我们对Linux 应用程序对驱动程序的调用流程有一个简单了解之后,我得知道整个程序编写流程应该怎么做。至于流程为什么是这样的,我们记住即可。因为这些都是人规定的,如果之后学的深了再进行深究也不迟,现在我们主要是入门。

 

驱动代码讲解

流程介绍

(1)下面我将介绍一个驱动程序编写的流程,如果看完上面的,大家还是一脸懵。没关系,我们根据代码逐个讲解,大家应该就会有一个简单的认识了。

(2)流程:(注意,你看到有些人讲的流程看似可能跟我不一样,你得仔细对比,就会发现其实都是一样的,讲法不同而已)

我们首先需要编写一个file_operations类型的结构体,这个结构体用于管理驱动程序。之后我们将驱动程序注册进入内核之后,我们在应用层调用这个驱动,那么就可以直接通过这个结构体来操作驱动中的open,write,read等函数。

实现对应的 drv_open/drv_read/drv_write 等函数,填入 file_operations 结构体。这样我们在应用层调用open,write,read等函数,就是调用这个驱动了。

这个时候有人可能会问了,有这么多个驱动,我怎么知道open对应的是哪一个驱动?很简单,咱们在写应用层程序的时候,是不是第一个参数是需要传入一个设备号。系统根据这个设备号来判断是调用的哪一个驱动。

把 file_operations 结构体告诉内核: register_chrdev。我们写了一个驱动,但是内核是不知道的。那么怎么办呢?我们就去注册他,内核就明白,有了这个驱动,然后给他分配一个设备号。之后应用层就可以根据这个设备号来调用驱动层了。

这个时候,有人就有疑问了,谁来注册这个结构体?于是我们需要一个入口函数来进行注册,安装驱动程序时,就会去调用这个入口函数。

有入口函数就应该有出口函数:卸载驱动程序时,出口函数调用unregister_chrdev。

最后需要加入GPL协议。因为Linux是遵顼GPL协议的,所以你如果需要使用Linux其他的驱动层函数,就必须遵顼GPL协议,强制要求开源代码。根据这个协议,你可以要求所有使用Linux的厂商提供驱动层源代码,同时别人也可以要求你公开你的驱动层代码,这个是相互的。不过很多厂商为了规避这个协议,驱动源代码很简单,复杂的东西放在应用层。至于还有一个作者名字的添加,随便写不写。

代码逐个分析

(1)第一步,咱们要创建一个file_operations结构体。这个结构体static const struct file_operations 部分是必须这么写的,规定的。最后这个结构体的名字可以不是hello_drv,随便定,不过后面register_chrdev要利用这个结构体名来注册。

static const struct file_operations  hello_drv = {

};

(2)

创建出来这个file_operations结构体之后,咱们就需要根据需求在这个结构体里面写入参数。对于一个文件,open,write,read,release肯定都是需要的。那么就在这几个参数中写入数据,这个数据是函数指针。(对于新手朋友可能不知道结构体".成员"是什么意思,请看C语言结构体详解的赋值部分)至于.owner  = THIS_MODULE,这个是规定要存在的,具体为什么我也不是很清楚。

在写驱动程序的时候,我们需要注意,打印函数是printk,而不是printf。为什么呢?因为内核没有办法使用 C 语言库。

需要注意,咱们这个内核打印信息需要输入:echo "7 4 1 7" > /proc/sys/kernel/printk,打开内核打印。虽然绝大多数内核打印是默认打开的,还是需要注意。

如果不想看内核打印信息,就输入:echo "7 4 1 7" > /proc/sys/kernel/printk。(听不懂没关系,后面演示的时候会解释到)

/*
 *传入参数 :
	 *node :
	 *filp :
 *返回参数 : 如果成功返回0
*/
static int hello_open (struct inode *node, struct file *filp)
{
	/*__FILE__ :表示文件
	 *__FUNCTION__ :当前函数名
	 *__LINE__ :在文件的哪一行
	*/
    printk("%s %s %dn",__FILE__,__FUNCTION__, __LINE__);
    return 0;
}

/*
 *传入参数 :
	 *filp :要读的文件
	 *buf :读的数据放在哪里
	 *size :读多大数据
	 *offset :偏移值(一般不用)
 *返回参数 :读到的数据长度	
*/
static	ssize_t hello_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
	/*__FILE__ :表示文件
	 *__FUNCTION__ :当前函数名
	 *__LINE__ :在文件的哪一行
	*/
    printk("%s %s %dn",__FILE__,__FUNCTION__, __LINE__);
    return size;
}

/*
 *传入参数 :
	 *filp :要写的文件
	 *buf :写入的数据来自于buf
	 *size :写多大数据
	 *offset :偏移值(一般不用)
 *返回参数 :写的数据长度	
*/
static	ssize_t hello_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
	/*__FILE__ :表示文件
	 *__FUNCTION__ :当前函数名
	 *__LINE__ :在文件的哪一行
	*/
    printk("%s %s %dn",__FILE__,__FUNCTION__, __LINE__);
    return size;
}

/*作用 : 应用程序关闭的时候调用这个函数
 *传入参数 :
	 *node :
	 *filp :要关闭的文件
 *返回参数 :成功返回0	
*/
static	int hello_release (struct inode *node, struct file *filp)
{
	/*__FILE__ :表示文件
	 *__FUNCTION__ :当前函数名
	 *__LINE__ :在文件的哪一行
	*/
    printk("%s %s %dn",__FILE__,__FUNCTION__, __LINE__);
    return 0;
}

static const struct file_operations  hello_drv = {
    .owner      = THIS_MODULE,
	.read		= hello_read,
	.write		= hello_write,
	.open		= hello_open,
    .release    = hello_release
};

(3)

这个时候,咱们就需要将file_operations 结构体告诉内核。调用register_chrdev()函数就可以让内核知道file_operations 结构体。

如果是看韦东山老师的视频的话,都知道,其实按照他的第一步,是需要确定主设备号的。不过,咱们在register_chrdev()的第一个参数输入0,那么系统将会帮我们自动确定主设备号,并且返回这个主设备号。

register_chrdev()的第二个参数,我们随便起什么名字。我就跟着韦东山老师的一样算了,懒得改了。

register_chrdev()的第三个参数,这个就跟咱们之前定义的file_operations 结构体有关了。因为我们上面定义的是static const struct file_operations  hello_drv;结构体名为hello_drv,所以第三个参数输入hello_drv。

这个返回的主设备号,我们需要接收,因为之后卸载程序的时候需要使用到。但是如果你不打算卸载,不接收这个主设备号也可以。

(4)

将file_operations 结构体告诉内核以后,我们还需要注册驱动程序,就需要一个入口函数,这个入口函数需要module_init(xxx) 这个宏来告诉内核,确认入口函数。xxx就是我们入口函数名。

那么问题来了,我们什么时候才知道,注册了驱动程序呢?很简单,当我们在Linux终端输入insmod hello_drv.ko程序的时候,那么系统就会调用hello_init()函数。

//在命令行输入insmod命令,就是注册驱动程序。之后就会进入这个入口函数
//3,入口函数
static int  hello_init(void)
{
	/*将hello_drv这个驱动放在内核的第n项,中间传入的名字不重要,第三个是要告诉内核的驱动
	 *因为我们不知道第n项是否已经存放了其他驱动,就可以放在第0项,然后让系统自动往后遍历存放到空的地方
	 *major为最终存放的第n项,等下卸载程序需要使用。如果不卸载程序,可以不管这个
	*/
    major = register_chrdev(0,"100ask_hello",&hello_drv);
	//如果成功注册驱动,打印
	printk("insmod success!n");
    return 0;
}

module_init(hello_init); //确认入口函数

(5)咱们有了入口程序,必然也有一个出口程序。这个时候就需要module_exit(XXX)来确认出口函数了。

//在命令行输入rmmod命令,就是注册驱动程序。之后就会进入这个出口函数
//4,出口函数
static void  hello_exit(void)
{
	//卸载驱动程序
	//第一个参数是主设备号,第二个是名字
    unregister_chrdev(major,"100ask_hello");
	//如果成功卸载驱动,打印
	printk("rmmod success!n");
}

module_exit(hello_exit); //确认出口函数

(6)最后,添加GPL协议和作者名。GPL协议是强制要求必须添加的,作者名随便。

/*最后我们需要在驱动中加入 LICENSE 信息和作者信息,其中 LICENSE 是必须添加的,否则的话编译的时候会报错,作者信息可以添加也可以不添加
 *这个协议要求我们代码必须免费开源,Linux遵循GPL协议,他的源代码可以开放使用,那么你写的内核驱动程序也要遵循GPL协议才能使用内核函数
 *因为指定了这个协议,你的代码也需要开放给别人免费使用,同时可以根据这个协议要求很多厂商提供源代码
 *但是很多厂商为了规避这个协议,驱动源代码很简单,复杂的东西放在应用层
*/
MODULE_LICENSE("GPL"); //指定模块为GPL协议
MODULE_AUTHOR("CSDN:qq_63922192");  //表明作者,可以不写

命令行操作讲解

命令行操作流程

(1)命令行输入流程:

根据上面驱动代码讲解,我们知道了,将驱动代码编写出来以后,内核是不知道的,还需要注册。而注册方法有两种,第一种就是将驱动编译进 Linux 内核中,这样当 Linux 内核启动的时候就会自动运行驱动程序。第二种就是将驱动编译成模块(Linux下模块扩展名为.ko),在Linux内核启动以后使用“insmod”命令加载驱动模块。在调试驱动的时候一般都选择将其编译为模块,这样我们修改驱动以后只需要编译一下驱动代码即可,不需要编译整个 Linux 代码。而且在调试的时候只需要加载或者卸载驱动模块即可,不需要重启整个系统。总之,将驱动编译为模块最大的好处就是方便开发,当驱动开发完成,确定没有问题以后就可以将驱动编译进Linux 内核中。
我们需要确认是否注册成功,所以需要输入cat /proc/devices:查看当前已经被使用掉的设备号。lsmod,查看内核中已经加载的驱动程序。

创建设备节点。驱动加载成功需要在/dev 目录下创建一个与之对应的设备节点文件,应用程序就是通过操作这个设备节点文件来完成对具体设备的操作。

设备节点创建之后,我们就可以按照:应用程序   /dev/xxx(xxx是设备节点,名字任意)格式来从应用层调用驱动层了。

用完之后,咱们可能想要卸载了,就可以输入:rmmod 驱动程序 来卸载。

(2)现在我们知道应用程序如何通过设备节点调用驱动程序了。那么现在我们讲一下需求。我们想,如果在命令行输入三个参数,那么表示写入数据。如果输入两个参数,就表示读取数据。

Makefile代码

KERN_DIR = /home/book/100ask_imx6ull-sdk/Linux-4.9.88

all:
	make -C $(KERN_DIR) M=`pwd` modules 
	$(CROSS_COMPILE)gcc -o hello_test hello_test.c 

clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order
	rm -f hello_test

obj-m	+= hello_drv.o

应用层代码讲解

(1)咱们知道了知道了需求之后就要进行操作了。不过为了防止有部分人基础过差,还是解释一下main函数的argc和argv是什么。

(2)我们在命令行输入./hello_test  /dev/xxx  100ask的时候,会将这三个存入到一个argv的二级指针里面。这个argv[0]存放./hello_test,argv[1]存放/dev/xxx,argv[2]存放100ask。而argc存放传入的参数有几个,比如现在就是传入三个参数了。但是有人会问了,我怎么知道是三个参数呢?这个很简单,用空格区分参数。

(3)

如果传入参数少于2个,那么我们就会打印出这个应用程序的使用方法。同时结束程序。

使用open打开这个设备节点,之后会返回一个文件描述符,我们之后就可以根据这个文件描述符来操作这个设备节点。同时,内核会调用驱动层的hello_open()函数,因为应用层使用了open函数。

如果没有打开这个文件,open函数将会返回-1,我们判断fd是否为-1,如果是-1那么结束程序,提醒没有打开设备节点。

现在我们需要判断传入的是三个参数。如果是三个参数,那么就表示写数据,内核调用hello_write()函数,因为应用层使用了write函数。否则表示读数据,内核调用hello_read()函数,因为应用层调用了read函数。

最后调用close函数,关闭文件。对应内核调用hello_release函数。

/* 说明 : 
 	*1,本代码是学习韦东山老师的驱动入门视频所写,增加了注释。
 	*2,采用的是UTF-8编码格式,如果注释是乱码,需要改一下。
 	*3,这是应用层代码
 * 作者 : CSDN风正豪
*/



#include 
#include 
#include 
#include 
#include 
#include 

/* 作用:输入三个参数表示向/dev/xxx文件中写入数据,输入非三个数据,表示向/dev/xxx文件中读取数据。
 * 写 : ./hello_test /dev/xxx 100ask
 * 读 : ./hello_test /dev/xxx
 */
int main(int argc,char** argv)
{
    int fd,len;    //fd:存放文件描述符;len:存放写入字符个数
    char buf[100]; //存放文件中的字符
	//如果输入参数小于2个,打印本程序使用方法
    if(argc < 2)
    {
        printf("Usage:n");
        printf("%s  [string]n",argv[0]);
        return -1;
    }

    //打开/dev/xxx文件(设备节点),返回一个文件描述符,我们之后可以直接根据这个文件描述符来操作设备节点,间接操作驱动
    fd = open(argv[1],O_RDWR);
	//如果打开失败
    if(fd < 0)
    {
        printf("can not open file %sn",argv[1]);
        return -1;
    }

    //如果输入参数为3个,表示写入数据
    if(argc == 3)
    {
		//因为strlen计算字符串长度不会包括'',所以需要+1
        len = write(fd,argv[2],strlen(argv[2])+1);
		//打印出写入字符个数
        printf("write ret = %dn",len);
    }
    //否则为读取数据
    else
    {
		//读入100个字符
        len =read(fd,buf,100);
		//无论传入多少个数据,都只会读100个字符
        buf[99] = '';
		//打印读取到的字符
        printf("read str : %sn",buf);
    }

    //关闭文件
    close(fd);
    return 0;
}

效果演示

为了让大家更深刻的理解驱动层和应用层,我在此分为两种演示方法,一种是打开内核打印的效果演示,一种是关闭内核打印的效果演示。

关闭内核打印效果演示

(1)make编译程序,注意,这个需要在Ubuntu中编译程序!

(2)

在开发板中,共享与Ubuntu共享文件:mount -t nfs -o nolock,vers=3  192.168.5.11:/home/book/nfs_rootfs  /mnt。

之后我们关闭内核打印:echo 0       4       0      7  > /proc/sys/kernel/printk

(3)

确认存在 hello_drv.ko文件

insmod hello_drv.ko装载驱动

lsmod 确认驱动已经安装

 (4)我们知道驱动已经安装好了,那么我们需要知道这个驱动的设备号,输入:cat /proc/devices:查看当前已经被使用掉的设备号。驱动名字与我们在驱动层使用register_chrdev()函数的第二个参数有关。

(5) 创建设备节点: mknod  /dev/xyz c 240 0

“/dev/xyz”是要创建的节点文件,xyz可以为任意名字

“c”表示这是个字符设备

“ 240”是设备的主设备号,这个数值是根据cat /proc/devices查看驱动的时候,看到240 100ask_hello,所以100ask_hello这个驱动的设备号是240。

“ 0”是设备的次设备号,默认写0即可。

 (6)命令行调用

(7)

最后删除驱动程序:rmmod  驱动程序 (我们的驱动程序叫做hello_drv)

删除设备节点:rm /dev/xyz

 

 打开内核打印效果演示

(1)打开内核打印:echo "7 4 1 7" > /proc/sys/kernel/printk

 (2)

因为名为打开了内核打印,所以会出现很多奇怪的东西,不用管。按shift+C即可。

我们输入insmod hello_drv.ko装载程序,就是调用了驱动层的入口函数,所以这里内核会打印“insmod success!”

//在命令行输入insmod命令,就是注册驱动程序。之后就会进入这个入口函数
//3,入口函数
static int  hello_init(void)
{
	/*将hello_drv这个驱动放在内核的第n项,中间传入的名字不重要,第三个是要告诉内核的驱动
	 *因为我们不知道第n项是否已经存放了其他驱动,就可以放在第0项,然后让系统自动往后遍历存放到空的地方
	 *major为最终存放的第n项,等下卸载程序需要使用。如果不卸载程序,可以不管这个
	*/
    major = register_chrdev(0,"100ask_hello",&hello_drv);
	//如果成功注册驱动,打印
	printk("insmod success!n");
    return 0;
}

(3)

确认存在 hello_drv.ko文件

insmod hello_drv.ko装载驱动

lsmod 确认驱动已经安装

(4)创建设备节点: mknod  /dev/xyz c 240 0

 (5)

我们只输入两个参数,发现他内核成功打印了数据,从中我们可以知道调用了hello_open,hello_read,hello_release函数。

我们输入三个参数,从内核打印得知, 我们调用了hello_open,hello_read,hello_release函数。与应用层相对应。

 

 (6)

删除驱动程序,最后我们发现成功打印了内核信息。

删除设备节点:rm /dev/xyz

相关文章

服务器端口转发,带你了解服务器端口转发
服务器开放端口,服务器开放端口的步骤
产品推荐:7月受欢迎AI容器镜像来了,有Qwen系列大模型镜像
如何使用 WinGet 下载 Microsoft Store 应用
百度搜索:蓝易云 – 熟悉ubuntu apt-get命令详解
百度搜索:蓝易云 – 域名解析成功但ping不通解决方案

发布评论