linux异步通知 -7

学习目标：

了解linux常用信号；

了解异步通知概念；

在前面代码基础上增加异步通知；

理解：

异步通知：举个例子吧。比如我想要买口罩，现在肺炎很厉害商店都没有卖的了，我在药店交押金预定，不用专门去药店问今天有没有，药店有口罩了售货员小姐姐会通知我。这种情况我认为就是异步通知。

同步通知：我去药店问小姐姐（也可以打电话问，就是我必须主动问人家），问完结果才罢休。

综上：同步和异步是针对我（操作者）来说的，我等待结果再返回是“同步”，不等结果就返回是“异步”。

延伸：

阻塞、非阻塞是针对等待结果的状态。

阻塞：等不到结果，就挂起。我要药店买口罩，药店没开门（等结果），我就在药店门口等着，药店没开门，我无法得知今天有没有口罩我就等，等待过程中我无聊就睡着了，除了等开门不干别的事。

非阻塞：等不到结果不挂起，一直等。我要药店买口罩，药店没开门（等结果），我就在药店门口等着，期间无聊我就玩手机。直到药店开门。

一般情况下，同步、异步和阻塞、非阻塞互相搭配使用。对于异步通知，一般通过挂接回调，当通知到了，执行回调函数。

比喻可能不准确，大家有更好的解释，可以写出来互相学习下哈。

参考：https://blog.csdn.net/weixin_45455015/article/details/100118258

1- linux信号的简单应用

a- linux信号的简单应用

这里通过按ctrl+c释放SIGINT信号，触发处理函数sigterm_handler()

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/time.h>
#include<unistd.h>
#include<errno.h>
#include <unistd.h> //read
#include <sys/ioctl.h> //ioctl
#include <signal.h>
//signal
void sigterm_handler(int signo)
{
printf("nsigNO:%dn",signo);
exit(0);
}
int main()
{
signal(SIGINT, sigterm_handler); //ctrl+c发送信号
signal(SIGTERM, sigterm_handler); //
while(1);
return 0;
}

Makefile

#Makefile
main: main.o
gcc -o main main.o
main.o:main.c
gcc -c main.c
clean:
rm -rf *.o main

b- 设置便准输入信号异步通知方式处理

主要分为3步：

I- 设置信号的处理函数。signal(SIGIO, input_handle);

II- 将信号与本进程绑定。fcntl(STDIN_FILENO, F_SETOWN, getpid()); 其中getpid()为获取本进程pid，获取其父进程的pid为getppid()。

III- 开启异步通知。这里分两小步：获取标准输入fd的标志位fcntl(STDIN_FILENO, F_GETFL);  设置标准输入fd为异步方式fcntl(STDIN_FILENO, F_SETFL, oflags | FASYNC);

通过上述设置后，每当有输入就调用inputhandle（）。这里的输入是异步的，程序不用一直等输入，而是不论你啥时候输入，只要有输入就干事情。

#include<stdio.h>
#include<stdlib.h> //exit()
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/time.h>
#include<unistd.h>
#include<errno.h>
#include <unistd.h> //read
#include <sys/ioctl.h> //ioctl
#include <signal.h>
//signal
void input_handle(int signo)
{
char data[100];
int len;
len = read(STDIN_FILENO, &data, 100);
data[len] = 0;
printf("input:%sn", data);
}
int main()
{
int oflags;
signal(SIGIO, input_handle); //信号SIGIO的处理函数input_handle
//printf("npid=%dn",getpid()); //打印当前进程的pid
fcntl(STDIN_FILENO, F_SETOWN, getpid()); //将当前进程与输入信号STDIN_FILENO绑定
/*开启标准输入异步通知*/
oflags = fcntl(STDIN_FILENO, F_GETFL); //获取标准输入的文件标志位
fcntl(STDIN_FILENO, F_SETFL, oflags | FASYNC);//设置标准输入为异步通知
while(1);
return 0;
}

Makefile文件同上。

2- 增加异步通知

分为用户态和内核态代码。

内核态：在写函数中，每次写完就释放信号量kill_fasync()，通知设备/dev/globalmem写操作完成了，用户态代码就执行回调函数。在释放函数中调用fasync_helper()释放异步资源。

用户态：设置/dev/globalmem设备为异步状态，当有异步信号到来执行回调函数input_handle()

执行情况：

1- 内核代码编译

make //编译内核代码
lsmod globalmem.ko //加载globalmem模块
mknod /dev/globalmem c 243 0 //在/dev/globalmem目录创建节点

2- 用户代码编译

make //编译用户态代码
./main //执行用户态代码

3- 效果

每执行玩一次下面语句就会释放一次信号量，调用异步通知挂接的回调函数。

echo "hello" > /dev/globalmem //向/dev/globalmem写东西

内核代态码：

C文件

//globalmem
#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/sched/signal.h> //signal_pending()头文件
#include<linux/init.h>
#include<linux/cdev.h>
#include <linux/slab.h>
//#include <linux/mutex.h> //增加互斥量
#include<linux/sem.h> //增加互斥量
#include <linux/workqueue.h> //等待队列
#include <linux/poll.h>
//poll()
#include<asm/io.h>
#include<asm/switch_to.h>
//#include<asm/uaccess.h>
#include <linux/uaccess.h>
#define GLOBALMEM_SIZE 0x1000 /*操作的mem内存大小，全局变量大小4k*/
#define MEM_CLEAR 0x1
/*ioctrl命令码*/
#define GLOBALMEM_MAJOR 243 /*设定globalmem的主设备号，查看已经注册的避免冲突cat /proc/devices*/
static int globalmem_major = GLOBALMEM_MAJOR;
/*globalmem结构体*/
struct globalmem_dev
{
struct cdev cdev; //字符设备结构体
unsigned int current_len; /*有效数据长度*/
unsigned char mem[GLOBALMEM_SIZE]; //大小
struct semaphore sem;
wait_queue_head_t r_wait; /*读等待队列头*/
wait_queue_head_t w_wait; /*写等待队列头*/
struct fasync_struct *async_queue; //异步通知结构体指针
};
struct globalmem_dev *globalmem_devp;
/*以下为文件操作：打开、释放、ioctrl、读写、定位*/
/*支持异步通知*/
static int globalmem_fasync(int fd, struct file *filp, int mode)
{
struct globalmem_dev *dev = filp->private_data;
printk(KERN_INFO "funt:%s enter!n",__FUNCTION__);
return fasync_helper(fd, filp, mode, &dev->async_queue);
}
/*文件打开操作*/
int globalmem_open(struct inode *inode, struct file *filp)
{
filp->private_data = globalmem_devp;
printk(KERN_INFO "funt:%s enter!n",__FUNCTION__);
return 0;
}
/*文件释放*/
int globalmem_release(struct inode *inode, struct file *filp)
{
printk(KERN_INFO "funt:%s enter!n",__FUNCTION__);
globalmem_fasync(-1, filp, 0);
return 0;
}
/*ioctrl操作*/
static long globalmem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)//和2.6内核不一样！！
{
struct globalmem_dev *dev = filp->private_data;
printk(KERN_INFO "funt:%s enter!n",__FUNCTION__);
switch(cmd)
{
case MEM_CLEAR: //增加信号量保护共享资源
/*获取信号量*/
if(down_interruptible(&dev->sem))
return -ERESTARTSYS;
/*共享资源操作*/
memset(dev->mem,0,GLOBALMEM_SIZE);
/*释放信号量*/
up(&dev->sem);
printk(KERN_INFO "globalmem is set to zeron");
break;
default:
return -EINVAL;
}
return 0;
}
/*读函数*/
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
int ret =0;
//unsigned long p = *ppos;
unsigned int count = size;
struct globalmem_dev *dev = filp->private_data;
DECLARE_WAITQUEUE(wait,current);
printk(KERN_INFO "funt:%s enter!n",__FUNCTION__);
/*获取信号量*/
down(&dev->sem);
add_wait_queue(&dev->r_wait, &wait); //加入读等待队列头
/*等待FIFO非空*/
while(dev->current_len == 0)
{
if(filp->f_flags & O_NONBLOCK)
{
ret
= -EAGAIN;
goto out;
}
__set_current_state(TASK_INTERRUPTIBLE);//改变进程状态
/*释放信号量*/
up(&dev->sem);
schedule(); //任务调度、切换
if(signal_pending(current))
{
ret = -ERESTARTSYS;
goto out2;
}
/*为保护共享资源互斥访问，再次获取信号量*/
down(&dev->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);
dev->current_len -= count;
printk(KERN_INFO "read %d butes, current_len:%dn",count,dev->current_len);
wake_up_interruptible(&dev->w_wait); //唤醒写等待队列
ret = count;
}
out:up(&dev->sem);
out2:remove_wait_queue(&dev->r_wait, &wait); //移除写等待队列
set_current_state(TASK_RUNNING);
return ret;
}
/*写函数--支持异步*/
static ssize_t globalmem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
int ret =0;
//unsigned long p = *ppos;
unsigned int count = size;
struct globalmem_dev *dev = filp->private_data;
DECLARE_WAITQUEUE(wait, current); //定义等待队列
printk(KERN_INFO "funt:%s enter!n",__FUNCTION__);
/*获取信号量*/
down(&dev->sem);
add_wait_queue(&dev->w_wait, &wait);
while(dev->current_len == GLOBALMEM_SIZE)
{
if(filp->f_flags & O_NONBLOCK)
{
ret = -EAGAIN;
goto out;
}
__set_current_state(TASK_INTERRUPTIBLE); //改变进程状态
/*释放信号量*/
up(&dev->sem);
/*任务调度、切换*/
schedule();
if(signal_pending(current))
{
ret = -ERESTARTSYS;
goto out2;
}
/*重新获取信号量*/
down(&dev->sem);
}
/*数据拷贝*/
if(count > GLOBALMEM_SIZE - dev->current_len)
count = GLOBALMEM_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, current_len:%dn",count,dev->current_len);
wake_up_interruptible(&dev->r_wait);
if(dev->async_queue)
{
kill_fasync(&dev->async_queue, SIGIO ,POLL_IN);
printk(KERN_INFO "FUNC:%s kill SIGIOn", __FUNCTION__);
}
ret = count;
}
out: up(&dev->sem);
out2: remove_wait_queue(&dev->w_wait, &wait);
set_current_state(TASK_RUNNING);
return ret;
}
/*文件定位*/
static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig)
{
loff_t ret = 0;
switch(orig)
{
/*从文件开头偏移*/
case 0:
if(offset < 0)
{
ret = -EINVAL;
break;
}
if((unsigned int)offset > GLOBALMEM_SIZE)
{
ret = -EINVAL;
break;
}
filp->f_pos = (unsigned int )offset;
ret = filp->f_pos;
break;
/*从当前位置偏移*/
case 1:
if(filp->f_pos + offset < 0)
{
ret = -EINVAL;
break;
}
if((filp->f_pos + offset) > GLOBALMEM_SIZE)
{
ret = -EINVAL;
break;
}
filp->f_pos += (unsigned int )offset;
ret = filp->f_pos;
break;
default:
ret = -EINVAL;
break;
}
return ret;
}
/*globalmem_pool驱动*/
static unsigned int globalmem_poll(struct file *filp, poll_table *wait)
{
unsigned int mask = 0;
struct globalmem_dev *dev = filp->private_data; /*获取设备结构体指针*/
/*获取信号量*/
down(&dev->sem);
/*临界区*/
poll_wait(filp, &dev->r_wait, wait);
poll_wait(filp, &dev->w_wait, wait);
if(dev->current_len != 0)
mask |= POLLIN | POLLRDNORM;
if(dev->current_len != GLOBALMEM_SIZE)
mask |= POLLOUT |
POLLWRNORM;
/*释放信号量*/
up(&dev->sem);
return mask;
}
/*文件操作结构体*/
static const struct file_operations globalmem_fops =
{
.owner = THIS_MODULE,
.llseek = globalmem_llseek,
.read = globalmem_read,
.write = globalmem_write,
.unlocked_ioctl = globalmem_ioctl,
.open = globalmem_open,
.release = globalmem_release,
.poll = globalmem_poll,
.fasync = globalmem_fasync,
};
/*初始化并向内核注册cdev*/
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
int err;
int devno = MKDEV(globalmem_major,index);
cdev_init(&dev->cdev,&globalmem_fops); //初始化cdev
dev->cdev.owner = THIS_MODULE;
dev->cdev.ops = &globalmem_fops;
err = cdev_add(&dev->cdev,devno,1);//向内核注册cdev
if(err)
{
printk(KERN_NOTICE "Err %d adding LED%d",err,index);
}
}
/*设备驱动模块加载*/
int globalmem_init(void)
{
int result;
dev_t devno = MKDEV(globalmem_major,0);//如果有主设备号，先求出设备号，向系统注册
if(globalmem_major)
{
result = register_chrdev_region(devno,1,"globalmem"); //向内核静态申请设备号，设备号devno已知
}
else
{
result = alloc_chrdev_region(&devno,0,1,"globalmem");//动态申请设备号，
globalmem_major = MAJOR(devno);//根据申请到的设备号求出主设备号
}
if(result < 0)
{
return result;
}
/*申请内存*/
globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
if(!globalmem_devp)
{
result = -ENOMEM;
goto fail_malloc;
}
memset(globalmem_devp,0,sizeof(struct globalmem_dev));
globalmem_setup_cdev(globalmem_devp,0);//向内核注册cdev
sema_init(&globalmem_devp->sem,1); /*初始化信号量*/
init_waitqueue_head(&globalmem_devp->r_wait); /*初始化读等待队列头*/
init_waitqueue_head(&globalmem_devp->w_wait); /*初始化写等待队列头*/
printk(KERN_INFO "module_init succ!n");
return 0;
fail_malloc:unregister_chrdev_region(devno,1);//解注册申请的设备号
return result;
}
/*模块卸载*/
void globalmem_exit(void)
{
cdev_del(&globalmem_devp->cdev);//解注册cdev
kfree(globalmem_devp);
unregister_chrdev_region(MKDEV(globalmem_major,0), 1);
printk(KERN_INFO "module_exit succ!n");
}
MODULE_AUTHOR("lhk");
MODULE_LICENSE("Dual BSD/GPL");
module_param(globalmem_major, int, S_IRUGO);
module_init(globalmem_init);
module_exit(globalmem_exit);

Makefile文件

ifneq ($(KERNELRELEASE),)
obj-m:=globalmem.o
else
KDIR:=/lib/modules/$(shell uname -r)/build
PWD:=$(shell pwd)
all:
make -C $(KDIR) M=$(PWD) modules
clean:
rm -rf *.ko *.o *.symvers *.cmd *.cmd.o *.mod.c *.order
endif

用户态代码

C文件

#include<stdio.h>
#include<stdlib.h> //exit()
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/time.h>
#include<unistd.h>
#include<errno.h>
#include <unistd.h> //read
#include <sys/ioctl.h> //ioctl
#include <signal.h>
//signal
void input_handle(int signo)
{
printf("recive a signal from globalmem, sigNO:%dn",signo);
}
int main()
{
int oflags;
int fd;
fd = open("/dev/globalmem", O_RDWR, S_IRUSR | S_IWUSR);
if(fd != -1)
{
signal(SIGIO, input_handle);
fcntl(fd, F_SETOWN, getpid());
oflags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, oflags | FASYNC);
while(1)
{
sleep(100);
}
}
else
{
printf("device open failn");
}
return 0;
}

Makefile文件

#Makefile
main: main.o
gcc -o main main.o
main.o:main.c
gcc -c main.c
clean:
rm -rf *.o main

最后

以上就是沉默黑夜为你收集整理的linux异步通知 -7的全部内容，希望文章能够帮你解决linux异步通知 -7所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。