Kernel Space - User Space Interfaces_Mmap
2011-09-01 23:22
330 查看
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,
memcpyand
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_operationsstruct 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_datapointer of this file to the allocated memory in order to access it later in the
my_mmapand
my_closefunction
my_close
This function frees the memory allocated during
my_open.
my_mmap
This function initializes the
vm_area_structto point to the mmap functions specific to our implementation.
mmap_openund
mmap_closeare used only for bookkeeping.
mmap_nopagesis called when the user space process references a memory area that is not in its memory.Therefore
mmap_nopagesdoes the real mapping between user space and kernel space.The most important function is
virt_to_pagewhich 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;
}
相关文章推荐
- Kernel Space - User Space Interfaces_Mmap
- Kernel Space - User Space Interfaces
- Kernel Space - User Space Interfaces
- User space和Kernel space
- 『阿男的Linux内核世界』*12 Kernel Space和User Space*
- V4l2 capture时 USERPTR和MMAP的区别
- 用户空间内核空间ipc总结(sockopt,ioctl,mmap,netlink,proc,seq,file,copy_user)
- WWDC笔记:2013 Session 201 Building User Interfaces for iOS 7
- Kernel space DMA and User space DMA
- 安装L7-filter Userspace
- Android.mk 移植示例--移植usbip userspace tools
- Writing a Real Driver -- In User Space
- 《DirectX9 User Interfaces Design and Implementation》第八章的译文
- [中英对照]Device Drivers in User Space: A Case for Network Device Driver | 用户态设备驱动: 以网卡驱动为例
- PCIe userspace tools: lspci, setpci and sysfs
- DirectX 9 UI设计学习笔记之一:开场白+第一章User Interfaces
- Memory Allocation API In Linux Kernel && Linux Userspace、kmalloc vmalloc Difference、Kernel Large Section Memory Allocation
- Building User Interfaces by Using Windows® Presentation Foundation
- Call KernelIoControl in user space in WINCE6.0
- gpio Sysfs Interface for Userspace