Kernel Space - User Space Interfaces_Mmap

http://people.ee.ethz.ch/~arkeller/linux/kernel_user_space_howto.html#s8

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/debugfs.h>

#include <linux/mm.h>  /* mmap related stuff */

struct dentry  *file1;

struct mmap_info {
    char *data;    /* the data */
    int reference;       /* how many times it is mmapped */      
};


/* keep track of how many times it is mmapped */

void mmap_open(struct vm_area_struct *vma)
{
    struct mmap_info *info = (struct mmap_info *)vma->vm_private_data;
    info->reference++;
}

void mmap_close(struct vm_area_struct *vma)
{
    struct mmap_info *info = (struct mmap_info *)vma->vm_private_data;
    info->reference--;
}

/* nopage is called the first time a memory area is accessed which is not in memory,
 * it does the actual mapping between kernel and user space memory
 */
struct page *mmap_nopage(struct vm_area_struct *vma, unsigned long address, int *type)
{
    struct page *page;
    struct mmap_info *info;
    /* is the address valid? */
    if (address > vma->vm_end) {
        printk("invalid address\n");
        return NOPAGE_SIGBUS;
    }
    /* the data is in vma->vm_private_data */
    info = (struct mmap_info *)vma->vm_private_data;
    if (!info->data) {
        printk("no data\n");
        return NULL;    
    }

    /* get the page */
    page = virt_to_page(info->data);
    
    /* increment the reference count of this page */
    get_page(page);
    /* type is the page fault type */
    if (type)
        *type = VM_FAULT_MINOR;

    return page;
}

struct vm_operations_struct mmap_vm_ops = {
    .open =     mmap_open,
    .close =    mmap_close,
    .nopage =   mmap_nopage,
};

int my_mmap(struct file *filp, struct vm_area_struct *vma)
{
    vma->vm_ops = &mmap_vm_ops;
    vma->vm_flags |= VM_RESERVED;
    /* assign the file private data to the vm private data */
    vma->vm_private_data = filp->private_data;
    mmap_open(vma);
    return 0;
}

int my_close(struct inode *inode, struct file *filp)
{
    struct mmap_info *info = filp->private_data;
    /* obtain new memory */
    free_page((unsigned long)info->data);
        kfree(info);
    filp->private_data = NULL;
    return 0;
}

int my_open(struct inode *inode, struct file *filp)
{
    struct mmap_info *info = kmalloc(sizeof(struct mmap_info), GFP_KERNEL);
    /* obtain new memory */
        info->data = (char *)get_zeroed_page(GFP_KERNEL);
    memcpy(info->data, "hello from kernel this is file: ", 32);
    memcpy(info->data + 32, filp->f_dentry->d_name.name, strlen(filp->f_dentry->d_name.name));
    /* assign this info struct to the file */
    filp->private_data = info;
    return 0;
}

static const struct file_operations my_fops = {
    .open = my_open,
    .release = my_close,
    .mmap = my_mmap,
};

static int __init mmapexample_module_init(void)
{
    file1 = debugfs_create_file("mmap_example", 0644, NULL, NULL, &my_fops);
    return 0;
}

static void __exit mmapexample_module_exit(void)
{
    debugfs_remove(file1);

}

module_init(mmapexample_module_init);
module_exit(mmapexample_module_exit);
MODULE_LICENSE("GPL");

Of course we need some memory that we want to map between user space and kernel space.In this example we share some RAM but if you are writing a device driver, this could be the memory of your device.We use debugfs and attach the memory area to a file. This allows the user space process to access theshared memory area with the help of a file descriptor.

The user space program uses the system calls open, mmap, memcpy and close, which are all documented in the Linux man pages.

The kernel module is more challenging. Please note that the discussed module offers only the most basic functionality, and thatusually mmap is just one of the functions provided to handle a file.In the module_init function we create the file as discussed in section debugfs.Since it is an example module, our file_operations struct contains only three entries: my_open, my_close and my_mmap.

my_open

In this function we allocate the memory that will later be shared with the user space process.Since memory mapping is done on a PAGE_SIZE basis we allocate one page of memory with get_zeroed_page(GFP_KERNEL)We initialize the memory with a message form the kernel that states the name of this file.We set the private_data pointer of this file to the allocated memory in order to access it later in the my_mmap and my_close function

my_close

This function frees the memory allocated during my_open.

my_mmap

This function initializes the vm_area_struct to point to the mmap functions specific to our implementation.mmap_open und mmap_close are used only for bookkeeping. mmap_nopages is called when the user space process references a memory area that is not in its memory.Therefore mmap_nopages does the real mapping between user space and kernel space.The most important function is virt_to_page which takes the memory area to be shared as an argument and returns a struct page * that can be used by the user space to access this memory area.

#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>

#define PAGE_SIZE 4096

int main ( int argc, char **argv )
{
    int configfd;
    configfd = open("/sys/kernel/debug/mmap_example", O_RDWR);
    if(configfd < 0) {
        perror("open");
        return -1;
    }

    char * address = NULL;
    address = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, configfd, 0);
    if (address == MAP_FAILED) {
        perror("mmap");
        return -1;
    }

    printf("initial message: %s\n", address);
    memcpy(address + 11 , "*user*", 6);
    printf("changed message: %s\n", address);
    close(configfd);    
    return 0;
}