Kernel 如何将fasync函数添加到内核模块代码中？

套件：比格犬骨黑，操作系统：埃，内核：

root@beaglebone:~# uname -a
Linux beaglebone 3.12.9-00018-g9bdb229-dirty #67 SMP Sat Apr 18 11:45:30 CST 2015 armv7l GNU/Linux

我想将fasync函数添加到我的内核模块中，但它不能很好地工作。下面的代码来自internet，我对其进行了修改（尝试添加fasync）。它可以在小猎犬的骨头上跑。我简化了write（）、read（）和poll（）函数。并将kill_fasync（）放入irq处理程序中

#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/cdev.h>
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <linux/vmalloc.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/pci.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/irq.h>

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Fortune Cookie Kernel Module");
MODULE_AUTHOR("M. Tim Jones");

#define MAX_BUF_LENGTH       PAGE_SIZE

static struct proc_dir_entry *proc_entry;
static char *fortune_buf;  // Space for fortune strings
static int write_index;   // Index to write next fortune
static int read_index;    // Index to read next fortune

static DEFINE_SPINLOCK(fortune_lock);
static DECLARE_WAIT_QUEUE_HEAD(fortune_wait);
static volatile unsigned long fortune_data_flag;    /* our output to the world    */
static struct fasync_struct *fortune_async_queue = NULL;


#define GPIO2_START_ADDR 0x481ac000
#define GPIO2_SIZE (0x481adfff - GPIO2_START_ADDR)

#define CM_PER_START_ADDR 0x44e00000
#define CM_PER_SIZE       0x400
#define CM_PER_GPIO2_CLKCTRL 0xb0   // page 948

#define GPIO_IRQSTATUS_0 0x2c
#define GPIO_IRQSTATUS_1 0x30
#define GPIO_DATAIN      0x138  // page 4657
#define GPIO_OE          0x134  // page 4656
#define GPIO_FALLINGDETECT 0x14c
#define GPIO_DEBOUNCENABLE 0x150    // page 4663
#define GPIO_DEBOUNCINGTIME 0x154   // page 4664

#define PIN_A_GPIO 68 // is on BBB connector P8 pin10/TIMER6/GPIO2_4    
#define PIN_A_FLAGS GPIOF_IN
#define PIN_A_LABEL "HI_PIN_A"  // when floating, its level is high, 3.19~3.20V

#define PIN_B_GPIO 69 // is on BBB connector P8 pin9/TIMER5/GPIO2_5
#define PIN_B_FLAGS GPIOF_IN
#define PIN_B_LABEL "HI_PIN_B"

void __iomem *mem;

static irqreturn_t irq_handler_pin_a (int irq, void *dev_id)
{
    int regval;
    int regval_a, regval_b;

    regval = ioread32 (mem + GPIO_DATAIN);
    printk (KERN_DEBUG "interrupt: Hello from irq_handler_pin_a. The GPIO b read value is %x - %d \n", regval, (regval & 0x20) >> 5);
    regval_a = (regval & 0x10) >> 4;
    regval_b = (regval & 0x20) >> 5;

    printk(KERN_DEBUG "irq 0: fortune_async_queue  is 0x%p", fortune_async_queue);
    if(regval_a == regval_b) {
        printk (KERN_DEBUG "interrupt: 1 \n");
    } else {
        printk (KERN_DEBUG "interrupt: 2 \n");
    }

    kill_fasync(&fortune_async_queue, SIGIO, POLL_IN);
    printk(KERN_DEBUG "irq 1: fortune_async_queue  is 0x%p", fortune_async_queue);

    return IRQ_HANDLED;
}

static int gpio_interrupt_init (void)
{
   ...
}

static void gpio_interrupt_exit(void)
{
    printk ("HI: Releasing IRQ resources...\n");

    iounmap (mem);
    free_irq (gpio_to_irq (PIN_A_GPIO), NULL);
    gpio_free (PIN_A_GPIO);
    gpio_free (PIN_B_GPIO);

    printk (KERN_DEBUG "Goodbye gpio_interrupt!\n");
}


ssize_t fortune_write( struct file *filp, const char __user *buff,
                       unsigned long len, void *data )
{
    printk(KERN_INFO "fortune_write() executes\n");

    return len;
}

ssize_t fortune_read(struct file *file, char *buf, size_t count, loff_t *f_pos)
{
    int len;
    printk(KERN_INFO "fortune_read() executes\n");

    return len;
}

static unsigned int fortune_poll(struct file *file, poll_table *wait)
{
    printk(KERN_INFO "fortune_poll() executes\n");
    return 0;
}

static int fortune_fasync(int fd, struct file *file, int on)
{
    printk("fortune_fasync() executes\n");
    if(!fortune_async_queue)
    {
        if (fasync_helper(fd, file, 1, &fortune_async_queue) >= 0)
        {
            printk(KERN_DEBUG "fasync 0: fasync_helper works. fortune_async_queue is 0x%p", fortune_async_queue);
            return 0;
        }
        else
        {
            printk(KERN_DEBUG "fasync 1: fasync_helper doesn't work. fortune_async_queue is 0x%p", fortune_async_queue);
            return -EIO;
        }
    }
    else
    {
        printk(KERN_DEBUG "fasync 2: fasync_helper doesn't work. fortune_async_queue is 0x%p", fortune_async_queue);
    }

}

static int fortune_release(struct inode *inode, struct file *file)
{
    struct fortune_dev *devp;

    devp = file->private_data;
    fortune_fasync(-1, file, 0);

    file->private_data = NULL;
    return 0;
}
static int fortune_open(struct inode *inode, struct file *file)
{
    return 0;
}

static const struct file_operations proc_test_fops = {
    .owner        = THIS_MODULE,
    .open         = fortune_open,
    .read         = fortune_read,
    .write        = fortune_write,
    .poll          = fortune_poll,
    .release      = fortune_release,
    .fasync       = fortune_fasync,
};

int __init init_fortune_module( void )
{
    int ret = 0;

    gpio_interrupt_init();

    fortune_buf = (char *)vmalloc( MAX_BUF_LENGTH );
    if (!fortune_buf) {
        ret = -ENOMEM;
    } else {
        memset( fortune_buf, 0, MAX_BUF_LENGTH );
        proc_entry = proc_create( "fortune", 0644, NULL, &proc_test_fops );

        if (proc_entry == NULL) {
            ret = -ENOMEM;
            vfree(fortune_buf);
            printk(KERN_INFO "fortune: Couldn't create proc entry\n");
        } else
            write_index = 0;
            read_index = 0;
            printk(KERN_INFO "fortune: Module loaded.\n");
        }

    return ret;
}

void __exit exit_fortune_module( void )
{
    gpio_interrupt_exit();
    proc_remove(proc_entry);
    vfree(fortune_buf);
    printk(KERN_INFO "fortune: Module unloaded.\n");
}

module_init( init_fortune_module );
module_exit( exit_fortune_module );

然后我将模块上传到我的Beagle Bone Black，如下所示：

root@beaglebone:~# insmod fasync_kernel.ko
root@beaglebone:~# cat /proc/fortune
root@beaglebone:~# ./a.out
open OK, fd = 0x3
SIGIO occurs!
SIGIO occurs!
SIGIO occurs!
SIGIO occurs!
^Csignum: 0x2

我在相应的GPIO上进行了一些中断，然后它显示出现了

SIGIO。但问题是，在运行用户空间代码（
a.out
）之前，我必须先执行
cat/proc/fortune
。而且它并不总是像上面那样工作。通常我需要
rmmod-insmod-cat-a.out
两次，然后fasync代码就可以工作了。dmesg如下所示：

[ 5512.325893] fortune: Module loaded.
[ 5514.950859] fortune_read() executes
[ 5514.950932] fortune_fasync() executes
[ 5518.915844] interrupt: Hello from irq_handler_pin_a. The GPIO b read value is f2d - 1
[ 5514.950961] fasync 0: fasync_helper works. fortune_async_queue is 0xdf63eb18
[ 5518.915881] irq 0: fortune_async_queue  is 0xdf63eb18
[ 5518.915895] interrupt: 2
[ 5518.915950] irq 1: fortune_async_queue  is 0xdf63eb18
[ 5519.610571] interrupt: Hello from irq_handler_pin_a. The GPIO b read value is f2d - 1
[ 5519.610601] irq 0: fortune_async_queue  is 0xdf63eb18
[ 5519.610612] interrupt: 2
[ 5519.610666] irq 1: fortune_async_queue  is 0xdf63eb18
[ 5520.260265] interrupt: Hello from irq_handler_pin_a. The GPIO b read value is f0d - 0
[ 5520.260295] irq 0: fortune_async_queue  is 0xdf63eb18
[ 5520.260306] interrupt: 1
[ 5520.260357] irq 1: fortune_async_queue  is 0xdf63eb18
[ 5521.185887] interrupt: Hello from irq_handler_pin_a. The GPIO b read value is f0d - 0
[ 5521.185916] irq 0: fortune_async_queue  is 0xdf63eb18
[ 5521.185926] interrupt: 1
[ 5522.777769] fortune_fasync() executes
[ 5521.185976] irq 1: fortune_async_queue  is 0xdf63eb18
[ 5522.777812] fasync 2: fasync_helper doesn't work. fortune_async_queue is 0xdf63eb18

我的问题是，为什么我必须在执行用户空间代码之前执行
cat/proc/fortune
？还有更好的办法吗？如何使其稳定运行？如何避免循环（
rmmod-insmod-cat-a.out
）运行两次

我在
fortune\u async\u队列
周围添加了一些if-else，因为如果我简单地使用
fasync\u helper（）
和
kill\u fasync（）
，
fortune\u async\u队列
将始终是
null
。对于这个函数：
static int fortune\u fasync（int fd，struct file*file，int on）
，我发现它在

上的最后一个参数

总是0，为什么？我必须手动将其设置为1，就像上面的代码：
fasync\u helper（fd、file、1和fortune\u async\u queue）
您使用的是“insmod”，它接受文件路径，但不会自动加载依赖项。因此，在执行用户空间代码以加载依赖项之前，必须先执行cat/proc/fortune

您可以尝试使用“modprobe”代替“insmod”。默认情况下，它将加载依赖项

默认情况下，文件描述符的异步通知处于关闭状态。因此，on=0总是。
关于你的最后一句话，我不明白。那么在什么条件下“开”将是1？
[ 5512.325893] fortune: Module loaded.
[ 5514.950859] fortune_read() executes
[ 5514.950932] fortune_fasync() executes
[ 5518.915844] interrupt: Hello from irq_handler_pin_a. The GPIO b read value is f2d - 1
[ 5514.950961] fasync 0: fasync_helper works. fortune_async_queue is 0xdf63eb18
[ 5518.915881] irq 0: fortune_async_queue  is 0xdf63eb18
[ 5518.915895] interrupt: 2
[ 5518.915950] irq 1: fortune_async_queue  is 0xdf63eb18
[ 5519.610571] interrupt: Hello from irq_handler_pin_a. The GPIO b read value is f2d - 1
[ 5519.610601] irq 0: fortune_async_queue  is 0xdf63eb18
[ 5519.610612] interrupt: 2
[ 5519.610666] irq 1: fortune_async_queue  is 0xdf63eb18
[ 5520.260265] interrupt: Hello from irq_handler_pin_a. The GPIO b read value is f0d - 0
[ 5520.260295] irq 0: fortune_async_queue  is 0xdf63eb18
[ 5520.260306] interrupt: 1
[ 5520.260357] irq 1: fortune_async_queue  is 0xdf63eb18
[ 5521.185887] interrupt: Hello from irq_handler_pin_a. The GPIO b read value is f0d - 0
[ 5521.185916] irq 0: fortune_async_queue  is 0xdf63eb18
[ 5521.185926] interrupt: 1
[ 5522.777769] fortune_fasync() executes
[ 5521.185976] irq 1: fortune_async_queue  is 0xdf63eb18
[ 5522.777812] fasync 2: fasync_helper doesn't work. fortune_async_queue is 0xdf63eb18