如何在内核空间和用户空间之间使用mmap和proc共享内存技术

Question

我正在开发一个Linux内核模块。我想使用和文件系统在内核和用户空间之间共享内存。我已经实现了一些部分，但不知道如何完成它。

我想在内核模块中写入一些东西（），并在用户空间中读取它们（读取文件并保存文件）。我不知道的意思；我应该实现还是其他什么？

这是我的示例代码（适用于Linux 3.16）：

#include <linux/version.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/seq_file.h>

#define PROC_MEMSHARE_DIR "memshare"
#define PROC_MEMSHARE_INFO "phymem_info"
#define PROC_MMAP_FILE "mmap"

/* alloc one page. 4096 bytes */
#define PAGE_ORDER 0
/* this value can get from PAGE_ORDER */
#define PAGES_NUMBER 1

struct proc_dir_entry *proc_memshare_dir ;
unsigned long kernel_memaddr = 0;
unsigned long kernel_memsize= 0;

int proc_mmap(struct file *filp, struct vm_area_struct *vma)
{
    unsigned long page;
    page = virt_to_phys((void*)kernel_memaddr) >> PAGE_SHIFT;

    if (remap_pfn_range(vma, vma->vm_start, page, (vma->vm_end - vma->vm_start),
                vma->vm_page_prot))
    {
        printk("remap failed...");
        return -1;
    }
    vma->vm_flags |= (VM_DONTDUMP|VM_DONTEXPAND);
    printk("remap_pfn_rang page:[%lu] ok.\n", page);
    return 0;
}

static int proc_show_meminfo(struct seq_file *m, void *v) {
    seq_printf(m, "%08lx %lu\n",__pa(kernel_memaddr), kernel_memsize);
    return 0;
}

static int proc_open_meminfo(struct inode *inode, struct  file *file) {
    return single_open(file, proc_show_meminfo, NULL);
}

static const struct file_operations read_phymem_info_fops = {
    .owner = THIS_MODULE,
    .open = proc_open_meminfo,
    .read = seq_read,
    .llseek = seq_lseek,
    .release = seq_release
};

static const struct file_operations proc_mmap_fops = {
    .owner = THIS_MODULE,
    .mmap = proc_mmap
};

static int __init init(void)
{
    /* build proc dir "memshare"and two proc files: phymem_addr, phymem_size in the dir */
    proc_memshare_dir = proc_mkdir(PROC_MEMSHARE_DIR, NULL);
    proc_create_data(PROC_MEMSHARE_INFO, 0, proc_memshare_dir, &read_phymem_info_fops,NULL);
    proc_create_data(PROC_MMAP_FILE, 0, proc_memshare_dir, &proc_mmap_fops,NULL);

    /* alloc one page */
    kernel_memaddr =__get_free_pages(GFP_KERNEL, PAGE_ORDER);
    if (!kernel_memaddr) {
        printk("Allocate memory failure!/n");
    } else {
        SetPageReserved(virt_to_page(kernel_memaddr));
        kernel_memsize = PAGES_NUMBER * PAGE_SIZE;
        printk("Allocate memory success!. The phy mem addr=%08lx, size=%lu\n", __pa(kernel_memaddr), kernel_memsize);
    }
    return 0;
}

static void __exit fini(void)
{
    printk("The content written by user is: %s\n", (unsigned char*) kernel_memaddr);
    ClearPageReserved(virt_to_page(kernel_memaddr));
    free_pages(kernel_memaddr, PAGE_ORDER);
    remove_proc_entry(PROC_MEMSHARE_INFO, proc_memshare_dir);
    remove_proc_entry(PROC_MEMSHARE_DIR, NULL);
    return;
}
module_init(init);
module_exit(fini);
MODULE_LICENSE("GPL");
MOUDLE_AUTHOR("wack");
MODULE_DESCRIPTION("Kernel memory share module.");

这里是用户空间程序：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mman.h>

int main(int argc, char *argv[])
{
    char *str ;
    if (argc != 2) {
        printf("Usage: %s string\n", argv[0]);
        return 0;
    }

    unsigned long phymem_addr, phymem_size;
    char *map_addr;
    char s[256];
    int fd;

    /*get the physical address & size of allocated memory in kernel*/
    fd = open("/proc/memshare/phymem_info", O_RDONLY);
    if (fd < 0) {
        printf("cannot open file /proc/memshare/phymem_info\n");
        return 0;
    }
    read(fd, s, sizeof(s));
    sscanf(s, "%lx %lu", &phymem_addr,&phymem_size);
    close(fd);

    printf("phymem_addr=%lx, phymem_size=%lu\n", phymem_addr, phymem_size);
    /*memory map*/
    int map_fd = open("/proc/memshare/mmap",  O_RDWR|O_SYNC);
    if (map_fd < 0) {
        printf("cannot open file /proc/memshare/mmap\n");
        return -1;
    }
    map_addr = mmap(NULL, phymem_size, PROT_READ|PROT_WRITE, MAP_SHARED, map_fd, phymem_addr);
    if (map_addr ==MAP_FAILED) {
        perror("mmap");
        printf("MAP_FAILED : %s",map_addr);
        close(map_fd);
        return -1;
    } else{
        printf("mmap: %s \n",map_addr);
        printf("addr: %p \n",map_addr);
        printf("addr: %d \n",*map_addr);
    }
    //memcpy(map_addr, argv[1],sizeof(argv));
    strcpy(map_addr,argv[1]);
    memcpy(str,map_addr,256);
    printf("str is :%s \n",str);
    int ret = munmap(map_addr, phymem_size);
    if (ret) {
        printf("munmap failed:%d \n",ret);
    }
    close(map_fd);
    return 0;
}

- wack

---

我不太明白：你已经实现了从你的proc文件中读取（内核向其写入，用户从中读取）。那么问题是什么？你想允许用户写入你的proc文件吗？ - Tsyvarev

我想在内核模块中编写proc文件，但是我不知道该怎么做。这段代码只能读取文件，无法写入...你能告诉我如何将内核消息转储到proc文件吗？（实际上，我想将sk_buff转储到proc文件，并在用户空间中读取它） - wack

事实上，这正是我想知道的。在 fops.write 中我应该做什么？我如何在内核模块中调用此方法 fops.write？ - wack

Tsyvarev，非常感谢。我想我知道如何读写这个内存了。但是我还有一个问题。如果我要在内核模块中写入内存并从用户空间同时读取它，该怎么办？如果内存已满，我该怎么办？ - wack

非常感谢，我想我知道该怎么做了~ - wack

Answer 1

我自己能做到的最好：

• 在这个问题中，我想要将 sk_buff 写入共享内存，并从用户空间读取它。
• 在这里，我使用 netfilter 钩子 PRE_ROUTING，并且在我的钩子中可以获取 skb。
• 关于如何写入共享内存，在用户 Tsyvarev 建议下，我可以直接写入我 malloc 的内存。

首先 malloc 共享内存：

kernel_memaddr = __get_free_pages(GFP_KERNEL, PAGE_ORDER);  //or use kmalloc vmalloc
SetPageReserved(virt_to_page(kernel_memaddr));

用户空间需要知道内存物理地址（proc read）：

static int proc_show_meminfo(struct seq_file *m, void *v) {
    seq_printf(m, "%08lx %lu\n",__pa(kernel_memaddr), kernel_memsize);
    return 0;
}

在proc_mmap()中，我们需要remap_pfn_range内存：

int proc_mmap(struct file *filp, struct vm_area_struct *vma)
{
    unsigned long page;
    page = virt_to_phys((void *)kernel_memaddr) >> PAGE_SHIFT;

    if( remap_pfn_range(vma, vma->vm_start, page, (vma->vm_end - vma->vm_start), 
         vma->vm_page_prot) )
    {
        printk("remap failed...");
        return -1;
    }
    vma->vm_flags |= (VM_DONTDUMP|VM_DONTEXPAND);
    printk("remap_pfn_rang page:[%lu] ok.\n", page);
    return 0;
}

回复内容存在敏感词^**$它即可：

memcpy((void *)(memaddr + offset),data, dataLen);   //data is what you want to write

在用户空间，当我们获取到kernel_memaddr后，使用mmap()来获取地址

map_addr = mmap(NULL, phymem_size, PROT_READ|PROT_WRITE, MAP_SHARED, map_fd, phymem_addr);
memcpy(str,map_addr,256);

- wack