mmap函数用法及示例程序

http://blog.csdn.net/bluebluesea/article/details/7210913

该函数主要有三个用途：

1.将一个普通文件映射到内存中，通常在需要对文件进行频繁读写时使用，这样用内存读写取代I/O读写，以获得较高的性能；

2.将特殊文件进行匿名内存映射，可以为关联进程提供共享内存空间；

3.为无关联的进程提供共享内存空间，一般也是将一个普通文件映射到内存中。

 

头文件:

　　#include <unistd.h>

　　#include <sys/mman.h>

原型: void *mmap(void *start_addr, size_t length, int prot, int flags, int fd, off_t offsize);

返回值: 成功则返回映射区起始地址, 失败则返回MAP_FAILED(-1)，错误原因存在于errno中.

错误代码：

EBADF 参数fd 不是有效的文件描述词

EACCES 存取权限有误。如果是MAP_PRIVATE 情况下文件必须可读，使用MAP_SHARED

则要有PORT_WRITE以及该文件要能写入。

EINVAL 参数start、length 或offset有一个不合法。

EAGAIN 文件被锁住，或是有太多内存被锁住。

ENOMEM 内存不足。

参数:

　　start_addr: 指定映射的起始地址, 通常设为NULL, 代表让系统自动选定地址，映射成功后返回该地址.

　　length: 将文件的多大长度映射到内存.

　　prot: 映射区的保护方式,。可以为以下几种方式的组合:

　　PROT_EXEC: 映射区可被执行.

　　PROT_READ: 映射区可被读取.

　　PROT_WRITE: 映射区可被写入.

　　PROT_NONE: 映射区不能存取.

flags: 映射区的各种特性。在调用mmap()时必须要指定MAP_SHARED或MAP_PRIVATE

MAP_FIXED:如果start_addr所指的地址无法成功建立映射时，则放弃映射，不对地址做修正。通常不鼓励用此flag.

　　MAP_SHARED: 对映射区域的写入数据会复制回文件内, 且允许其他映射该文件的进程共享.

　　MAP_PRIVATE: 对映射区域的写入操作会产生一个映射的复制，即私人的“写入时复制”(copy-on-write), 对此区域所做的修改不会写回原文件.

MAP_ANONYMOUS:建立匿名映射。此时会忽略参数fd，不涉及文件，而且映射区域无法和其它进程共享.

MAP_DENYWRITE:只允许对映射区域的写入操作，其他对文件直接写入的操作将会被拒绝.

　　fd: 由open返回的文件描述符, 代表要映射到内存中的文件。如果flag中设置了ANONYMOUS，则fd=-1。有些系统不支持匿名内存映射，则可以使用fopen打开/dev/zero文件，然后对该文件进行映射，可以同样达到匿名内存映射的效果.

offset: 以文件开始处的偏移量, 必须是分页大小的整数倍, 通常为0, 表示从文件头开始映射.

 

系统调用mmap()用于共享内存的两种方式：

（1）使用普通文件提供的内存映射：

适用于任何进程之间。此时，需要打开或创建一个文件，然后再调用mmap()

典型调用代码如下：

fd=open(name, flag, mode); if(fd<0) ...

ptr=mmap(NULL, len , PROT_READ|PROT_WRITE, MAP_SHARED , fd , 0);

通过mmap()实现共享内存的通信方式有许多特点和要注意的地方，可以参看UNIX网络编程第二卷。

（2）使用特殊文件提供匿名内存映射：

适用于具有亲缘关系的进程之间。由于父子进程特殊的亲缘关系，在父进程中先调用mmap()，然后调用 fork()。那么在调用fork()之后，子进程继承父进程匿名映射后的地址空间，同样也继承mmap()返回的地址，这样，父子进程就可以通过映射区域进行通信了。注意，这里不是一般的继承关系。一般来说，子进程单独维护从父进程继承下来的一些变量。而mmap()返回的地址，却由父子进程共同维护。对于具有亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射的方式。此时，不必指定具体的文件，只要设置相应的标志即可。

 

示例1.将文件第30条记录编号修改为300，并相应修改其内容。

#include <unistd.h>

#include <stdio.h>

#include <sys/mman.h>

#include <fcntl.h>

#include <stdlib.h>

//定义存放记录的结构体

typedef struct

{

 int index; //编号

 char text[10]; //内容

} RECORD;

#define SIZE (50)

#define EDIT_INDEX (10)

int main(void)

{

     RECORD record, *p_mapped_memory_addr;

    int i, fd;

    FILE *fp;

  //创建文件并写入测试数据

fp = fopen("records.dat", "w+");

for (i = 0; i < SIZE; i++)

{

   record.index = i;

    sprintf(record.text, "No.%d", i);

    fwrite(&record, sizeof(record), 1, fp);//因为字节序对齐，在32位机上，sizeof(record)＝16，并不是14。

 }

 fclose(fp);

printf("Ok, write %d records to the file: records.dat .\n", SIZE);

//将第一30条记录编号修改为300，并相应地修改其内容。

//采用传统方式

fp = fopen("records.dat", "r+");

fseek(fp, EDIT_INDEX * sizeof(record), SEEK_SET);
    fread(&record, sizeof(record), 1, fp);

record.index = EDIT_INDEX*10;

sprintf(record.text, "No.%d", record.index);

fseek(fp, EDIT_INDEX * sizeof(record), SEEK_SET);

fwrite(&record, sizeof(record), 1, fp);

fclose(fp);

printf("Ok, edit the file of records.dat using traditional method.\n");

 //同样的修改，这次使用内存映射方式。

//将记录映射到内存中

fd = open("records.dat", O_RDWR);

p_mapped_memory_addr = (RECORD *)mmap(0, SIZE * sizeof(record), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

//修改数据

p_mapped_memory_addr[EDIT_INDEX].index = EDIT_INDEX*10;

sprintf(p_mapped_memory_addr[EDIT_INDEX].text, "No.%d",

           p_mapped_memory_addr[EDIT_INDEX].index);

/* Synchronize the region starting at ADDR and extending LEN bytes with the

     file it maps. Filesystem operations on a file being mapped are

     unpredictable before this is done. Flags are from the MS_* set.

     This function is a cancellation point and therefore not marked with

     __THROW. extern int msync (void *__addr, size_t __len, int __flags);

*/

//将修改写回映射文件中(采用异步写方式)

msync((void *)p_mapped_memory_addr, SIZE * sizeof(record), MS_ASYNC);

/* Deallocate any mapping for the region starting at ADDR and extending LEN

bytes. Returns 0 if successful, -1 for errors (and sets errno).

extern int munmap (void *__addr, size_t __len) __THROW;

*/

//释放内存段

munmap((void *)p_mapped_memory_addr, SIZE * sizeof(record));

printf("Ok, edit the file of records.dat using mmap method.\n");

//关闭文件

close(fd)

 return 0;

}

示例2.写个测试程序，从用户态读取DM365里寄存器的数据

#include <sys/mman.h>   

#include <stdio.h>   

#include <fcntl.h>   

#include <sys/types.h>   

#include <sys/stat.h>   

#include <ubistd.h>   

#define DAVINCI_SYSTEM_MODULE_BASE      (0x01C70000)   

#define SYSTEM_LEN    0x4000   

#define DEV_MEM_CTL   "/dev/mem"   

static int dev_mem = -1;  

static unsigned int *pMem_map = NULL;  /*mmap address for usb*/  

static int mem_open(void)  

{  

    if(dev_mem < 0){  

        dev_mem = open(DEV_MEM_CTL, O_RDWR|O_SYNC);  

        if(dev_mem < 0){  

            printf("open %s error/n", DEV_MEM_CTL);  

            return -1;  

        }  

    }  

    return 0;  

}  

static int mmap_init(void)  

{  

    unsigned long phyaddr = DAVINCI_SYSTEM_MODULE_BASE;  

   if(pMem_map == NULL){  

        pMem_map = mmap((void *)phyaddr, SYSTEM_LEN, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_SHARED,  

                            dev_mem, phyaddr);  

        if(pMem_map != (void *)phyaddr){  

            printf("mem failed/n");  

            return -1;  

        }  

    }  

    else{  

        return 0;  

    }  

}  

static int mmap_free(void)  

{  

    if(pMem_map){  

        munmap(pMem_map, SYSTEM_LEN);  

        pMem_map = NULL;  

    }  

}  

static void mem_close(void)  

{  

    if(dev_mem > 0) {  

        close(dev_mem);  

        dev_mem = -1;  

    }  

}  

int  ReadRegister(unsigned long phy_addr)  

{  

    int ret = -1;  

    //void *pMem_map;   

    //unsigned int length = 0x88;  /*DM365 's System Control Description*/   

    //unsigned long phyAddr = phy_addr;   

    unsigned int *WB_WGN_B = NULL;  

    unsigned int *WB_WGN_GB = NULL;  

    unsigned int *WB_WGN_GR = NULL;  

    unsigned int *WB_WGN_R = NULL;  

    int sleep_cnt = 0;  

    phy_addr = phy_addr; /*for the compile warning*/  

    if(dev_mem < 0) {  

        ret = mem_open();  

        if(ret < 0){  

            //ERR_PRINT("");   

            return -1;  

        }  

    }  

    if(pMem_map == NULL){  

        if(mmap_init() < 0)  

            return -1;  

    }  

    WB_WGN_R = (unsigned int *)((char *)pMem_map + 0x800 + 0x480);    

    WB_WGN_GR = (unsigned int *)((char *)pMem_map + 0x800 + 0x484);   

    WB_WGN_GB = (unsigned int *)((char *)pMem_map + 0x800 + 0x488);   

    WB_WGN_B = (unsigned int *)((char *)pMem_map + 0x800 + 0x492);   

    printf("WB_WGN_R=%x,WB_WGN_GR=%x,WB_WGN_GB=%x,WB_WGN_B=%x/n",  

                *WB_WGN_R,  

                *WB_WGN_GR,  

                *WB_WGN_GB,  

                *WB_WGN_B);  

    return 0;  

}  

 void mem_free_all(void)  

{  

    mmap_free();      

    mem_close();  

}  

int main(int argc, char *argv[])  

{  

    int ret = -1;     

    unsigned long phr_add = 1;  

    if((ret = mem_open()) < 0)  

    {  

        return -1;  

    }  

    ret = mmap_init();  

    if(ret < 0)  

    {  

        return -1;  

    }  

    ret = ReadRegister(1);  

    if(ret < 0)  

    {  

        return -1;  

    }  

    mem_free_all();  

    return 0;  

}   

 mmap()的特点：

 　 mmap系统调用并不是完全为了用于共享内存而设计的。它本身提供了不同于一般对普通文件的访问方式，进程可以像读写内存一样对普通文件的操作。而 Posix或系统V的共享内存IPC则纯粹用于共享目的，当然mmap()实现共享内存也是其主要应用之一。

　 mmap系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以像访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。

　　我们的程序中大量运用了mmap，用到的正是mmap的这种“像访问普通内存一样对文件进行访问”的功能。实践证明，当要对一个文件频繁的进行访问，并且指针来回移动时，调用mmap比用常规的方法快很多。

/dev/mem:物理内存的全镜像。可以用来访问物理内存。

一开始，指定的内存映射起始地址是0x01C70800，程序跑起来以后打印“mem failed”，但是查了半天mmap()函数，没发现错在哪里，后来将内存映射起始地址设置为0x01C7000，刚好是内存分页中一页（常为4K）的倍数，程序运行正常了，mmap()如果要指定内存映射的起始地址，起始地址要是内存分页后每页的开始地址。