内核和用户之间的共享内存

Question

我目前正在为RaspberryPi 3开发内核模块，并且是该领域的新手。这应该在上升沿或下降沿产生中断。在相应的ISR中，设置时间戳并生成信号以通知用户应用程序。 为了代码，我已经采取了信号。

我的目标是将时间戳的值写入共享内存，用户应用程序可以在输入信号之后将其读出，以便测量中断与用户应用程序中接收的信号之间的延迟。我已经研究过，但没有找到解决方案。如何将分配的内存的虚拟内核地址映射到用户应用程序以及需要执行哪些步骤？

提前致谢。

内核代码：

/****************************************************************************/
/* Kernelmodul Shared Memory                                                */
/****************************************************************************/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/types.h>

#include <linux/ioport.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>

// kmalloc
#include <linux/slab.h>
// ioremap
#include <asm/io.h>

/****************************************************************************/
/* Define block                                                             */
/****************************************************************************/

#define DriverAuthor        ""
#define DriverDescription   "Shared Memory"

#define InterruptPin        26
#define GPIO_PIN_DEV_STR   "PIN"
#define GPIO_PIN_STR       "Timestamp"

unsigned int *  timerAddr;
unsigned int    time = 0;
unsigned int *  SHMvirtual = 0;
 /****************************************************************************/
/* Module params declaration block                                          */
/****************************************************************************/

static short int gpio_pin = InterruptPin;

/****************************************************************************/
/* Interrupts variables block                                               */
/****************************************************************************/

short int irq_gpio_pin   = InterruptPin;
short int irq_enabled    = 0;    // this is only a flag

/****************************************************************************/
/* IRQ handler                                                              */
/****************************************************************************/

static irqreturn_t ISR(int irq, void *dev_id, struct pt_regs *regs) {


    unsigned long flags;

    // disable hard interrupts (remember them in flag 'flags')
    local_irq_save(flags);

    time = timerAddr[1];
    *SHMvirtual = time;

    // restore hard interrupts
    local_irq_restore(flags);

    return IRQ_HANDLED;
}

/****************************************************************************/
/* This function configures interrupts.                                     */
/****************************************************************************/

void configInterrupts(void) {


   if (gpio_request(gpio_pin, GPIO_PIN_STR))
   {
      printk(KERN_INFO "GPIO request faiure %d\n", gpio_pin);
      return;
   }

   if ( (irq_gpio_pin = gpio_to_irq(gpio_pin)) < 0 )
   {
      printk(KERN_INFO "GPIO to IRQ mapping faiure %d\n", gpio_pin);
      return;
   }

   printk(KERN_INFO "Mapped int %d\n", irq_gpio_pin);

   if (request_irq(irq_gpio_pin, (irq_handler_t ) ISR, (IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING), GPIO_PIN_STR,
                   GPIO_PIN_DEV_STR))
   {
      printk("Interrupt Request failure\n");
      return;
   }

   return;
}

/****************************************************************************/
/* This function releases interrupts.                                       */
/****************************************************************************/

void releaseInterrupt(void) {

   free_irq(irq_gpio_pin, GPIO_PIN_DEV_STR);
   gpio_free(gpio_pin);

   return;
}

/****************************************************************************/
/* Module init / cleanup block.                                             */
/****************************************************************************/

int initModule(void) {

   printk(KERN_INFO "Hello\n");
   configInterrupts();
   timerAddr = ioremap(0x3F003000, 0x20);
   SHMvirtual = (unsigned int *)kmalloc(sizeof(time),GFP_USER);

   return 0;
}


void cleanupModule(void) {

   printk(KERN_INFO "Goodbye\n");
   releaseInterrupt();
   kfree(SHMvirtual);
   return;
}


module_init(initModule);
module_exit(cleanupModule);


/****************************************************************************/
/* Module licensing/description block.                                      */
/****************************************************************************/
MODULE_LICENSE("GPL");
MODULE_AUTHOR(DriverAuthor);
MODULE_DESCRIPTION(DriverDescription);