可行的阻塞型IO和休眠的初次应用

来源：互联网发布：域名备案多少钱编辑：程序博客网时间：2024/05/29 03:09

注：所以文章红色字体代表需要特别注意和有问题还未解决的地方，蓝色字体表示需要注意的地方

1.本文所介绍的程序平台

虚拟机为：Ubuntu 12.10

开发板上系统内核版本：linux-3.5.7.2

等待队列

在Linux驱动程序设计中，可以使用等待队列来实现进程的阻塞，等待队列可

看作保存进程的容器，在阻塞进程时，将进程放入等待队列，当唤醒进程时，

从等待等列中取出进程。

Linux 3.5.7.2内核提供了如下关于等待队列的操作：

1、定义等待队列

wait_queue_head_t my_queue

2、初始化等待队列

init_waitqueue_head(&my_queue)

3、定义并初始化等待队列

DECLARE_WAIT_QUEUE_HEAD(my_queue)

4、有条件睡眠

wait_event(queue,condition)

当condition(一个布尔表达式)为真时，立即返回；否则让进程进入TASK_UNINTERRUPTIBLE模式的睡眠，并挂在 queue参数所指定的等待队列上。

wait_event_interruptible(queue,condition)

当condition(一个布尔表达式)为真时，立即返回；否则让进程进入TASK_INTERRUPTIBLE的睡眠，并挂在queue参数所指定的等待队列上。

int wait_event_killable(wait_queue_t queue, condition)

当condition(一个布尔表达式)为真时，立即返回；否则让进程进入TASK_KILLABLE的睡眠，并挂在queue参数所指定的等待队列上。

5、无条件睡眠（老版本，建议不再使用）

sleep_on(wait_queue_head_t *q)

让进程进入不可中断的睡眠,并把它放入等待队列。

interruptible_sleep_on(wait_queue_head_t *q)

让进程进入可中断的睡眠,并把它放入等待队列。

6、从等待队列中唤醒进程

wake_up(wait_queue_t *q)

从等待队列中唤醒状态为TASK_UNINTERRUPTIBLE，

TASK_INTERRUPTIBLE，TASK_KILLABLE的所有进程。

wake_up_interruptible(wait_queue_t *q)

从等待队列中唤醒状态为TASK_INTERRUPTIBLE的进程

阻塞的实现

在阻塞型驱动程序中，Read实现方法如下：如果进程调用read，但设备没有数据或数据不足，进程阻塞。当新数据到达后，唤醒被阻塞进程。

在阻塞型驱动程序中，Write实现方法如下：如果进程调用了write，但设备没有足够的空间供其写入数据，进程阻塞。当设备中的数据被读走后，缓冲区中空出部分空间，则唤醒进程。

阻塞方法是文件读写操作的默认方法，但应用程序员可通过使用O_NONBLOCK标志来人为的设置读写操作为非阻塞方法（该标志定义在<linux/fcntl.h>中，在打开文件时指定）。如果设置了O_NONBLOCK标志，read和write的行为是不同的。如果进程在没有数据就绪时调用了read，或者在缓冲区没有空间时调用了write，系统只是简

单地返回-EAGAIN，而不会阻塞进程。

2.程序清单

本次实验程序为国嵌培训代码，本人作了改动和较为详细的注释，如有错误请指出。

memdev.h

//头文件

#ifndef _MEMDEV_H_

#define _MEMDEV_H_

#include <linux/ioctl.h>

#ifndef MEMDEV_MAJOR

#define MEMDEV_MAJOR 0 /*预设的mem的主设备号*/

#endif

#ifndef MEMDEV_NR_DEVS

#define MEMDEV_NR_DEVS 2 /*设备数*/

#endif

#ifndef MEMDEV_SIZE

#define MEMDEV_SIZE 4096

#endif

/*mem设备描述的结构体*/

struct mem_dev

{

char *data;

unsigned long size;

wait_queue_head_t inq;

};

/*定义幻数*/

#define MEMDEV_IOC_MAGIC 'k'

/* 定义命令，这里的命令都是unsigned int类型*/

#define MEMDEV_IOCPRINT _IO(MEMDEV_IOC_MAGIC, 1)

#define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC, 2, int)

#define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC, 3, int)

#define MEMDEV_IOC_MAXNR 3 //定义命令的最大序列号

#endif

memdev.c

/*********************************************

*memdev.c 阻塞版本

*********************************************/

#include <linux/module.h>

#include <linux/types.h>

#include <linux/fs.h>

#include <linux/errno.h>

#include <linux/mm.h>

#include <linux/sched.h>

#include <linux/init.h>

#include <linux/cdev.h>

#include <linux/slab.h>

#include <asm/io.h>

#include <asm/uaccess.h>

#include "memdev.h"

static int mem_major = MEMDEV_MAJOR;

bool have_data = false; /*表明设备有足够空间可供读*/

module_param(mem_major,int,S_IRUGO);

struct mem_dev *mem_devp;/*设备结构体指针*/

struct cdev cdev;

/*文件打开函数*/

int mem_open(struct inode *inode,struct file *filp)

{

struct mem_dev *dev;

/*获取次设备号*/

int num = MINOR(inode->i_rdev);

/*大于最大的次设备号就错误了因为注册的时候要指定次设备的数目*/

if(num >=MEMDEV_NR_DEVS)

return -ENODEV;

dev = &mem_devp[num];

/*将设备描述结构指针赋值给文件私有数据指针*/

filp->private_data = dev;

return 0;

}

/*文件释放函数*/

int mem_release(struct inode *inode,struct file *filp)

{

return 0;

}

/*读函数*/

static ssize_t mem_read(struct file *filp,char __user *buf,size_t size,loff_t *poss)

{

unsigned long p = *poss;

unsigned int count = size;

int ret = 0;

/*获得设备结构体指针由于read没有struct inode *inode结构而且函数的

参数不能改只能改函数名所以只能在open函数里面设置*/

struct mem_dev *dev = filp->private_data;

/*判断读位置是否有效*/

if(p >= MEMDEV_SIZE)

return 0;

if(count > MEMDEV_SIZE-p)

count = MEMDEV_SIZE-p;

/*没有数据可读考虑为什么不用if 而用while !!!!??*/

while(!have_data)

{

if(filp->f_flags & O_NONBLOCK)

return -EAGAIN;

wait_event_interruptible(dev->inq, have_data);

}

/*读数据到用户空间*/

if(copy_to_user(buf,(void*)(dev->data+p),count))

{

ret = -EFAULT;

}

else

{

*poss +=count;

ret = count;

printk(KERN_INFO "read %d bytes from %lu\n",count,p);

}

have_data = false; /*表明不再有数据可读 */

return ret;

}

/*写函数*/

static ssize_t mem_write(struct file *filp,const char __user *buf,size_t size,loff_t *poss)

{

unsigned long p = *poss;

unsigned int count = size;

int ret=0;

struct mem_dev *dev = filp->private_data;

if(p>=MEMDEV_SIZE)

return 0;

if(count>MEMDEV_SIZE-p)

count = MEMDEV_SIZE-p;

if(copy_from_user(dev->data+p,buf,count))

{

ret = -EFAULT;

}

else

{

*poss += count;

ret = count;

printk(KERN_INFO "write %d bytes from %lu\n",count,p);

}

have_data = true;/*有新数据可读*/

/*唤醒读进程*/

wake_up(&(dev->inq));

return ret;

}

int memdev_ioctl(struct inode *inode, struct file *filp,

unsigned int cmd, unsigned long arg)

{

int err = 0;

int ret = 0;

int ioarg = 0;

/* 检测命令的有效性 */

if (_IOC_TYPE(cmd) != MEMDEV_IOC_MAGIC)//命令是否操作这一类设备

return -EINVAL;

if (_IOC_NR(cmd) > MEMDEV_IOC_MAXNR) // 命令序列号是否超出定义

return -EINVAL;

/* 根据命令类型，检测参数空间是否可以访问 */

if (_IOC_DIR(cmd) & _IOC_READ)

err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));

else if (_IOC_DIR(cmd) & _IOC_WRITE)

err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));

if (err)

return -EFAULT;

/* 根据命令，执行相应的操作 */

switch(cmd) {

/* 打印当前设备信息 */

case MEMDEV_IOCPRINT:

printk("<--- CMD MEMDEV_IOCPRINT Done--->\n\n");

break;

/* 获取参数 */

case MEMDEV_IOCGETDATA:

ioarg = 1101;

ret = __put_user(ioarg, (int *)arg);

break;

/* 设置参数 */

case MEMDEV_IOCSETDATA:

ret = __get_user(ioarg, (int *)arg);

printk("<--- In Kernel MEMDEV_IOCSETDATA ioarg = %d --->\n\n",ioarg);

break;

default:

return -EINVAL;

}

return ret;

}

static loff_t mem_llseek(struct file *filp,loff_t offset,int whence)

{

loff_t newpos;

switch(whence)

{

case 0:

newpos = offset;

break;

case 1:

newpos = filp->f_pos + offset;

break;

case 2:

newpos = MEMDEV_SIZE - 1 + offset;

break;

default:

return -EINVAL;

}

if((newpos<0) || (newpos>MEMDEV_SIZE))

return -EINVAL;

filp->f_pos = newpos;

return newpos;

}

static const struct file_operations mem_fops =

{

.owner = THIS_MODULE,

.llseek = mem_llseek,

.read = mem_read,

.write = mem_write,

.open = mem_open,

.release = mem_release,

.unlocked_ioctl = memdev_ioctl,/*为什么这里有‘，’？？*/

};

/*设备驱动模块加载函数*/

static int memdev_init(void)

{

int result;

int i;

dev_t devno = MKDEV(mem_major,0);

/*静态申请设备号*/

if(mem_major)

result = register_chrdev_region(devno,2,"memdev");

else/*动态申请设备号*/

{

result = alloc_chrdev_region(&devno,0,2,"memdev");

mem_major = MAJOR(devno);

}

if(result < 0)

return result;

/*初始化cdev结构*/

cdev_init(&cdev,&mem_fops);

cdev.owner = THIS_MODULE;

cdev.ops = &mem_fops;

/*注册字符设备*/

cdev_add(&cdev,MKDEV(mem_major,0),MEMDEV_NR_DEVS);

/*为设备描述结构分配内存*/

mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev),GFP_KERNEL);

if(!mem_devp)/*申请失败*/

{

result = -ENOMEM;

goto fail_malloc;

}

memset(mem_devp,0,MEMDEV_NR_DEVS * sizeof(struct mem_dev));

/*为设备分配内存*/

for(i=0;i<MEMDEV_NR_DEVS;i++)

{

mem_devp[i].size = MEMDEV_SIZE;

mem_devp[i].data = kmalloc(MEMDEV_SIZE,GFP_KERNEL);

memset(mem_devp[i].data,0,MEMDEV_SIZE);

/*初始化等待队列*/

init_waitqueue_head(&(mem_devp[i].inq));

}

return 0;

fail_malloc:

unregister_chrdev_region(devno,1);

return result;

}

static void memdev_exit(void)

{

cdev_del(&cdev);

kfree(mem_devp);

unregister_chrdev_region(MKDEV(mem_major,0),2);

}

MODULE_AUTHOR("fulinux");

MODULE_LICENSE("GPL");

module_init(memdev_init);

module_exit(memdev_exit);

memdevapp_read.c

/*********************************************

*memdevapp.c

*********************************************/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

int main()

{

int fd;

char buf[4096];

//FILE *fp0 = NULL;

/*初始化buf*/

strcpy(buf,"This is read");

printf("buf:%s\n",buf);

/*打开设备文件*/

fd=open("/dev/memdev3",O_RDWR);

if(fd == -1)

{

printf("open memdev failed!\n");

return -1;

}

lseek(fd,0,SEEK_SET);

/*清除buf*/

strcpy(buf,"nothing");

/*读出设备*/

read(fd,buf,sizeof(buf));

/*检测结果*/

printf("buf:%s\n",buf);

return 0;

}

memdevapp_write.c

/*********************************************

*memdevapp.c

*********************************************/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

int main()

{

int fd;

char buf[4096];

//FILE *fp0 = NULL;

/*初始化buf*/

strcpy(buf,"This is write");

printf("buf:%s\n",buf);

/*打开设备文件*/

fd=open("/dev/memdev3",O_RDWR);

if(fd == -1)

{

printf("open memdev failed!\n");

return -1;

}

/*写入设备*/

write(fd,buf,sizeof(buf));

return 0;

}

/**************************************************************************

Makefile

**************************************************************************/

1 ifneq ($(KERNELRELEASE),)
2
3 obj-m:=memdev.o
4
5 else
6
7 KERNELDIR:=/lib/modules/3.5.7.2/build
8
9 PWD:=$(shell pwd)
10
11 default:
12
13         $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
14
15 install:
16         insmod ./memdev.ko
17
18 uninstall:
19         rmmod memdev
20
21 clean:
22         rm -rf *.o *.mod.* *.ko
23
24 endif

fulinux@ubuntu:~$ clear
fulinux@ubuntu:~$ cd memdev2/
fulinux@ubuntu:~/memdev2$ ls -l
总用量 24
-rw-rw-r-- 1 fulinux fulinux 257 3月 6 14:41 Makefile
-rw-rw-r-- 1 fulinux fulinux 759 3月 6 14:37 memdevapp_read.c
-rw-rw-r-- 1 fulinux fulinux 515 3月 6 14:36 memdevapp_write.c
-rw-rw-r-- 1 fulinux fulinux 6920 3月 6 14:49 memdev.c
-rw-rw-r-- 1 fulinux fulinux 772 3月 6 13:32 memdev.h
fulinux@ubuntu:~/memdev2$ sudo make
[sudo] password for fulinux:
make -C /lib/modules/3.5.7.2/build M=/home/fulinux/memdev2 modules
make[1]: 正在进入目录 `/usr/src/linux-source-3.5.0/linux-source-3.5.0'
CC [M] /home/fulinux/memdev2/memdev.o
/home/fulinux/memdev2/memdev.c:397:5: 警告：从不兼容的指针类型初始化 [默认启用]
/home/fulinux/memdev2/memdev.c:397:5: 警告： (在‘mem_fops.unlocked_ioctl’的初始化附近) [默认启用]
Building modules, stage 2.
MODPOST 1 modules
CC      /home/fulinux/memdev2/memdev.mod.o
LD [M] /home/fulinux/memdev2/memdev.ko
make[1]:正在离开目录 `/usr/src/linux-source-3.5.0/linux-source-3.5.0'
fulinux@ubuntu:~/memdev2$ ls
Makefile           memdev.c   memdev.mod.c modules.order
memdevapp_read.c   memdev.h   memdev.mod.o Module.symvers
memdevapp_write.c memdev.ko memdev.o
fulinux@ubuntu:~/memdev2$ cat /proc/devices
Character devices:
1 mem
4 /dev/vc/0
4 tty
4 ttyS
5 /dev/tty
5 /dev/console
5 /dev/ptmx
5 ttyprintk
6 lp
7 vcs
10 misc
13 input
14 sound
21 sg
29 fb
99 ppdev
108 ppp
116 alsa
128 ptm
136 pts
180 usb
189 usb_device
216 rfcomm
226 drm
252 bsg
253 watchdog
254 rtc

Block devices:
1 ramdisk
259 blkext
7 loop
8 sd
9 md
11 sr
65 sd
66 sd
67 sd
68 sd
69 sd
70 sd
71 sd
128 sd
129 sd
130 sd
131 sd
132 sd
133 sd
134 sd
135 sd
252 device-mapper
253 virtblk
254 mdp
fulinux@ubuntu:~/memdev2$ sudo make install
insmod ./memdev.ko
fulinux@ubuntu:~/memdev2$ cat /proc/devices
Character devices:
1 mem
4 /dev/vc/0
4 tty
4 ttyS
5 /dev/tty
5 /dev/console
5 /dev/ptmx
5 ttyprintk
6 lp
7 vcs
10 misc
13 input
14 sound
21 sg
29 fb
99 ppdev
108 ppp
116 alsa
128 ptm
136 pts
180 usb
189 usb_device
216 rfcomm
226 drm
251 memdev
252 bsg
253 watchdog
254 rtc

Block devices:
1 ramdisk
259 blkext
7 loop
8 sd
9 md
11 sr
65 sd
66 sd
67 sd
68 sd
69 sd
70 sd
71 sd
128 sd
129 sd
130 sd
131 sd
132 sd
133 sd
134 sd
135 sd
252 device-mapper
253 virtblk
254 mdp
fulinux@ubuntu:~/memdev2$ ls -al memdev3
ls: 无法访问memdev3: 没有那个文件或目录
fulinux@ubuntu:~/memdev2$ mknod /dev/memdev3 c 251 0
mknod: "/dev/memdev3": 权限不够
fulinux@ubuntu:~/memdev2$ sudo mknod /dev/memdev3 c 251 0
fulinux@ubuntu:~/memdev2$ ls -al memdev3
ls: 无法访问memdev3: 没有那个文件或目录
fulinux@ubuntu:~/memdev2$ ls -al /dev/memdev3
crw-r--r-- 1 root root 251, 0 3月 6 15:31 /dev/memdev3
fulinux@ubuntu:~/memdev2$ gcc -o memdevapp_read memdevapp_read.c
memdevapp_read.c: 在函数‘main’中:
memdevapp_read.c:24:5: 警告：隐式声明与内建函数‘strcpy’不兼容 [默认启用]
fulinux@ubuntu:~/memdev2$ gcc -o memdevapp_write memdevapp_write.c
memdevapp_write.c: 在函数‘main’中:
memdevapp_write.c:20:5: 警告：隐式声明与内建函数‘strcpy’不兼容 [默认启用]
fulinux@ubuntu:~/memdev2$ ./memdevapp_write
buf:This is write
open memdev failed!
fulinux@ubuntu:~/memdev2$ sudo ./memdevapp_write
buf:This is write
fulinux@ubuntu:~/memdev2$ sudo ./memdevapp_read
buf:This is read
buf:This is write
fulinux@ubuntu:~/memdev2$