异步消息日志串联异步消息通知机制

转载

mob64ca140c3859 2024-07-03 20:21:05

文章标签 异步消息日志串联 async #include 应用程序 linux 文章分类 云原生云计算

在前面几章说了下面几种访问节点的方法：

1.查询方式：这种耗资源

2.中断方式：只要按键没有按下，read就不会返回

3.poll方式：在指定的时间内，如果按键没有按下会返回

在上面几种方法中，都是应用程序主动的取read。那么有没有一种方法，由驱动去提醒应用程序呢？

有，这就是异步通知机制，它是使用signal来实现的。

先做一个实验,看看进程间是如何发信号的。

#include <stdio.h>
#include <signal.h>


void mysignalhandle(int signum)
{
	static int cnt = 0;
	printf("The signum is %d\n and send %d times \n",signum,++cnt);
}

int main(int argc,char **argv)
{
	signal(SIGUSR1, mysignalhandle);

	while(1){
		sleep(1000);
	}	
	return 0;
}

操作如下：

/test # ./signaltest &

/test # The signum is 10
and send 7 times //SIGUSR1的信号编号为10
/test # kill -10 600 //600为signaltest的进程号
/test # The signum is 10
and send 8 times
所以进程间可以通过kill命令，进程号，信号编号来进行发送信号，接受进程接受到信号就会调用相关的信号处理函数。

所以信号处理的要点：

1.注册信号处理函数

2.谁发？

2.发给谁？

4.怎么发？

那么如何编写异步通知驱动程序？

目标：按下按键的时候，驱动通知应用程序。

1.应用程序：注册信号处理函数

2.谁发：驱动来发

3.发给谁：应用程序。应用程序要告诉驱动应用程序的PID是多少

4.怎么发： kill_fasync函数来发送

先来看下驱动程序：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <asm/uaccess.h>
#include <linux/device.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <mach/regs-gpio.h>
#include <linux/gpio.h>
#include <linux/poll.h>


struct class *buttons_class;
struct device *buttons_dev;

static struct fasync_struct *buttons_async;


static DECLARE_WAIT_QUEUE_HEAD(button_waitq);//定义休眠队列
static volatile int ev_press = 0; //初始值为0，处于休眠状态

static unsigned char key_val;

struct pin_desc{
	unsigned int pin;
	unsigned int key_val;
};

struct pin_desc pins_desc[4] = {
	{S3C64XX_GPN(0),0x01},
	{S3C64XX_GPN(1),0x02},
	{S3C64XX_GPN(2),0x03},
	{S3C64XX_GPN(3),0x04},
};



static irqreturn_t button_irq_handle(int irq, void *devid)
{
	printk("irq = %d\n",irq);
	struct pin_desc * pindesc = (struct pin_desc *)devid;
	unsigned int pinval;

	pinval = gpio_get_value(pindesc->pin);

	if (pinval)
	{
		key_val = 0x80 | pindesc->key_val;
		printk("songkai\n");
	}
	else
	{
		key_val = pindesc->key_val;
		printk("anxia\n");
	}

	ev_press = 1;   //唤醒              
    wake_up_interruptible(&button_waitq);  

	kill_fasync(&buttons_async, SIGIO, POLL_IN);//向应用程序发送信号在有按键按下后告诉应用程序，SIGIO表示IO口有数据变化
	return IRQ_HANDLED;
}


static int buttons_drv_open(struct inode *inode, struct file *file)
{
	printk("buttons_drv_open \n");

	request_irq(IRQ_EINT(0),button_irq_handle,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "PAD1", &pins_desc[0]);
	request_irq(IRQ_EINT(1),button_irq_handle,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "PAD2", &pins_desc[1]);
	request_irq(IRQ_EINT(2),button_irq_handle,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "PAD3", &pins_desc[2]);
	request_irq(IRQ_EINT(3),button_irq_handle,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "PAD4", &pins_desc[3]);

	return 0;
}

static ssize_t buttons_drv_read( struct file *file,
			  char __user *buffer,
			  size_t len,
			  loff_t *offset )
{
	if (len != 1)
		return -EINVAL;
	
	wait_event_interruptible(button_waitq, ev_press);//进入睡眠

	ev_press = 0;
	copy_to_user(buffer, &key_val, 1);


	return 1;
}

int buttons_drv_release(struct inode *inode, struct file *file)
{
	free_irq(IRQ_EINT(0),&pins_desc[0]);
	free_irq(IRQ_EINT(1),&pins_desc[1]);
	free_irq(IRQ_EINT(2),&pins_desc[2]);
	free_irq(IRQ_EINT(3),&pins_desc[3]);

	return 0;
}


static unsigned int buttons_drv_poll(struct file *file, poll_table *wait)
{
	unsigned int mask = 0;

	poll_wait(file, &button_waitq, wait);//到这里还没有进入休眠

	if (ev_press)
		mask |= POLLIN | POLLWRNORM;//mask是返回应用程序poll的返回值,mask一定要和应用程序中的events相对应，不然还会进行超时

	return mask;
}


static int buttons_drv_fasync(int fd, struct file *filp, int on)
{
	return fasync_helper(fd, filp, on, &buttons_async);//应用程序的进程ID保存在buttons_async中，这个由内核帮助设置
}


static struct file_operations buttons_fops = {
    .owner   =   THIS_MODULE,    
    .open    =   buttons_drv_open,
    .read    =   buttons_drv_read,
    .release =   buttons_drv_release,
    .poll    =   buttons_drv_poll,
    .fasync  =   buttons_drv_fasync,
};


int major;
static int __init buttons_drv_init(void)
{
	printk("buttons_drv_init \n");
	major = register_chrdev(0,"buttons",&buttons_fops);
	buttons_class = class_create(THIS_MODULE,"buttons");
	buttons_dev = device_create(buttons_class,NULL,MKDEV(major,0),NULL,"buttons");
	
	return 0;
}

static void __exit buttons_drv_exit(void)
{
	device_destroy(buttons_class,MKDEV(major,0));
	class_destroy(buttons_class);
	unregister_chrdev(major,"buttons");
}

module_init(buttons_drv_init);
module_exit(buttons_drv_exit);

MODULE_LICENSE("GPL");

为了使设备支持异步通知机制，驱动程序中涉及以下3项工作：

1. 支持

F_SETOWN命令，能在这个控制命令处理中设置filp->f_owner为对应进程ID。不过此项工作已由内核完成，设备驱动无须处理。

2. 支持F_SETFL命令的处理，每当FASYNC标志改变时，驱动程序中的fasync()函数将得以执行。

驱动中应该实现fasync()函数。也就是上面最终调用的fasync_helper函数，这个函数帮助我们设置了应用程序的进程ID

3. 在设备资源可获得时，调用kill_fasync()函数激发相应的信号

应用程序所要做的工作：

fcntl(fd, F_SETOWN, getpid()); // 告诉驱动，发给谁

Oflags = fcntl(fd, F_GETFL); //获取当前的FLAGS

fcntl(fd, F_SETFL, Oflags | FASYNC); // 改变fasync标记，最终会调用到驱动的faync > fasync_helper：初始化/释放fasync_struct，也就是上面的buttons_async

应用程序实现如下：

#include <stdio.h>
#include <signal.h>
#include <fcntl.h>


int fd;

void mysignalhandle(int signum)
{
	unsigned int key_val;
	read(fd, &key_val, 1);
	printf("key_val = 0x%x\n", key_val);
}

int main(int argc,char **argv)
{
	int Oflags;
	fd = open("/dev/buttons", O_RDWR);
	if (fd < 0)
	{
		printf("can't open!\n");
	}

	fcntl(fd, F_SETOWN, getpid());  // 告诉驱动，发给谁
	Oflags = fcntl(fd, F_GETFL);    //获取当前的FLAGS
	fcntl(fd, F_SETFL, Oflags | FASYNC);  // 改变fasync标记，最终会调用到驱动的faync > fasync_helper：初始化/释放fasync_struct，也就是上面的buttons_async
	
	signal(SIGIO, mysignalhandle);

	while(1){
		sleep(1000);
	}	
	return 0;
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。