嵌入式驱动初级-阻塞与非阻塞

文章目录

前言
一、五种IO模型
二、阻塞与非阻塞
三、多路复用
四、信号驱动

前言

记录嵌入式驱动学习笔记

一、五种IO模型

当应用程序对设备驱动进行操作的时候，如果不能获取到设备资源，那么阻塞式 IO 就会将应用程
序对应的线程挂起，直到设备资源可以获取为止。对于非阻塞 IO，应用程序对应的线程不会挂
起，它要么一直轮询等待，直到设备资源可以使用，要么就直接放弃。
1.阻塞式 IO
应用程序调用 read 函数从设备中读取数据，当设备不可用或数据未准备好的时候就会进入到休眠态。等设备可用的时候就会从休眠态唤醒，然后从设备中读取数据返回给应用程序。阻塞式 IO 如图
在这里插入图片描述
2.非阻塞式 IO
应用程序使用非阻塞访问方式从设备读取数据，当设备不可用或数据未准备好的时候会立即向内核返回一个错误码，表示数据读取失败。应用程序会再次重新读取数据，这样一直往复循环，直到数据读取成功。非阻塞 IO 如图

在这里插入图片描述
3.多路复用
委托中介监控

4.信号驱动
让内核如果能操作时发信号，在信号处理函数中操作

5.异步IO
向内核注册操作请求，内核完成操作后发通知信号

二、阻塞与非阻塞

阻塞与非阻塞实现流程
应用层：
open时由O_NONBLOCK指示read、write时是否阻塞，open以后可以由fcntl函数来改变是否阻塞：

	flags = fcntl(fd,F_GETFL,0);
	flags |= O_NONBLOCK; flags &= ~ O_NONBLOCK;
	fcntl(fd, F_SETFL, flags);
1
2
3

驱动层：通过等待队列

A.定义等待队列头
wait_queue_head_t rq; 读等待队列头
wait_queue_head_t wq; 写等待队列头
B.初始化队列头
init_waitqueue_head(wait_queue_head_t *pwq)
C.将任务丢到等待队列去条件成立后正常唤醒读和写的睡眠条件不同
wait_event_interruptible(wq,condition)
D.将符合条件唤醒条件的任务从等待队列头中唤醒
wake_up_interruptible(wait_queue_head_t *pwq)

读、写用不同的等待队列头rq、wq
无数据可读、可写时调用wait_event_interruptible(rq、wq,条件)
写入数据成功时唤醒rq，读出数据成功唤醒wq

	wait_queue_head_t //等待队列头数据类型
	init_waitqueue_head(wait_queue_head_t *pwq) //初始化等待队列头
	wait_event_interruptible(wq,condition)
	/*
	功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来
	    wq:等待队列头
	    condition：C语言表达式
	返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）
	*/        
	wait_event(wq,condition) //深度睡眠
	wake_up_interruptible(wait_queue_head_t *pwq) //唤醒浅睡眠
	wake_up(wait_queue_head_t *pwq) //唤醒深睡眠
/*
1
2
3
4
5
6
7
8
9
10
11
12
13

添加读写阻塞等待功能和非阻塞的字符设备驱动代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "mychar.h"
// 该程序思路 应用层先往内核mydev_buf内写 hello 然后再从内核里读出来
#define BUF_LEN 100
//主设备号
int major = 11;
//次设备号
int minor = 0;
//注册设备数量
int mychar_num = 1;
//设备名
char mycharname[] ="mychar";
//设备操作函数避免使用太多全局变量 将变量写入一个结构体
struct mychar_dev
{
   //创建cdev类型的对象 cdevinit函数要用到 包含在结构体mychar_dev相当于子类继承父类
   struct cdev mydev;
   //全局数组 字符设备产生的数据存放
   char mydev_buf[BUF_LEN];
   //数组下标从零开始
   int curlen;
   //阻塞队列队头 读等待 写等待
   wait_queue_head_t rq;
   wait_queue_head_t wq; 
}; 
//实例化一个 mychar_dev类型的对象
struct mychar_dev gmydev;
int mychar_open(struct inode *pnode, struct file *pfile) //打开设备
{
   //将设备结构体作为私有数据添加到设备文件中
   /*已知成员的地址获得所在结构体变量的地址：container_of(成员地址,结构体类型名，成员在结构体中的名称)*/
   pfile->private_data =(void *) (container_of(pnode->i_cdev,struct mychar_dev,mydev));
   printk("mychar_open is called\n");
   return 0;
}
int mychar_close(struct inode *pnode, struct file *pfile) //关闭设备
{
   printk("mychar_close is called\n");
   return 0;
}
//读数据是对于应用层来说 把内核数据拷贝到应用层来读取
/*
ssize_t xxx_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos);
完成功能：读取设备产生的数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次read对应的那次open
    pbuf：指向用户空间一块内存，用来保存读到的数据
    count：用户期望读取的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示读取的起始位置，读完后也需要变更位置指示器的指示位置
 返回值：
    本次成功读取的字节数，失败返回-1

wait_event_interruptible(wq,condition)
功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来
    wq:等待队列头
    condition：C语言表达式
返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）

*/
ssize_t mychar_read(struct file *pfile, char __user *puser, size_t count, loff_t *p_pos)
{
   struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;
   int ret = 0;
   //要读的数据大于数据的长度 修改要读数据的长度
   int size = 0;
   //改写读写函数变成支持非阻塞 curlen <= 0此时表示没数据可读
   if(pmydev->curlen <= 0)
   {
      //通过该标志位判断是否为非阻塞
      if(pfile->f_flags & O_NONBLOCK)
      {//非阻塞 直接返回错误
         printk("O_NONBLOCK No Data Read\n");
         return -1;
      }else
      {//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 
         ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
         if(ret)
         {
            printk("Wake up by signal\n");
            return -ERESTARTSYS;
         }
      }
   }
   if(count > pmydev->curlen)
   {
      size = pmydev->curlen;
   }else
   {
      size=count;
   }
   //将内核空间数据复制到用户空间 用户空间：puser 内核空间：mydev_buf
   ret = copy_to_user(puser,pmydev->mydev_buf,size);
   if(ret)
   {
      printk("copy_to_user failed\n");
      return -1;
   }
   //将剩下的数据移动到数组起始 即删除已读数据
   memcpy(pmydev->mydev_buf,pmydev->mydev_buf + size,pmydev->curlen - size);
   pmydev->curlen -= size;
   //成功读走一段数据 就会空出一段空间可以写入数据
   wake_up_interruptible(&pmydev->wq);
   return size;
}
//写数据对于应用层来说 把数据写进驱动
/*
ssize_t xxx_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos);  
完成功能：向设备写入数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次write对应的那次open
    pbuf：指向用户空间一块内存，用来保存被写的数据
    count：用户期望写入的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示写入的起始位置，写完后也需要变更位置指示器的指示位置
 返回值：
    本次成功写入的字节数，失败返回-1
*/
ssize_t mychar_write(struct file *pfile, const char __user *puser, size_t count, loff_t *p_pos)
{
   int size = 0;
   int ret = 0;
   struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;
   //改写读写函数变成支持非阻塞 >= BUF_LEN此时表示数据已经写满不可再写
   if(pmydev->curlen >= BUF_LEN)
   {
      if(pfile->f_flags & O_NONBLOCK)
      {//非阻塞 直接返回错误
         printk("O_NONBLOCK Can not write data\n");
         return -1;
      }
      else
      {//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 
         ret = wait_event_interruptible(pmydev->wq,pmydev->curlen < BUF_LEN);
         if(ret)
         {
            printk("wake up by signal\n");
            return -ERESTARTSYS;
         }
      }
   }
   //如果剩余数组长度小于要写入的数据长度 则把要写入的数据修改 
   if(count > BUF_LEN - pmydev->curlen)
   {
      size = BUF_LEN - pmydev->curlen;
   }else
   {
      size = count;
   }
   //从用户空间拷贝数据到内核空间
   ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen,puser,size);
   if(ret)
   {
      printk("copy_from_user failed\n");
      return -1;
   }
   pmydev->curlen += size;
   //当应用层写入数据后 就有数据可读在此处唤醒读等待队列
   wake_up_interruptible(&pmydev->rq);
   return size;
}
//设备属性控制函数
long mychar_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{
   int __user *pret = (int *)arg;
   int maxlen = BUF_LEN;
   int ret = 0;
   struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

   switch(cmd)
   {
      case MYCHAR_IOCTL_GET_MAXLEN:
         ret = copy_to_user(pret,&maxlen,sizeof(int));
         if(ret)
         {
            printk("copy_to_user MAXLEN failed\n");
            return -1;
         }
         break;
      case MYCHAR_IOCTL_GET_CURLEN:
         ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
         if(ret)
         {
            printk("copy_to_user CURLEN failed\n");
            return -1;
         }
         break;
      default:
         printk("The cmd is unknow\n");
         return -1;

   }

   return 0;
}
//内核驱动操作函数集合 cdevinit函数要用到
struct file_operations myops =
{
   .owner=THIS_MODULE,
   .open=mychar_open,
   .release=mychar_close,
   .read=mychar_read,
   .write=mychar_write,
   .unlocked_ioctl=mychar_ioctl,
};

int __init mychar_init(void)
{
   //用来接收注册设备函数的返回值
   int ret = 0;
   //主设备号和次设备号合并
   dev_t devno = MKDEV(major,minor);
   /*1.申请设备号*/
   //静态分配 手动分配设备号，先验证设备号是否被占用，如果没有则申请占用该设备号
   //ret = register_chrdev_region(devno,mychar_num,"mychar");
   ret = register_chrdev_region(devno,mychar_num,mycharname);
   //分配失败返回负数
   if(ret)
   {
      //动态分配设备号，查询内核里未被占用的设备号，如果找到则占用该设备号
      //ret = alloc_chrdev_region(&devno,minor,mychar_num,"mychar");
      ret = alloc_chrdev_region(&devno,minor,mychar_num,mycharname);
      if(ret)
      {
         printk("get devno failed\n");
         return -1;
      }
      //如果是动态分配说明自己设置的设备号被占用了 系统会更换主设备号 重新获取一下主设备号
      major = MAJOR(devno);
   }
   /*2.将struct cdev对象添加到内核对应的数据结构里*/
   //初始化cdev 给struct cdev对象指定操作函数集
   cdev_init(&gmydev.mydev,&myops);
   gmydev.mydev.owner=THIS_MODULE;
   //将字符设备添加进内核 哈希管理列表
   cdev_add(&gmydev.mydev,devno,1);
   //初始化等待队列头
   init_waitqueue_head(&gmydev.rq);
   init_waitqueue_head(&gmydev.wq);
   
 
   return 0;
}
   
void __exit mychar_exit(void)
{
   //主设备号和次设备号合并
   dev_t devno = MKDEV(major,minor);
   //注销字符设备驱动 入口参数：设备号 设备名称
   //unregister_chrdev(devno,"mychar");
   //将字符设备从内核移除
   cdev_del(&gmydev.mydev);
   unregister_chrdev_region(devno,mychar_num);
}
MODULE_LICENSE("GPL");
module_init(mychar_init);
module_exit(mychar_exit);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261

阻塞等待应用程序

#include 
#include 
#include 
#include 
#include 
#include 
#include "mychar.h"
int main(int argc,char *argv[])
{
	int fd = -1;
	char buf[8] = "";
	int ret = 0;
	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}
	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}
	ret = read(fd,buf,8);
	if(ret < 0)
	{
		printf("read data failed\n");
	}
	else
	{
		printf("buf=%s\n",buf);
	}
	close(fd);
	fd = -1;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

非阻塞等待应用程序

#include 
#include 
#include 
#include 
#include 
#include 
#include "mychar.h"
int main(int argc,char *argv[])
{
	int fd = -1;
	char buf[8] = "";
	int ret = 0;
	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}
	fd = open(argv[1],O_RDWR | O_NONBLOCK);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}
	ret = read(fd,buf,8);
	if(ret < 0)
	{
		printf("read data failed\n");
	}
	else
	{
		printf("buf=%s\n",buf);
	}
	close(fd);
	fd = -1;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

三、多路复用

如果用户应用程序以非阻塞的方式访问设备，设备驱动程序就要提供非阻塞的处理方式，也就是轮询。poll、epoll 和 select 可以用于处理轮询，应用程序通过 select、epoll 或 poll 函数来查询设备是否可以操作，如果可以操作的话就从设备读取或者向设备写入数据。当应用程序调用 select、epoll 或 poll 函数的时候设备驱动程序中的 poll 函数就会执行，因此需要在设备驱动程序中编写 poll 函数。
应用层思路
select 函数

int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
/*	功能：监听多个描述符，阻塞等待有一个或者多个文件描述符，准备就绪。
		内核将没有准备就绪的文件描述符，从集合中清掉了。
	参数：  nfds			最大文件描述符数 ，加1
			readfds		读文件描述符集合
			writefds		写文件描述符集合
			exceptfds		其他异常的文件描述符集合
			timeout		超时时间（NULL）
	返回值：当timeout为NULL时返回0，成功:准备好的文件描述的个数  出错:-1 
		   当timeout不为NULL时，如超时设置为0，则select为非阻塞，超时设置 > 0，则无描述符可被操作的情况下阻塞指定长度的时间 
*/
void FD_CLR(int fd, fd_set *set);
//功能：将fd 从集合中清除掉

int  FD_ISSET(int fd, fd_set *set);
//功能：判断fd 是否存在于集合中
 
void FD_SET(int fd, fd_set *set);
//功能：将fd 添加到集合中

void FD_ZERO(fd_set *set);
//功能：将集合清零

//使用模型:

while(1)
{
    /*得到最大的描述符maxfd*/
    /*FD_ZERO清空描述符集合*/
	/*将被监控描述符加到相应集合rfds里  FD_SET*/
    /*设置超时*/
    ret = select(maxfd+1,&rfds,&wfds,NULL,NULL);
    if(ret < 0)
    {
        if(errno == EINTR)//错误时信号引起的
        {
        	continue;   
        }
        else
        {
            break;
        }
    }
    else if(ret == 0)
    {//超时
        //.....
    }
    else
    { //> 0 ret为可被操作的描述符个数
        if(FD_ISSET(fd1,&rfds))
        {//读数据
            //....
        }
        if(FD_ISSET(fd2,&rfds))
        {//读数据
            //....
        }
        ///.....
        if(FD_ISSET(fd1,&wfds))
        {//写数据
            //....
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

当应用程序调用 select 或 poll 函数来对驱动程序进行非阻塞访问的时候，驱动程序file_operations 操作集中的 poll 函数就会执行。所以驱动程序的编写者需要提供对应的 poll 函数，poll 函数原型如下所示：
驱动层思路
poll函数

void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)；
/*功能：将等待队列头添加至poll_table表中
  参数：struct file :设备文件
  Wait_queue_head_t :等待队列头
  Poll_table :poll_table表
*/

/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int xxx_poll(struct file *filp, poll_table *wait) //函数名初始化给struct file_operations的成员.poll
{
    unsigned int mask = 0;
    /*
    	1. 将所有等待队列头加入poll_table表中
    	2. 判断是否可读，如可读则mask |= POLLIN | POLLRDNORM;
    	3. 判断是否可写，如可写则mask |= POLLOUT | POLLWRNORM;
    */
    
    return mask;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

支持多路复用驱动层代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "mychar.h"

// 该程序思路 应用层先往内核mydev_buf内写 hello 然后再从内核里读出来
/*
   11.15增加多路复用代码
*/
#define BUF_LEN 100
//主设备号
int major = 11;
//次设备号
int minor = 0;
//注册设备数量
int mychar_num = 1;
//设备名
char mycharname[] ="mychar";
//设备操作函数避免使用太多全局变量 将变量写入一个结构体
struct mychar_dev
{
   //创建cdev类型的对象 cdevinit函数要用到 包含在结构体mychar_dev相当于子类继承父类
   struct cdev mydev;
   //全局数组 字符设备产生的数据存放
   char mydev_buf[BUF_LEN];
   //数组下标从零开始
   int curlen;
   //阻塞队列队头 读等待 写等待
   wait_queue_head_t rq;
   wait_queue_head_t wq; 
}; 
//实例化一个 mychar_dev类型的对象
struct mychar_dev gmydev;
int mychar_open(struct inode *pnode, struct file *pfile) //打开设备
{
   //将设备结构体作为私有数据添加到设备文件中
   /*已知成员的地址获得所在结构体变量的地址：container_of(成员地址,结构体类型名，成员在结构体中的名称)*/
   pfile->private_data =(void *) (container_of(pnode->i_cdev,struct mychar_dev,mydev));
   printk("mychar_open is called\n");
   return 0;
}
int mychar_close(struct inode *pnode, struct file *pfile) //关闭设备
{
   printk("mychar_close is called\n");
   return 0;
}
//读数据是对于应用层来说 把内核数据拷贝到应用层来读取
/*
ssize_t xxx_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos);
完成功能：读取设备产生的数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次read对应的那次open
    pbuf：指向用户空间一块内存，用来保存读到的数据
    count：用户期望读取的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示读取的起始位置，读完后也需要变更位置指示器的指示位置
 返回值：
    本次成功读取的字节数，失败返回-1

wait_event_interruptible(wq,condition)
功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来
    wq:等待队列头
    condition：C语言表达式
返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）

*/
ssize_t mychar_read(struct file *pfile, char __user *puser, size_t count, loff_t *p_pos)
{
   struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;
   int ret = 0;
   //要读的数据大于数据的长度 修改要读数据的长度
   int size = 0;
   //改写读写函数变成支持非阻塞 curlen <= 0此时表示没数据可读
   if(pmydev->curlen <= 0)
   {
      //通过该标志位判断是否为非阻塞
      if(pfile->f_flags & O_NONBLOCK)
      {//非阻塞 直接返回错误
         printk("O_NONBLOCK No Data Read\n");
         return -1;
      }else
      {//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 
         ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
         if(ret)
         {
            printk("Wake up by signal\n");
            return -ERESTARTSYS;
         }
      }
   }
   if(count > pmydev->curlen)
   {
      size = pmydev->curlen;
   }else
   {
      size=count;
   }
   //将内核空间数据复制到用户空间 用户空间：puser 内核空间：mydev_buf
   ret = copy_to_user(puser,pmydev->mydev_buf,size);
   if(ret)
   {
      printk("copy_to_user failed\n");
      return -1;
   }
   //将剩下的数据移动到数组起始 即删除已读数据
   memcpy(pmydev->mydev_buf,pmydev->mydev_buf + size,pmydev->curlen - size);
   pmydev->curlen -= size;
   //成功读走一段数据 就会空出一段空间可以写入数据
   wake_up_interruptible(&pmydev->wq);
   return size;
}
//写数据对于应用层来说 把数据写进驱动
/*
ssize_t xxx_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos);  
完成功能：向设备写入数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次write对应的那次open
    pbuf：指向用户空间一块内存，用来保存被写的数据
    count：用户期望写入的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示写入的起始位置，写完后也需要变更位置指示器的指示位置
 返回值：
    本次成功写入的字节数，失败返回-1
*/
ssize_t mychar_write(struct file *pfile, const char __user *puser, size_t count, loff_t *p_pos)
{
   int size = 0;
   int ret = 0;
   struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;
   //改写读写函数变成支持非阻塞 >= BUF_LEN此时表示数据已经写满不可再写
   if(pmydev->curlen >= BUF_LEN)
   {
      if(pfile->f_flags & O_NONBLOCK)
      {//非阻塞 直接返回错误
         printk("O_NONBLOCK Can not write data\n");
         return -1;
      }
      else
      {//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 
         ret = wait_event_interruptible(pmydev->wq,pmydev->curlen < BUF_LEN);
         if(ret)
         {
            printk("wake up by signal\n");
            return -ERESTARTSYS;
         }
      }
   }
   //如果剩余数组长度小于要写入的数据长度 则把要写入的数据修改 
   if(count > BUF_LEN - pmydev->curlen)
   {
      size = BUF_LEN - pmydev->curlen;
   }else
   {
      size = count;
   }
   //从用户空间拷贝数据到内核空间
   ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen,puser,size);
   if(ret)
   {
      printk("copy_from_user failed\n");
      return -1;
   }
   pmydev->curlen += size;
   //当应用层写入数据后 就有数据可读在此处唤醒读等待队列
   wake_up_interruptible(&pmydev->rq);
   return size;
}
//设备属性控制函数
long mychar_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{
   int __user *pret = (int *)arg;
   int maxlen = BUF_LEN;
   int ret = 0;
   struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

   switch(cmd)
   {
      case MYCHAR_IOCTL_GET_MAXLEN:
         ret = copy_to_user(pret,&maxlen,sizeof(int));
         if(ret)
         {
            printk("copy_to_user MAXLEN failed\n");
            return -1;
         }
         break;
      case MYCHAR_IOCTL_GET_CURLEN:
         ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
         if(ret)
         {
            printk("copy_to_user CURLEN failed\n");
            return -1;
         }
         break;
      default:
         printk("The cmd is unknow\n");
         return -1;

   }

   return 0;
}
/* 支持多路复用
void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)；
  功能：将等待队列头添加至poll_table表中
  参数：struct file :设备文件
  Wait_queue_head_t :等待队列头
  Poll_table :poll_table表
*/
unsigned int mychar_poll(struct file *pfile, poll_table *ptb)
{
   struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
   unsigned int mask = 0;
   //1. 将所有等待队列头加入poll_table表中
   poll_wait(pfile,&pmydev->rq,ptb);
	poll_wait(pfile,&pmydev->wq,ptb);
   //2. 判断是否可读，如可读则mask |= POLLIN | POLLRDNORM;
   if(pmydev->curlen > 0)
	{
		mask |= POLLIN | POLLRDNORM;
	}
   //3. 判断是否可写，如可写则mask |= POLLOUT | POLLWRNORM;
   if(pmydev->curlen < BUF_LEN)
	{
		mask |= POLLOUT | POLLWRNORM;
	}
   return mask;
}
//内核驱动操作函数集合 cdevinit函数要用到
struct file_operations myops =
{
   .owner=THIS_MODULE,
   .open=mychar_open,
   .release=mychar_close,
   .read=mychar_read,
   .write=mychar_write,
   .unlocked_ioctl=mychar_ioctl,
   .poll = mychar_poll,
};

int __init mychar_init(void)
{
   //用来接收注册设备函数的返回值
   int ret = 0;
   //主设备号和次设备号合并
   dev_t devno = MKDEV(major,minor);
   /*1.申请设备号*/
   //静态分配 手动分配设备号，先验证设备号是否被占用，如果没有则申请占用该设备号
   //ret = register_chrdev_region(devno,mychar_num,"mychar");
   ret = register_chrdev_region(devno,mychar_num,mycharname);
   //分配失败返回负数
   if(ret)
   {
      //动态分配设备号，查询内核里未被占用的设备号，如果找到则占用该设备号
      //ret = alloc_chrdev_region(&devno,minor,mychar_num,"mychar");
      ret = alloc_chrdev_region(&devno,minor,mychar_num,mycharname);
      if(ret)
      {
         printk("get devno failed\n");
         return -1;
      }
      //如果是动态分配说明自己设置的设备号被占用了 系统会更换主设备号 重新获取一下主设备号
      major = MAJOR(devno);
   }
   /*2.将struct cdev对象添加到内核对应的数据结构里*/
   //初始化cdev 给struct cdev对象指定操作函数集
   cdev_init(&gmydev.mydev,&myops);
   gmydev.mydev.owner=THIS_MODULE;
   //将字符设备添加进内核 哈希管理列表
   cdev_add(&gmydev.mydev,devno,1);
   //初始化等待队列头
   init_waitqueue_head(&gmydev.rq);
   init_waitqueue_head(&gmydev.wq);
   
 
   return 0;
}
   
void __exit mychar_exit(void)
{
   //主设备号和次设备号合并
   dev_t devno = MKDEV(major,minor);
   //注销字符设备驱动 入口参数：设备号 设备名称
   //unregister_chrdev(devno,"mychar");
   //将字符设备从内核移除
   cdev_del(&gmydev.mydev);
   unregister_chrdev_region(devno,mychar_num);
}
MODULE_LICENSE("GPL");
module_init(mychar_init);
module_exit(mychar_exit);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294

支持多路复用应用层代码

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


#include 

#include "mychar.h"
int main(int argc,char *argv[])
{
	//要监视的文件描述符
	int fd = -1;
	char buf[8] = "";
	int ret = 0;
	//读操作文件描述符集
	fd_set rfds;

	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}

	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}
/**
	 *int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
	功能：监听多个描述符，阻塞等待有一个或者多个文件描述符，准备就绪。
		内核将没有准备就绪的文件描述符，从集合中清掉了。
	参数：  nfds			最大文件描述符数 ，加1
			readfds		读文件描述符集合
			writefds		写文件描述符集合
			exceptfds		其他异常的文件描述符集合
			timeout		超时时间（NULL）
	返回值：当timeout为NULL时返回0，成功:准备好的文件描述的个数  出错:-1 
		   当timeout不为NULL时，如超时设置为0，则select为非阻塞，超时设置 > 0，则无描述符可被操作的情况下阻塞指定长度的时间 
*/
	while(1)
	{
		//功能：将集合清零 清除 readfds
		FD_ZERO(&rfds);
		//功能：将fd 添加到集合中  将 fd 添加到 readfds 里面
		FD_SET(fd,&rfds);
		//监听的文件中没有数据可读一直阻塞 有数据可读时返回 
		//select将更新这个集合,把其中不可读的文件描述符去掉只保留符合条件的在这个集合里面
		ret = select(fd + 1,&rfds,NULL,NULL,NULL);
		//小于0表示出错 返回其他值，可以进行操作的文件描述符个数。
		if(ret < 0)
		{//被信号唤醒的出错可以忽略继续执行
			if(errno == EINTR)
			{
				continue;
			}
			else
			{
				printf("select error\n");
				break;
			}
		}
		//功能：判断fd 是否存在于集合中 条件成立代表有数据可读
		/**
		 * fd_set rfds取fd_set长度为1字节，fd_set中的每一bit可以对应一个文件描述符fd。
		 * 则1字节长的fd_set最大可以对应8个fd。
		(1)执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。
		(2)若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)
		(3)若再加入fd＝2，fd=1,则set变为0001,0011
		(4)执行select(6,&set,0,0,0)阻塞等待
		(5)若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。
		*/
		if(FD_ISSET(fd,&rfds))
		{
			//读数据并打印
			read(fd,buf,8);
			printf("buf=%s\n",buf);
		}
	}

	close(fd);
	fd = -1;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

四、信号驱动

Linux 应用程序可以通过阻塞或者非阻塞这两种方式来访问驱动设备，通过阻塞方式访问的话应用程序会处于休眠态，等待驱动设备可以使用，非阻塞方式的话会通过 poll 函数来不断的轮询，查看驱动设备文件是否可以使用。这两种方式都需要应用程序主动的去查询设备的使用情况，如果能提供一种类似中断的机制，当驱动程序可以访问的时候主动告诉应用程序那就最好了。
“信号”为此应运而生，信号类似于我们硬件上使用的“中断”，只不过信号是软件层次上的。算是在软件层次上对中断的一种模拟，驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了，应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。
在这里插入图片描述

应用层思路：信号注册+fcntl

A.使用 signal 函数来设置指定信号的处理函数
sighandler_t signal(int signum, sighandler_t handler)
B.将本应用程序的进程号告诉内核
fcntl(fd, F_SETOWN, getpid())
C.将该设备的IO模式设置成信号驱动模式
oflags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, oflags | FASYNC);
D.应用自己实现的信号处理函数，在此函数中完成读写
void input_handler(int signum)

应用模板

//应用模板
int main()
{
	int fd = open("/dev/xxxx",O_RDONLY);

	fcntl(fd, F_SETOWN, getpid());

	oflags = fcntl(fd, F_GETFL);
	fcntl(fd, F_SETFL, oflags | FASYNC);

	signal(SIGIO,xxxx_handler);

	//......
}
    
void xxxx_handle(int signo)
{//读写数据
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

驱动层思路

/*设备结构中添加如下成员*/
struct fasync_struct *pasync_obj;

/*应用调用fcntl设置FASYNC时调用该函数产生异步通知结构对象，并将其地址设置到设备结构成员中*/
static int hello_fasync(int fd, struct file *filp, int mode) //函数名初始化给struct file_operations的成员.fasync
{
	struct hello_device *dev = filp->private_data; 
	return fasync_helper(fd, filp, mode, &dev->pasync_obj);
}

/*写函数中有数据可读时向应用层发信号*/
if (dev->pasync_obj)
       kill_fasync(&dev->pasync_obj, SIGIO, POLL_IN);
       
/*release函数中释放异步通知结构对象*/
if (dev->pasync_obj) 
	fasync_helper(-1, filp, 0, &dev->pasync_obj);

int fasync_helper(int fd, struct file *filp, int mode, struct fasync_struct **pp);
/*
	功能：产生或释放异步通知结构对象
	参数：
	返回值：成功为>=0,失败负数
*/

void kill_fasync(struct fasync_struct **, int, int);
/*	
	功能：发信号
	参数：
		struct fasync_struct ** 指向保存异步通知结构地址的指针
		int 	信号 SIGIO/SIGKILL/SIGCHLD/SIGCONT/SIGSTOP
		int 	读写信息POLLIN、POLLOUT
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

信号驱动代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "mychar.h"

// 该程序思路 应用层先往内核mydev_buf内写 hello 然后再从内核里读出来
/*
   11.15增加多路复用代码
   11.16增加信号驱动代码
*/
#define BUF_LEN 100
//主设备号
int major = 11;
//次设备号
int minor = 0;
//注册设备数量
int mychar_num = 1;
//设备名
char mycharname[] ="mychar";
//设备操作函数避免使用太多全局变量 将变量写入一个结构体
struct mychar_dev
{
   //创建cdev类型的对象 cdevinit函数要用到 包含在结构体mychar_dev相当于子类继承父类
   struct cdev mydev;
   //全局数组 字符设备产生的数据存放
   char mydev_buf[BUF_LEN];
   //数组下标从零开始
   int curlen;
   //阻塞队列队头 读等待 写等待
   wait_queue_head_t rq;
   wait_queue_head_t wq; 
   //异步相关结构体 
   struct fasync_struct *pasync_obj;
}; 
//实例化一个 mychar_dev类型的对象
struct mychar_dev gmydev;
int mychar_open(struct inode *pnode, struct file *pfile) //打开设备
{
   //将设备结构体作为私有数据添加到设备文件中
   /*已知成员的地址获得所在结构体变量的地址：container_of(成员地址,结构体类型名，成员在结构体中的名称)*/
   pfile->private_data =(void *) (container_of(pnode->i_cdev,struct mychar_dev,mydev));
   printk("mychar_open is called\n");
   return 0;
}
int mychar_close(struct inode *pnode, struct file *pfile) //关闭设备
{
   //释放异步通知结构对象
   struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
	if(pmydev->pasync_obj != NULL)
		fasync_helper(-1,pfile,0,&pmydev->pasync_obj);
   printk("mychar_close is called\n");
   return 0;
}
//读数据是对于应用层来说 把内核数据拷贝到应用层来读取
/*
ssize_t xxx_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos);
完成功能：读取设备产生的数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次read对应的那次open
    pbuf：指向用户空间一块内存，用来保存读到的数据
    count：用户期望读取的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示读取的起始位置，读完后也需要变更位置指示器的指示位置
 返回值：
    本次成功读取的字节数，失败返回-1

wait_event_interruptible(wq,condition)
功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来
    wq:等待队列头
    condition：C语言表达式
返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）

*/
ssize_t mychar_read(struct file *pfile, char __user *puser, size_t count, loff_t *p_pos)
{
   struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;
   int ret = 0;
   //要读的数据大于数据的长度 修改要读数据的长度
   int size = 0;
   //改写读写函数变成支持非阻塞 curlen <= 0此时表示没数据可读
   if(pmydev->curlen <= 0)
   {
      //通过该标志位判断是否为非阻塞
      if(pfile->f_flags & O_NONBLOCK)
      {//非阻塞 直接返回错误
         printk("O_NONBLOCK No Data Read\n");
         return -1;
      }else
      {//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 
         ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
         if(ret)
         {
            printk("Wake up by signal\n");
            return -ERESTARTSYS;
         }
      }
   }
   if(count > pmydev->curlen)
   {
      size = pmydev->curlen;
   }else
   {
      size=count;
   }
   //将内核空间数据复制到用户空间 用户空间：puser 内核空间：mydev_buf
   ret = copy_to_user(puser,pmydev->mydev_buf,size);
   if(ret)
   {
      printk("copy_to_user failed\n");
      return -1;
   }
   //将剩下的数据移动到数组起始 即删除已读数据
   memcpy(pmydev->mydev_buf,pmydev->mydev_buf + size,pmydev->curlen - size);
   pmydev->curlen -= size;
   //成功读走一段数据 就会空出一段空间可以写入数据
   wake_up_interruptible(&pmydev->wq);
   return size;
}
//写数据对于应用层来说 把数据写进驱动
/*
ssize_t xxx_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos);  
完成功能：向设备写入数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次write对应的那次open
    pbuf：指向用户空间一块内存，用来保存被写的数据
    count：用户期望写入的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示写入的起始位置，写完后也需要变更位置指示器的指示位置
 返回值：
    本次成功写入的字节数，失败返回-1
*/
ssize_t mychar_write(struct file *pfile, const char __user *puser, size_t count, loff_t *p_pos)
{
   int size = 0;
   int ret = 0;
   struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;
   //改写读写函数变成支持非阻塞 >= BUF_LEN此时表示数据已经写满不可再写
   if(pmydev->curlen >= BUF_LEN)
   {
      if(pfile->f_flags & O_NONBLOCK)
      {//非阻塞 直接返回错误
         printk("O_NONBLOCK Can not write data\n");
         return -1;
      }
      else
      {//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 
         ret = wait_event_interruptible(pmydev->wq,pmydev->curlen < BUF_LEN);
         if(ret)
         {
            printk("wake up by signal\n");
            return -ERESTARTSYS;
         }
      }
   }
   //如果剩余数组长度小于要写入的数据长度 则把要写入的数据修改 
   if(count > BUF_LEN - pmydev->curlen)
   {
      size = BUF_LEN - pmydev->curlen;
   }else
   {
      size = count;
   }
   //从用户空间拷贝数据到内核空间
   ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen,puser,size);
   if(ret)
   {
      printk("copy_from_user failed\n");
      return -1;
   }
   pmydev->curlen += size;
   //当应用层写入数据后 就有数据可读在此处唤醒读等待队列
   wake_up_interruptible(&pmydev->rq);
   /**
    * 当设备可以访问的时候，驱动程序需要向应用程序发出信号，相当于产生“中断”。kill_fasync
   函数负责发送指定的信号，kill_fasync 函数原型如下所示：
   void kill_fasync(struct fasync_struct **fp, int sig, int band)
   函数参数和返回值含义如下：
   fp：要操作的 fasync_struct。
   sig：要发送的信号。
   band：可读时设置为 POLL_IN，可写时设置为 POLL_OUT。
   返回值：无
   */
  //当对象被创建之后才可以执行以下语句
   if(pmydev->pasync_obj != NULL)
	{
		kill_fasync(&pmydev->pasync_obj,SIGIO,POLL_IN);
	}
   return size;
}
//设备属性控制函数
long mychar_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{
   int __user *pret = (int *)arg;
   int maxlen = BUF_LEN;
   int ret = 0;
   struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

   switch(cmd)
   {
      case MYCHAR_IOCTL_GET_MAXLEN:
         ret = copy_to_user(pret,&maxlen,sizeof(int));
         if(ret)
         {
            printk("copy_to_user MAXLEN failed\n");
            return -1;
         }
         break;
      case MYCHAR_IOCTL_GET_CURLEN:
         ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
         if(ret)
         {
            printk("copy_to_user CURLEN failed\n");
            return -1;
         }
         break;
      default:
         printk("The cmd is unknow\n");
         return -1;

   }

   return 0;
}
/* 支持多路复用
void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)；
  功能：将等待队列头添加至poll_table表中
  参数：struct file :设备文件
  Wait_queue_head_t :等待队列头
  Poll_table :poll_table表
*/
unsigned int mychar_poll(struct file *pfile, poll_table *ptb)
{
   struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
   unsigned int mask = 0;
   //1. 将所有等待队列头加入poll_table表中
   poll_wait(pfile,&pmydev->rq,ptb);
	poll_wait(pfile,&pmydev->wq,ptb);
   //2. 判断是否可读，如可读则mask |= POLLIN | POLLRDNORM;
   if(pmydev->curlen > 0)
	{
		mask |= POLLIN | POLLRDNORM;
	}
   //3. 判断是否可写，如可写则mask |= POLLOUT | POLLWRNORM;
   if(pmydev->curlen < BUF_LEN)
	{
		mask |= POLLOUT | POLLWRNORM;
	}
   return mask;
}
/**支持信号驱动
 * int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
fasync_helper 函数的前三个参数就是 fasync 函数的那三个参数，第四个参数就是要初始化
的 fasync_struct 结构体指针变量。当应用程序通过“fcntl(fd, F_SETFL, flags | FASYNC)”改变
fasync 标记的时候，驱动程序 file_operations 操作集中的 fasync 函数就会执行。功能：产生或释放异步通知结构对象
*/
int mychar_fasync(int fd,struct file *pfile,int mode)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
	return fasync_helper(fd,pfile,mode,&pmydev->pasync_obj);
}
//内核驱动操作函数集合 cdevinit函数要用到
struct file_operations myops =
{
   .owner=THIS_MODULE,
   .open=mychar_open,
   .release=mychar_close,
   .read=mychar_read,
   .write=mychar_write,
   .unlocked_ioctl=mychar_ioctl,
   //支持多路复用
   .poll = mychar_poll,
   //支持信号驱动
   .fasync = mychar_fasync,
};

int __init mychar_init(void)
{
   //用来接收注册设备函数的返回值
   int ret = 0;
   //主设备号和次设备号合并
   dev_t devno = MKDEV(major,minor);
   /*1.申请设备号*/
   //静态分配 手动分配设备号，先验证设备号是否被占用，如果没有则申请占用该设备号
   //ret = register_chrdev_region(devno,mychar_num,"mychar");
   ret = register_chrdev_region(devno,mychar_num,mycharname);
   //分配失败返回负数
   if(ret)
   {
      //动态分配设备号，查询内核里未被占用的设备号，如果找到则占用该设备号
      //ret = alloc_chrdev_region(&devno,minor,mychar_num,"mychar");
      ret = alloc_chrdev_region(&devno,minor,mychar_num,mycharname);
      if(ret)
      {
         printk("get devno failed\n");
         return -1;
      }
      //如果是动态分配说明自己设置的设备号被占用了 系统会更换主设备号 重新获取一下主设备号
      major = MAJOR(devno);
   }
   /*2.将struct cdev对象添加到内核对应的数据结构里*/
   //初始化cdev 给struct cdev对象指定操作函数集
   cdev_init(&gmydev.mydev,&myops);
   gmydev.mydev.owner=THIS_MODULE;
   //将字符设备添加进内核 哈希管理列表
   cdev_add(&gmydev.mydev,devno,1);
   //初始化等待队列头
   init_waitqueue_head(&gmydev.rq);
   init_waitqueue_head(&gmydev.wq);
   
 
   return 0;
}
   
void __exit mychar_exit(void)
{
   //主设备号和次设备号合并
   dev_t devno = MKDEV(major,minor);
   //注销字符设备驱动 入口参数：设备号 设备名称
   //unregister_chrdev(devno,"mychar");
   //将字符设备从内核移除
   cdev_del(&gmydev.mydev);
   unregister_chrdev_region(devno,mychar_num);
}
MODULE_LICENSE("GPL");
module_init(mychar_init);
module_exit(mychar_exit);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329

信号驱动应用层代码

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

#include 

#include "mychar.h"
//把描述符变为全局变量 可以方便信号服务函数使同一个文件描述符
int fd = -1;
//1.信号处理函数
void sigio_handler(int signo);
int main(int argc,char *argv[])
{
	int flg = 0;

	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}
	//指定收到什么信号后使用那个信号处理函数
	signal(SIGIO,sigio_handler);

	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}
	//2.将本应用程序的进程号告诉内核
	fcntl(fd,F_SETOWN,getpid());
	//3.开启异步通知
	flg = fcntl(fd,F_GETFL);
	flg |= FASYNC;
	fcntl(fd,F_SETFL,flg);
	//死循环一直阻塞 等待信号
	while(1)
	{
	}

	close(fd);
	fd = -1;
	return 0;
}
//信号服务函数 收到可读信号开始读数据
void sigio_handler(int signo)
{
	char buf[8] = "";
	read(fd,buf,8);
	printf("buf=%s\n",buf);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

相关阅读:
如何用在线模版快速制作活动海报？
Java锁lock的应用
 ElasticSearch 04 -- 集群
 静态时序分析：ideal_clock、propagated_clock以及generated_clock的关系及其延迟计算规则（一）
【Android笔记27】Android中的动画效果之属性动画
 vue 无限滚动插件 vue-seamless-scroll
java基础题--数组
 一文带你了解 Spring 的 @Enable 开头的注解
 敏捷DevOps专家王立杰：端到端DevOps持续交付的5P法则 | IDCF
C++：初始化列表，static成员，友元，内部类
原文地址：https://blog.csdn.net/weixin_44681745/article/details/128044196