Come aggiungere la funzione fasync al codice del modulo del kernel?

Question

Kit: Beagle Bone Nero, OS: Angstrom, kernel:

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 

voglio aggiungere fasync funzione per il mio modulo del kernel, ma non funziona bene. Sotto il codice è da internet e l'ho modificato (prova ad aggiungere fasync). Può funzionare su Beagle Bone Black. Semplifico le funzioni write(), read() e sondaggio(). E metti kill_fasync() nel gestore 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); 

Trovo anche questo codice spazio utente, si è compilato per 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; 
} 

E poi a caricare il modulo al mio Beagle Bone Nero, fare come di seguito:

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 

Faccio qualche interruzione sul GPIO corrispondente e quindi mostra SIGIO occurs!. Ma il problema è che devo eseguire cat /proc/fortune prima di eseguire il codice dello spazio utente (a.out). E non sempre funziona come sopra. Di solito ho bisogno di rmmod - insmod - cat - a.out per due volte e quindi il codice fasync può funzionare. Il dmesg è qui sotto:

[ 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 

La mia domanda è per questo che deve eseguire cat /proc/fortune prima che il codice dello spazio utente esegue? Qualche modo migliore? Come farlo funzionare stabilmente? Come evitare di eseguire il ciclo (rmmod - insmod - cat - a.out) per due volte?

aggiungo un po 'if-else intorno fortune_async_queue, perché se io semplicemente uso fasync_helper() e kill_fasync(), fortune_async_queue sarà sempre null. E per questa funzione: static int fortune_fasync(int fd, struct file *file, int on), ho trovato che il suo ultimo parametro on è sempre 0, perché? Devo impostarlo manualmente su 1, come sopra il codice: fasync_helper(fd, file, 1, &fortune_async_queue)

Answer 1

Si sta utilizzando "insmod" che accetta i percorsi su file ma le dipendenze non vengono caricate automaticamente. Pertanto, è necessario eseguire cat/proc/fortune prima che il codice di spazio utente venga eseguito per il caricamento delle dipendenze.

Si può provare "modprobe" al posto di "insmod". Caricherà le dipendenze per impostazione predefinita.

Per impostazione predefinita, le notifiche asincrone per il descrittore di file sono disattivate. Pertanto, su = 0 sempre.