Memory mapping is the only way to transfer data between user and kernel spaces that does not involve explicit copying, and is the fastest way to handle large amounts of data.
There is a major difference between the conventional read(2) and write(2) functions and mmap. While data is transfered with mmap no "control" messages are exchanged. This means that a user space process can put data into the memory, but that the kernel does not know that new data is available. The same holds for the opposite scenario: The kernel puts its data into the shared memory, but the user space process does not get a notification of this event. This characteristic implies that memory mapping has to be used with some other communication means that transfers control messages, or that the shared memory needs to be checked in regular intervals for new content. Similar to the read and write function calls mmap can be used with different file systems and with sockets.
|mmap_simple_kernel.c||kernel module that provides the mmap system call based on debugfs.|
|mmap_bart_tanghe_dan_hordern.c||kernel module for newer kernels. Thanks to Bart Thange and Dan Hordern!.|
|mmap_user.c||user space program that will share a memory area with the kernel module|
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 the shared memory area with the help of a file descriptor.
The user space program uses the system calls
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 that
usually mmap is just one of the functions provided to handle a file.
In the module_init function we create the file as discussed in
Since it is an example module, our
file_operations struct contains only three entries: my_open, my_close and my_mmap.
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
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
This function frees the memory allocated during
This function initializes the
vm_area_struct to point to the mmap functions specific to our implementation.
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.
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
struct page * that can be used by the user space to access this memory area.