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;

}