x4412&ibox项目实战40－Linux设备驱动之异步通知实验 - 九鼎创展论坛

[root@x4412 ~]# kill -l
HUP INT QUIT ILL TRAP ABRT BUS FPE KILL USR1 SEGV USR2 PIPE ALRM TERM STKFLT CHLD CONT STOP TSTP TTIN TTOU URG XCPU XFSZ VTALRM PROF WINCH IO PWR SYS
[root@x4412 ~]#

复制代码

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/device.h>
#define GLOBALFIFO_SIZE 0x1000 /*全局fifo最大4K字节*/
#define FIFO_CLEAR 0x1 /*清0全局内存的长度*/
DEFINE_SEMAPHORE(sem);//初始化并声明一个信号量
DECLARE_WAIT_QUEUE_HEAD(r_wait);//初始化并声明一个等待队列r_wait
DECLARE_WAIT_QUEUE_HEAD(w_wait);//初始化并声明一个等待队列w_wait
static int globalfifo_major;
static struct class *cdev_class;
struct globalfifo_dev
{
struct cdev cdev; /*cdev结构体*/
unsigned int current_len; /*fifo有效数据长度*/
unsigned char mem[GLOBALFIFO_SIZE]; /*全局内存*/
struct fasync_struct *async_queue;/*异步结构体指针*/
};
struct globalfifo_dev *globalfifo_devp; /*设备结构体指针*/
static int globalfifo_fasync(int fd,struct file *filp,int mode)
{
struct globalfifo_dev *dev =filp->private_data;
return fasync_helper(fd,filp,mode,&dev->async_queue);
}
int globalfifo_open(struct inode *inode, struct file *filp)
{
/*将设备结构体指针赋值给文件私有数据指针*/
filp->private_data = globalfifo_devp;
return 0;
}
int globalfifo_release(struct inode *inode, struct file *filp)
{
globalfifo_fasync(-1,filp,0);/*将文件从异步通知列表里删除*/
return 0;
}
static long globalfifo_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
struct globalfifo_dev *dev = filp->private_data;/*获得设备结构体指针*/
switch (cmd)
{
case FIFO_CLEAR:
down(&sem); //获得信号量
dev->current_len = 0;
memset(dev->mem,0,GLOBALFIFO_SIZE);
up(&sem); //释放信号量
printk(KERN_INFO "globalfifo is set to zero\n");
break;
default:
return - EINVAL;
}
return 0;
}
static unsigned int globalfifo_poll(struct file *filp, poll_table *wait)
{
unsigned int mask = 0;
struct globalfifo_dev *dev = filp->private_data; /*获得设备结构体指针*/
down(&sem);
poll_wait(filp, &r_wait, wait);//添加读等待队列头
poll_wait(filp, &w_wait, wait);//添加写等待队列头
if(dev->current_len != 0)/*fifo非空*/
{
mask |= POLLIN | POLLRDNORM; /*标示数据可获得*/
}
if (dev->current_len != GLOBALFIFO_SIZE)/*fifo非满*/
{
mask |= POLLOUT | POLLWRNORM; /*标示数据可写入*/
}
up(&sem);
return mask;
}
static ssize_t globalfifo_read(struct file *filp, char __user *buf, size_t count,loff_t *ppos)
{
int ret;
struct globalfifo_dev *dev = filp->private_data; //获得设备结构体指针
DECLARE_WAITQUEUE(wait, current); //定义等待队列
down(&sem); //获得信号量
add_wait_queue(&r_wait, &wait); //进入读等待队列头
if (dev->current_len == 0)/* 如果FIFO为空，则进程进入睡眠等待 */
{
if (filp->f_flags &O_NONBLOCK)//非阻塞
{
ret = - EAGAIN;
goto out;
}
__set_current_state(TASK_INTERRUPTIBLE); //改变进程状态为睡眠
up(&sem);
schedule(); //调度其他进程执行
if (signal_pending(current))//如果是因为信号唤醒
{
ret = - ERESTARTSYS;
goto out2;
}
down(&sem);
}
if (count > dev->current_len)/* 拷贝到用户空间 */
count = dev->current_len;
if (copy_to_user(buf, dev->mem, count)) //从内核空间拷贝到用户空间
{
ret = - EFAULT;
goto out;
}
else
{
memcpy(dev->mem, dev->mem + count, dev->current_len - count); //fifo(管道)数据前移
dev->current_len -= count; //有效数据长度减少
printk(KERN_INFO "read %d bytes(s),current_len:%d\n", count, dev->current_len);
wake_up_interruptible(&w_wait); //唤醒写等待队列
ret = count;
}
out:
up(&sem); //释放信号量
out2:
remove_wait_queue(&w_wait, &wait); //从附属的等待队列头移除
set_current_state(TASK_RUNNING);
return ret;
}
/*globalfifo写操作*/
static ssize_t globalfifo_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
struct globalfifo_dev *dev = filp->private_data; //获得设备结构体指针
int ret;
DECLARE_WAITQUEUE(wait, current); //定义等待队列
down(&sem); //获取信号量
add_wait_queue(&w_wait, &wait); //进入写等待队列头
if (dev->current_len == GLOBALFIFO_SIZE)/* 如果FIFO已满则进入睡眠等待 */
{
if (filp->f_flags &O_NONBLOCK)//如果是非阻塞访问
{
ret = - EAGAIN;
goto out;
}
__set_current_state(TASK_INTERRUPTIBLE); //改变进程状态为睡眠
up(&sem);
schedule(); //调度其他进程执行
if (signal_pending(current))//如果是因为信号唤醒
{
ret = - ERESTARTSYS;
goto out2;
}
down(&sem); //获得信号量
}
/*从用户空间拷贝到内核空间*/
if (count > GLOBALFIFO_SIZE - dev->current_len)
count = GLOBALFIFO_SIZE - dev->current_len;
if (copy_from_user(dev->mem + dev->current_len, buf, count))
{
ret = - EFAULT;
goto out;
}
else
{
dev->current_len += count;
printk(KERN_INFO "written %d bytes(s),current_len:%d\n", count, dev->current_len);
wake_up_interruptible(&r_wait); //唤醒读等待队列
ret = count;
}
if(dev->async_queue)/*产生异步读信号*/
kill_fasync(&dev->async_queue,SIGIO,POLL_IN);
out:
up(&sem); //释放信号量
out2:
remove_wait_queue(&w_wait, &wait); //从附属的等待队列头移除
set_current_state(TASK_RUNNING);
return ret;
}
/*文件操作结构体*/
static const struct file_operations globalfifo_fops =
{
.owner = THIS_MODULE,
.read = globalfifo_read,
.write = globalfifo_write,
.unlocked_ioctl = globalfifo_ioctl,
.poll = globalfifo_poll,
.fasync=globalfifo_fasync,
.open = globalfifo_open,
.release = globalfifo_release,
};
/*初始化并注册cdev*/
static void globalfifo_setup_cdev(struct globalfifo_dev *dev, int index)
{
int err, devno = MKDEV(globalfifo_major, index);
cdev_init(&dev->cdev, &globalfifo_fops);
dev->cdev.owner = THIS_MODULE;
dev->cdev.ops = &globalfifo_fops;
err = cdev_add(&dev->cdev, devno, 1);
if (err)
printk(KERN_NOTICE "Error %d adding LED%d", err, index);
}
/*设备驱动模块加载函数*/
int globalfifo_init(void)
{
int ret;
dev_t devno;
ret = alloc_chrdev_region(&devno, 0, 1, "x4412-globalfifo-fasync");
globalfifo_major = MAJOR(devno);
if (ret < 0)
return ret;
/* 动态申请设备结构体的内存*/
globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);
if (!globalfifo_devp) /*申请失败*/
{
ret = - ENOMEM;
goto fail_malloc;
}
memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev));
globalfifo_setup_cdev(globalfifo_devp, 0);
cdev_class = class_create(THIS_MODULE,"x4412-globalfifo-fasync");
if(IS_ERR(cdev_class))
goto fail_class;
device_create(cdev_class,NULL,devno,NULL,"x4412-globalfifo-fasync");
return 0;
fail_class:
class_destroy(cdev_class);
fail_malloc:
unregister_chrdev_region(devno, 1);
return ret;
}
/*模块卸载函数*/
void globalfifo_exit(void)
{
device_destroy(cdev_class,MKDEV(globalfifo_major,0));
class_destroy(cdev_class);
cdev_del(&globalfifo_devp->cdev); /*注销cdev*/
kfree(globalfifo_devp); /*释放设备结构体内存*/
unregister_chrdev_region(MKDEV(globalfifo_major, 0), 1); /*释放设备号*/
}
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("www.9tripod.com");
module_init(globalfifo_init);
module_exit(globalfifo_exit);

复制代码

.fasync=globalfifo_fasync,

复制代码

struct fasync_struct *async_queue;

复制代码

static int globalfifo_fasync(int fd,struct file *filp,int mode)
{
struct globalfifo_dev *dev =filp->private_data;
return fasync_helper(fd,filp,mode,&dev->async_queue);
}
int globalfifo_release(struct inode *inode, struct file *filp)
{
globalfifo_fasync(-1,filp,0);/*将文件从异步通知列表里删除*/
return 0;
}

复制代码

kill_fasync(&dev->async_queue,SIGIO,POLL_IN);

复制代码

config X4412_GLOBALFIFO_FASYNC_DRIVER
tristate "x4412 globalfifo by fasync driver"
default m
help
compile for x4412 globalfifo by fasync driver,y for kernel,m for module.

复制代码

obj-$(CONFIG_X4412_GLOBALFIFO_FASYNC_DRIVER) += x4412-globalfifo-fasync.o

复制代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <signal.h>
#define S_IRUSR 00400
#define S_IWUSR 00200
void input_handler(int signum)
{
printf("signum is ；%d\n",signum);
}
int main()
{
int fd,oflags;
fd=open("/dev/x4412-globalfifo-fasync",O_RDWR,S_IRUSR | S_IWUSR);
if(fd != -1) {
/*启动信号驱动机制*/
signal(SIGIO,input_handler);/*让input_handler 处理SIGIO信号*/
fcntl(fd,F_SETOWN,getpid());//设置本进程为打开的文件的拥有者
oflags=fcntl(fd,F_GETFL);
fcntl(fd,F_SETFL,oflags|FASYNC);//对设备设置fasync标志
while(1)
{
sleep(100);
}
} else
{
printf("device open failed!\n");
}
return 0;
}

复制代码

[root@x4412 mnt]# insmod x4412-globalfifo-fasync.ko
[root@x4412 mnt]# ./x4412-globalfifo-fasync-app &
[1] 1186
[root@x4412 mnt]# echo 'www.9tripod.com' > /dev/x4412-globalfifo-fasync
[ 3935.793561] written 16 bytes(s),current_len:16
signum is ；29
[root@x4412 mnt]# echo 'www.9tripod.com' > /dev/x4412-globalfifo-fasync
[ 3938.655007] written 16 bytes(s),current_len:32
signum is ；29
[root@x4412 mnt]#

复制代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <signal.h>
void input_handler(int signum)
{
printf("signum is %d\n",signum);
}
int main()
{
signal(SIGINT,input_handler);//让input_handler处理SIGINT信号
signal(SIGTERM,input_handler);//让input_handler处理SIGTERM信号
while(1)
{
sleep(100);
}
return 0;
}

复制代码

arm-none-linux-gnueabi-gcc x4412-signal-app.c -o x4412-signal-app

复制代码

[root@x4412 mnt]# ./x4412-signal-app
signum is 2
signum is 2

复制代码

[root@x4412 mnt]# ./x4412-signal-app &
[1] 1179
[root@x4412 mnt]#
[root@x4412 mnt]# kill 1179
[root@x4412 mnt]# signum is 15
[root@x4412 mnt]#

复制代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <signal.h>
void input_handler(int signum)
{
char data[100];
int len;
//读取并输出STDIN_FILENO上的输入
len = read(STDIN_FILENO,&data,100);
data[len]=0;
printf("available input from x4412:%s\n",data);
}
int main()
{
int oflags;
signal(SIGIO,input_handler);//让input_handler处理SIGIO信号
fcntl(STDIN_FILENO,F_SETOWN,getpid());
oflags = fcntl(STDIN_FILENO,F_GETFL);
fcntl(STDIN_FILENO,F_SETFL,oflags | FASYNC);
while(1)
{
sleep(100);
}
return 0;
}

复制代码

arm-none-linux-gnueabi-gcc x4412-signal-stdin.c -o x4412-signal-stdin

复制代码

[root@x4412 mnt]# ./x4412-signal-stdin
I love x4412 board.
available input from x4412:I love x4412 board.
I love ibox board too.
available input from x4412:I love ibox board too.

复制代码

信号	值	含义
SIGHUP	1	挂起
SIGINT	2	终端中断
SIGQUIT	3	终端退出
SIGILL	4	无效命令
SIGTRAP	5	跟踪陷阱
SIGIOT	6	IOT陷阱
SIGBUS	7	BUS错误
SIGFPE	8	浮点异常
SIGKILL	9	强行终止（不能被捕获或忽略）
SIGUSR1	10	用户定义的信号1
SIGSEGV	11	无效的内存段处理
SIGUSR2	12	用户定义的信号2
SIGPIPE	13	半关闭管道发生写操作
SIGALRM	14	计时器到期
SIGTERM	15	终止
SIGSTKFLT	16	堆栈错误
SIGCHLD	17	子进程已经停止或退出
SIGCONT	18	如果停止了，继续执行
SIGSTOP	19	停止执行（不能被捕获或忽略）
SIGTSTP	20	终端停止信号
SIGTTIN	21	后台进程需要从终端读取输入
SIGTTOU	22	后台进程需要向从终端写出
SIGURG	23	紧急的套接字事件
SIGXCPU	24	超额使用CPU分配的时间
SIGXFSZ	25	文件尺寸超额
SIGVTALRM	26	虚拟时钟信号
SIGPROF	27	时钟信号描述
SIGWINCH	28	窗口尺寸变化
SIGIO	29	I/O
SIGPWR	30	断电重启