Как добавить функцию fasync в код модуля ядра?

Question

Комплект: Beagle Bone Черный, ОС: Ангстрем, ядро:

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 в мой модуль ядра, но он не работает хорошо. Ниже код из Интернета, и я его модифицировал (попробуйте добавить fasync). Он может работать на Beagle Bone Black. Я упрощаю функции 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); 

Я также нахожу это пользовательского пространства код, он компилируется в a.out:

#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <stdio.h> 
#include <poll.h> 
#include <signal.h> 
#include <sys/types.h> 
#include <unistd.h> 
#include <fcntl.h> 


int fd; 

void my_signal_io_fun(int signum) 
{ 
    printf("SIGIO occurs!\n"); 
} 

void my_signal_int_fun(int signum) 
{ 
    printf("signum: 0x%x\n", signum); 
    close(fd); 
    exit(signum); 
} 

int main(int argc, char **argv) 
{ 
    unsigned char key_val; 
    int ret; 
    int Oflags; 

    signal(SIGIO, my_signal_io_fun); 
    signal(SIGINT, my_signal_int_fun); 

    fd = open("/proc/fortune", O_RDWR); 
    if (fd < 0) 
    { 
     printf("can't open!\n"); 
    } 
    printf("open OK, fd = 0x%x\n", fd); 
    fcntl(fd, F_SETOWN, getpid()); 
    Oflags = fcntl(fd, F_GETFL); 
    fcntl(fd, F_SETFL, Oflags | FASYNC); 

    while (1) 
    { 
     sleep(1000); 
    } 

    return 0; 
} 

А потом загрузить модуль на мой Бигль Bone черный, сделать, как показано ниже:

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 occurs!. Но проблема в том, что я должен сначала выполнить cat /proc/fortune перед запуском кода пространства пользователя (a.out). И это не всегда работает, как указано выше. Обычно мне нужно 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_async_queue, потому что если я просто использовать fasync_helper() и kill_fasync(), fortune_async_queue будет всегда null. И для этого func: static int fortune_fasync(int fd, struct file *file, int on), я обнаружил, что его последний параметр on всегда 0, почему? Я должен вручную установить его на 1, как и выше: fasync_helper(fd, file, 1, &fortune_async_queue)

Answer 1

Вы используете «insmod», который принимает пути к файлу, но зависимости не загружаются автоматически. Поэтому вам необходимо выполнить cat/proc/fortune до того, как код пространства пользователя будет выполняться для загрузки зависимостей.

Вы можете попробовать «modprobe» вместо «insmod». Он будет загружать зависимости по умолчанию.

По умолчанию асинхронные уведомления для файлового дескриптора отключены. Следовательно, on = 0 всегда.