韦东山Linux驱动入门实验班（1）hello驱动

举报
风正豪 发表于 2023/08/01 16:26:59 2023/08/01
【摘要】 韦东山Linux驱动入门实验班（1）hello驱动

​


前言


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

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

（3）gitee仓库；GitHub仓库；

代码

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

驱动代码

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



#include <linux/mm.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mman.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/raw.h>
#include <linux/tty.h>
#include <linux/capability.h>
#include <linux/ptrace.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/backing-dev.h>
#include <linux/shmem_fs.h>
#include <linux/splice.h>
#include <linux/pfn.h>
#include <linux/export.h>
#include <linux/io.h>
#include <linux/uio.h>
#include <linux/module.h>
#include <linux/uaccess.h>

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

/*
 *传入参数 ：
	 *node ：
	 *filp ：
 *返回参数 : 如果成功返回0
*/
static int hello_open (struct inode *node, struct file *filp)
{
	/*__FILE__ ：表示文件
	 *__FUNCTION__ ：当前函数名
	 *__LINE__ ：在文件的哪一行
	*/
    printk("%s %s %d\n",__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 %d\n",__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 %d\n",__FILE__,__FUNCTION__, __LINE__);
    return size;
}

/*作用 ： 应用程序关闭的时候调用这个函数
 *传入参数 ：
	 *node ：
	 *filp ：要关闭的文件
 *返回参数 ：成功返回0	
*/
static	int hello_release (struct inode *node, struct file *filp)
{
	/*__FILE__ ：表示文件
	 *__FUNCTION__ ：当前函数名
	 *__LINE__ ：在文件的哪一行
	*/
    printk("%s %s %d\n",__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 <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/* 作用：输入三个参数表示向/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 <dev> [string]\n",argv[0]);
        return -1;
    }

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

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

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

前置知识

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

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

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

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

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

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

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

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

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

 ​编辑


驱动代码讲解

流程介绍

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

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

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

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

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

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

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

<5>有入口函数就应该有出口函数：卸载驱动程序时，出口函数调用unregister_chrdev。

<6>最后需要加入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）

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

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

<3>需要注意，咱们这个内核打印信息需要输入：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 %d\n",__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 %d\n",__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 %d\n",__FILE__,__FUNCTION__, __LINE__);
    return size;
}

/*作用 ： 应用程序关闭的时候调用这个函数
 *传入参数 ：
	 *node ：
	 *filp ：要关闭的文件
 *返回参数 ：成功返回0	
*/
static	int hello_release (struct inode *node, struct file *filp)
{
	/*__FILE__ ：表示文件
	 *__FUNCTION__ ：当前函数名
	 *__LINE__ ：在文件的哪一行
	*/
    printk("%s %s %d\n",__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）

<1>这个时候，咱们就需要将file_operations 结构体告诉内核。调用register_chrdev（）函数就可以让内核知道file_operations 结构体。

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

<3>register_chrdev（）的第二个参数，我们随便起什么名字。我就跟着韦东山老师的一样算了，懒得改了。

<4>register_chrdev（）的第三个参数，这个就跟咱们之前定义的file_operations 结构体有关了。因为我们上面定义的是static const struct file_operations  hello_drv；结构体名为hello_drv，所以第三个参数输入hello_drv。

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

（4）

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

<2>那么问题来了，我们什么时候才知道，注册了驱动程序呢？很简单，当我们在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）命令行输入流程：

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

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

<4>设备节点创建之后，我们就可以按照：应用程序   /dev/xxx（xxx是设备节点，名字任意）格式来从应用层调用驱动层了。

<5>用完之后，咱们可能想要卸载了，就可以输入：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）

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

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

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

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

<5>最后调用close函数，关闭文件。对应内核调用hello_release函数。

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



#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/* 作用：输入三个参数表示向/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 <dev> [string]\n",argv[0]);
        return -1;
    }

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

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

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

效果演示

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

关闭内核打印效果演示

（1）make编译程序，注意，这个需要在Ubuntu中编译程序！

​编辑

（2）

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

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

​编辑

（3）

<1>确认存在 hello_drv.ko文件

<2>insmod hello_drv.ko装载驱动

<3>lsmod 确认驱动已经安装

​编辑

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

​编辑

（5） 创建设备节点： mknod  /dev/xyz c 240 0

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

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

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

<4>“ 0”是设备的次设备号，默认写0即可。

​编辑

 （6）命令行调用

​编辑

（7）

<1>最后删除驱动程序：rmmod  驱动程序 （我们的驱动程序叫做hello_drv）

<2>删除设备节点：rm /dev/xyz

 ​编辑

 打开内核打印效果演示

（1）打开内核打印：echo "7 4 1 7" > /proc/sys/kernel/printk

​编辑

 （2）

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

<2>我们输入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）

<1>确认存在 hello_drv.ko文件

<2>insmod hello_drv.ko装载驱动

<3>lsmod 确认驱动已经安装

​编辑

（4）创建设备节点： mknod  /dev/xyz c 240 0

​编辑

 （5）

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

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

​编辑

 ​编辑

 （6）

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

<2>删除设备节点：rm /dev/xyz

​编辑


​

【版权声明】本文为华为云社区用户原创内容，未经允许不得转载，如需转载请自行联系原作者进行授权。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Linux TCP/IP
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入