内核与用户空间共享内存之mmap

一、用到的API与数据结构
先看用户空间使用的API

#include <sys/mman.h>
void *mmap(void *start, //映射的范围首地址，通常设NULL，让系统自动选地址，映射成功后返回该地址
size_t length, //映射的范围的大小
int prot, //映射区的保护属性 PROT_EXEC PROT_READ PROT_WRITE PROT_NONE
int flags, //映射区的属性，注意MAP_SHARED、MAP_PRIVATE必选其一
int fd, //文件描述符
off_t offsize);//偏移量，后面讲
返回值：若映射成功则返回映射区的内存起始地址，否则返回MAP_FAILED(－1)，错误原因存于errno 中。
另外注意： offsize参数是有限制的。。。（以下摘自man手册）
EINVAL We don’t like start or length or offset.
(E.g., they are too large, or not aligned on a PAGESIZE boundary.)

在字符设备驱动模块里，有一个stuct file_operations结构
其中的fop->mmap() 指向你自己的mmap钩子函数。
用户空间里对一个字符设备文件进行mmap()系统调用后，最终会调用驱动模块里的mmap钩子函数
在mmap钩子函数里，需要调用下面这个API

int remap_pfn_range(struct vm_area_struct *vma, //这个结构很重要！！后面讲
unsigned long virt_addr, //要映射的范围的首地址
unsigned long pfn, //要映射的范围对应的物理内存的页帧号！！重要
unsigned long size, //要映射的范围的大小
pgprot_t prot); //PROTECT属性，mmap()中来的

内核维护VMA的链表和树形结构(即vm_area_struct),我们没事别建新的VMA，否则会打破这种组织结构。
用户空间每次调用mmap(),内核都会新建一个vm_area_struct数据结构,我们只关注几个重要的成员

struct vm_area_struct{
unsigned long vm_start; //要映射的范围的首地址
unsigned long vm_end; //要映射的范围的尾地址
pgprot_t vm_page_prot； //来自mmap()的形参prot
sturct file *vm_file; //字符设备文件所对应的file数据结构
unsigned long vm_pgoff; //来自mmap()的形参offsize,注意它是以PAGE为单位的，不是字节
unsigned long vm_flags; //来自mmap()的形参flags
}

在你的mmap钩子函数里，象下面这样就可以了

int my_mmap(struct file *filp, struct vm_area_struct *vma){
//......省略，page很重要,其他的参数一般照下面就可以了
remap_pfn_range(vma, vma->vm_start, page,
(vma->vm_end - vma->vm_start), vma->vm_page_prot);
//......省略
}

二、代码示例
内核模块里分配内存，通过proc把此内存的EA地址、大小告诉用户空间。
用户空间通过proc获取内存相关信息后，调用mmap，往内存里写字符串。

内核模块代码：

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <asm/io.h>
#include <asm/system.h>
#include <linux/cdev.h>
#include <linux/proc_fs.h>
#include <linux/mm.h>
#define PROC_SHM_MAP_DIR "shm_dir"
#define PROC_SHM_MAP_INFO "shm_info"
#define PAGE_ORDER 0
#define PAGES_NUMBER 1
static int dbg_major = 215;
struct cdev dgb_dev;
struct proc_dir_entry *proc_shm_map_dir;
unsigned long kernel_memaddr = 0;
unsigned long kernel_memsize = 0;
int get_shm_proc_info(char *page, char **start, off_t off, int count)
{
return sprintf(page, "lx %lu\n", __pa(kernel_memaddr), kernel_memsize);
}
void create_shm_proc(void)
{
if(NULL == (proc_shm_map_dir = proc_mkdir(PROC_SHM_MAP_DIR, NULL)) ){
printk("proc create error!\n");
return ;
}
create_proc_info_entry(PROC_SHM_MAP_INFO, 0, proc_shm_map_dir, get_shm_proc_info);
}
void destroy_shm_proc(void)
{
remove_proc_entry(PROC_SHM_MAP_INFO, proc_shm_map_dir);
remove_proc_entry(PROC_SHM_MAP_DIR, NULL);
}
int shm_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) )
return -1;
vma->vm_flags |= VM_RESERVED;
printk("remap_pfn_rang page:[%lu] ok.\n", page);
return 0;
}
int create_shm_mem(void)
{
if( NULL == (kernel_memaddr =__get_free_pages(GFP_KERNEL, PAGE_ORDER) )) {
printk("alloc kernel memory failed!\n");
return -1;
}
SetPageReserved(virt_to_page(kernel_memaddr)); // important !! only 1 page
kernel_memsize = PAGES_NUMBER * PAGE_SIZE;
printk("The kernel mem addr=lx, size=%lu\n",__pa(kernel_memaddr), kernel_memsize);
return 0;
}
void destroy_shm_mem(void)
{
printk("The string written by user is: %s\n", (unsigned char *)kernel_memaddr);
ClearPageReserved(virt_to_page(kernel_memaddr));// important !!
free_pages(kernel_memaddr, PAGE_ORDER);
return;
}
static const struct file_operations dbg_fops ={
.owner = THIS_MODULE,
.mmap = shm_mmap,
};
static void dbg_exit(void)
{
cdev_del(&dgb_dev);
unregister_chrdev_region(MKDEV(dbg_major, 0), 1);
destroy_shm_proc();
destroy_shm_mem();
}
int dbg_init(void)
{
int result;
dev_t devno ;
struct cdev *p_cdev = &dgb_dev;
if (dbg_major){
devno =MKDEV(dbg_major,0);
result = register_chrdev_region(devno,1, "leon");
}
else{
result=alloc_chrdev_region(&devno, 0, 1,"leon");
dbg_major = MAJOR(devno);
}
if (result < 0)
return result;
printk("the major device No. is %d\n", dbg_major );
cdev_init(p_cdev,&dbg_fops);
p_cdev->owner = THIS_MODULE;
result = cdev_add(p_cdev,devno,1);
if(result){
printk(KERN_NOTICE "Error %d while adding dbg",result);
return result;
}
create_shm_mem();
create_shm_proc();
return 0;
}
MODULE_AUTHOR("leonwang202");
MODULE_LICENSE("Dual BSD/GPL");
module_init(dbg_init);
module_exit(dbg_exit);

用户空间代码：

#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>
#include <errno.h>
int main(int argc, char* argv[])
{
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;
if( (fd = open("/proc/shm_dir/shm_info", O_RDONLY)) < 0) {
printf("cannot open file /proc/shm_dir/shm_info\n");
return 0;
}
read(fd, s, sizeof(s));
if(2 != sscanf(s, "lx %lu", &phymem_addr, &phymem_size)){
printf("data format from /proc/shm_dir/shm_info error!\n");
close(fd);
return -1;
};
close(fd);
printf("phymem_addr=%lx, phymem_size=%lu\n", phymem_addr, phymem_size);
if( (fd = open("/dev/enetdbg", O_RDWR|O_NONBLOCK)) < 0){
printf("open /dev/enetdbg error!\n");
return -1;
}
map_addr = mmap(NULL,
phymem_size,
PROT_READ|PROT_WRITE,
MAP_SHARED,
fd,
0); // ignored, because we don't use "vm->pgoff" in driver.
if( MAP_FAILED == map_addr){
printf("mmap() error:[%d]\n", errno);
return -1;
}
strcpy(map_addr, argv[1]);
munmap(map_addr, phymem_size);
close(fd);
return 0;
}

注意：我们在shm_mmap里没使用vm->pgoff，所以mmap()的形参offsize可以无视。

三、使用/dev/mem
想偷懒的，可以使/dev/mem，就不用费劲写内核模块里的mmap钩子函数了
（此用法在帖子http://bbs.chinaunix.net/thread-2017863-1-1.html中有写）

内核代码不用改，图干净的话只要把mmap钩子函数相关的东东全删掉就ok了
用户空间代码得改：

#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>
#include <errno.h>
int main(int argc, char* argv[])
{
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;
if( (fd = open("/proc/shm_dir/shm_info", O_RDONLY)) < 0) {
printf("cannot open file /proc/shm_dir/shm_info\n");
return 0;
}
read(fd, s, sizeof(s));
if(2 != sscanf(s, "lx %lu", &phymem_addr, &phymem_size)){
printf("data format from /proc/shm_dir/shm_info error!\n");
close(fd);
return -1;
};
close(fd);
printf("phymem_addr=%lx, phymem_size=%lu\n", phymem_addr, phymem_size);
if( (fd = open("/dev/mem", O_RDWR|O_NONBLOCK)) < 0){
printf("open /dev/mem error!\n");
exit(0);
}
map_addr = mmap(NULL,
phymem_size,
PROT_READ|PROT_WRITE,
MAP_SHARED,
fd,
phymem_addr);
strcpy(map_addr, argv[1]);
munmap(map_addr, phymem_size);
close(fd);
return 0;
}

注意：
1.你的linux环境下没有/dev/mem的话，敲命令 mknod /dev/mem c 1 1 原因后面讲
2.这次mmap()形参offsize不能无视，因为创建/dev/mem的内核模块的mmap钩子函数里用到了vm->pgoff

看到底是哪个模块创建了/dev/mem

start_kernel --> kernel_init --> do_basic_setup --> do_initcalls --> chr_dev_init

文件 linux_2_6_24/drivers/char/mem.c 中 chr_dev_init() 函数

static int __init chr_dev_init(void)
{
if (register_chrdev(MEM_MAJOR,"mem",&memory_fops)) //cat /proc/devices 时显示 1 mem
printk("unable to get major %d for memory devs\n", MEM_MAJOR);
for (i = 0; i < ARRAY_SIZE(devlist); i )
device_create(mem_class, NULL, //据数组新建N多设备，主设备号为1，从设备号来自数组
MKDEV(MEM_MAJOR, devlist[i].minor),devlist[i].name);
}
static const struct {
unsigned int minor;
char *name;
umode_t mode;
const struct file_operations *fops;
} devlist[] = { /* list of minor devices */ //我擦，major为1的字符设备这么多....
{1, "mem", S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops}, //mknod /dev/mem c 1 1 原因知道了吧
{2, "kmem", S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
{3, "null", S_IRUGO | S_IWUGO, &null_fops},
#ifdef CONFIG_DEVPORT
{4, "port", S_IRUSR | S_IWUSR | S_IRGRP, &port_fops},
#endif
{5, "zero", S_IRUGO | S_IWUGO, &zero_fops},
{7, "full", S_IRUGO | S_IWUGO, &full_fops},
{8, "random", S_IRUGO | S_IWUSR, &random_fops},
{9, "urandom", S_IRUGO | S_IWUSR, &urandom_fops},
{11,"kmsg", S_IRUGO | S_IWUSR, &kmsg_fops},
#ifdef CONFIG_CRASH_DUMP
{12,"oldmem", S_IRUSR | S_IWUSR | S_IRGRP, &oldmem_fops},
#endif
};

---------------------------------- 华丽的分割线 -------------------------------------------

若共享小块连续内存，上面例子用get_free_pages可以分配多达几M的连续空间（MAX_ORDER目前是11）。
若共享大块连续内存，就得靠uboot帮忙了，给linux kernel传参数的时候，用mem=大小

《ldd3》中的分配内存那章有专门一节讲解，通过API

void *alloc_bootmem(unsigned long size);
void free_bootmem(unsigned long addr, unsigned long size);

lelv123

内核与用户空间共享内存之mmap