mmap映射文件至內存( 實現共享內存與文件的另類訪問 )

有以下整合而成，個人有稍加修改，還請看原版。。。

轉自：http://blog.csdn.net/adcxf/archive/2009/03/14/3989725.aspx

轉自：http://www.cnblogs.com/feisky/archive/2009/11/11/1600986.html

Linux提供了內存映射函數mmap, 它把文件內容映射到一段內存上(準確說是虛擬內存上), 通過對這段內存的讀取和修改, 實現對文件的讀取和修改, 先來看一下mmap的函數聲明:

頭文件:
- <unistd.h>
- <sys/mman.h>
原型: void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);//offset: 以文件開始處的偏移量, 必須是分頁大小的整數倍, 通常爲0, 表示從文件頭開始映射.
返回值: 成功則返回映射區起始地址, 失敗則返回MAP_FAILED(-1).
參數:
- addr: 指定映射的起始地址, 通常設爲NULL, 由系統指定.
- length: 將文件的多大長度映射到內存，不該超過文件大小.
- prot: 映射區的保護方式, 可以是:
  - PROT_EXEC: 映射區可被執行.
  - PROT_READ: 映射區可被讀取.
  - PROT_WRITE: 映射區可被寫入.
  - PROT_NONE: 映射區不能存取.
- flags: 映射區的特性, 可以是:
  - MAP_SHARED: 對映射區域的寫入數據會複製迴文件(由守護進程自動完成), 且允許其他映射該文件的進程共享.
  - MAP_PRIVATE: 對映射區域的寫入操作會產生一個映射的複製(copy-on-write), 對此區域所做的修改不會寫回原文件.
  - 此外還有其他幾個flags不很常用, 具體查看linux C函數說明.
- fd: 由open返回的文件描述符, 代表要映射的文件，在映射完後就可以馬上關閉文件了，對映射區域的訪問與文件是否打開無關.
- offset:以文件開始處的偏移量, 必須是分頁大小的整數倍, 通常爲0, 表示從文件頭開始映射.

mmap返回的是用戶進程空間的虛擬地址，在stack和heap 之間的空閒邏輯空間(虛擬空間) 就是用來提供映射的，文件將會被映射到這一區域的某塊虛擬內存上，具體哪一塊若是用戶沒有指定，則由內核來分配。一般上，用戶不該去指定這個映射的起始地址，因爲棧和堆都是在向塊區域進行擴展的，所以這塊區域的大小會一直在變化，若是用戶指定，用戶根本就無法知道這塊地址是否被堆用去了還是被棧用去了。

下面說一下內存映射的步驟:

用open系統調用打開文件, 並返回描述符fd.
用mmap建立內存映射, 並返回映射首地址指針start.
對映射(文件)進行各種操作, 顯示(printf), 修改(sprintf).
用munmap(void *start, size_t lenght)關閉內存映射.
用close系統調用關閉文件fd（只要保證在mmap成功了之後就都可以）.

注意事項:

在修改映射的文件時, 只能在原長度上修改, 不能增加文件長度, 因爲內存是已經分配好的.

mmap的用地：

1、共享內存：可以說是最有用的進程間通信方式，也是最快的IPC形式。兩個不同進程A、B共享內存的意思是，同一塊物理內存被映射到進程A、B各自的進程地址空間。進程A可以即時看到進程B對共享內存中數據的更新，反之亦然。由於多個進程共享同一塊內存區域，必然需要某種同步機制，互斥鎖和信號量都可以。

採用共享內存通信的一個顯而易見的好處是效率高，因爲進程可以直接讀寫內存，而不需要任何數據的拷貝。對於像管道和消息隊列等通信方式，則需要在內核和用戶空間進行四次的數據拷貝，而共享內存則只拷貝兩次數據[1]：一次從輸入文件到共享內存區，另一次從共享內存區到輸出文件。實際上，進程之間在共享內存時，保持共享區域，直到通信完畢爲止，這樣，數據內容一直保存在共享內存中，並沒有寫回文件。共享內存中的內容往往是在解除映射時才寫回文件的。所以寫入共享內存並不會立即寫入文件。因此，採用共享內存的通信方式效率是非常高的。

Linux的2.2.x內核支持多種共享內存方式，如mmap()系統調用，Posix共享內存，以及系統V共享內存。linux發行版本如Redhat 8.0支持mmap()系統調用及系統V共享內存，但還沒實現Posix共享內存，本文將主要介紹mmap()系統調用及系統V共享內存API的原理及應用。

2、文件訪問方式：mmap函數是unix/linux下的系統調用，mmap系統調用並不是完全爲了用於共享內存而設計的。它本身提供了不同於一般對普通文件的訪問方式，進程可以像讀寫內存一樣對普通文件的操作。而Posix或系統V的共享內存IPC則純粹用於共享目的，當然mmap()實現共享內存也是其主要應用之一。

mmap系統調用使得進程之間通過映射同一個普通文件實現共享內存。普通文件被映射到進程地址空間後，進程可以像訪問普通內存一樣對文件進行訪問，不必再調用read()，write（）等操作。
我們的程序中大量運用了mmap，用到的正是mmap的這種“像訪問普通內存一樣對文件進行訪問”的功能。實踐證明，當要對一個文件頻繁的進行訪問，並且指針來回移動時，調用mmap比用常規的方法快很多。

一、內核怎樣保證各個進程尋址到同一個共享內存區域的內存頁面

---------------------------------看不懂，屬於內核的問題，只要記得共享內存在進程間是即時可見的就可以了！！

1、 page cache及swap cache中頁面的區分：一個被訪問文件的物理頁面都駐留在page cache或swap cache中，一個頁面的所有信息由struct page來描述。struct page中有一個域爲指針mapping ，它指向一個struct address_space類型結構。page cache或swap cache中的所有頁面就是根據address_space結構以及一個偏移量來區分的。

2、文件與 address_space結構的對應：一個具體的文件在打開後，內核會在內存中爲之建立一個struct inode結構，其中的i_mapping域指向一個address_space結構。這樣，一個文件就對應一個address_space結構，一個 address_space與一個偏移量能夠確定一個page cache 或swap cache中的一個頁面。因此，當要尋址某個數據時，很容易根據給定的文件及數據在文件內的偏移量而找到相應的頁面。

3、進程調用mmap()時，只是在進程空間內新增了一塊相應大小的緩衝區，並設置了相應的訪問標識，但並沒有建立進程空間到物理頁面的映射。因此，第一次訪問該空間時，會引發一個缺頁異常。

4、對於共享內存映射情況，缺頁異常處理程序首先在swap cache中尋找目標頁（符合address_space以及偏移量的物理頁），如果找到，則直接返回地址；如果沒有找到，則判斷該頁是否在交換區 (swap area)，如果在，則執行一個換入操作；如果上述兩種情況都不滿足，處理程序將分配新的物理頁面，並把它插入到page cache中。進程最終將更新進程頁表。
注：對於映射普通文件情況（非共享映射），缺頁異常處理程序首先會在page cache中根據address_space以及數據偏移量尋找相應的頁面。如果沒有找到，則說明文件數據還沒有讀入內存，處理程序會從磁盤讀入相應的頁面，並返回相應地址，同時，進程頁表也會更新。

5、所有進程在映射同一個共享內存區域時，情況都一樣，在建立線性地址與物理地址之間的映射之後，不論進程各自的返回地址（實際上各進程返回的地址爲各進程的虛擬地址，虛擬地址自然就會不一樣，而它們映射的物理地址是相同的）如何，實際訪問的必然是同一個共享內存區域對應的物理頁面。
注：一個共享內存區域可以看作是特殊文件系統shm中的一個文件，shm的安裝點在交換區上。

上面涉及到了一些數據結構，圍繞數據結構理解問題會容易一些。

二、mmap()及其相關係統調用 mmap、munmap、msync

mmap()系統調用使得進程之間通過映射同一個普通文件實現共享內存。普通文件被映射到進程地址空間後，進程可以向訪問普通內存一樣對文件進行訪問，不必再調用read()，write（）等操作。

注：實際上，mmap()系統調用並不是完全爲了用於共享內存而設計的。它本身提供了不同於一般對普通文件的訪問方式，進程可以像讀寫內存一樣對普通文件的操作。而Posix或系統V的共享內存IPC則純粹用於共享目的，當然mmap()實現共享內存也是其主要應用之一。

1、mmap()系統調用形式如下：

void* mmap ( void * addr , size_t len , int prot , int flags , int fd , off_t offset )
參數fd爲即將映射到進程空間的文件描述字，一般由open()返回，同時，fd可以指定爲-1，此時須指定flags參數中的MAP_ANON，表明進行的是匿名映射（不涉及具體的文件名，避免了文件的創建及打開，很顯然只能用於具有親緣關係的進程間通信）。len是將文件的多大長度進行映射。prot 參數指定共享內存的訪問權限。可取如下幾個值的或：PROT_READ（可讀） , PROT_WRITE （可寫）, PROT_EXEC （可執行）, PROT_NONE（不可訪問）。flags由以下幾個常值指定：MAP_SHARED , MAP_PRIVATE , MAP_FIXED，其中，MAP_SHARED , MAP_PRIVATE必選其一，而MAP_FIXED則不推薦使用。offset參數一般設爲0，表示從文件頭開始映射。參數addr指定文件應被映射到進程虛擬空間的起始地址，一般被指定一個空指針，此時選擇起始地址的任務留給內核來完成。函數的返回值爲最後文件映射到進程空間的地址，進程可直接操作起始地址爲該值的有效地址。這裏不再詳細介紹mmap()的參數，讀者可參考mmap()手冊頁獲得進一步的信息。

2、系統調用mmap()用於共享內存的兩種方式：

（1）使用普通文件提供的內存映射：適用於任何進程之間；此時，需要打開或創建一個文件，然後再調用mmap()；典型調用代碼如下：

fd=open(name, flag, mode);

if(fd<0)

...

ptr=mmap(NULL, len , PROT_READ|PROT_WRITE, MAP_SHARED , fd , 0); 通過mmap()實現共享內存的通信方式有許多特點和要注意的地方，我們將在範例中進行具體說明。

（2）使用特殊文件提供匿名內存映射：適用於具有親緣關係的進程之間；由於父子進程特殊的親緣關係，在父進程中先調用mmap()，然後調用fork()。那麼在調用fork()之後，子進程繼承父進程匿名映射後的地址空間，同樣也繼承mmap()返回的地址，這樣，父子進程就可以通過映射區域進行通信了。注意，這裏不是一般的繼承關係。一般來說，子進程單獨維護從父進程繼承下來的一些變量。而mmap()返回的地址，卻由父子進程共同維護。
對於具有親緣關係的進程實現共享內存最好的方式應該是採用匿名內存映射（可以使用fd =-1 的方式，也可以用fd = open("dev/zero",)的方式）的方式。此時，不必指定具體的文件，只要設置相應的標誌即可，參見範例

3、系統調用munmap()

int munmap( void * addr, size_t len )
該調用在進程地址空間中解除一個映射關係，addr是調用mmap()時返回的地址，len是映射區的大小。當映射關係解除後，對原來映射地址的訪問將導致段錯誤發生。注意，munmap並不會將映射區的內容寫入磁盤文件，它完成的僅僅只是釋放映射區包括其上的內容。

4、系統調用msync()---------此“沖洗”非彼沖洗，不同於用戶緩衝區，此時的沖洗不會洗掉映射存儲區的內容，會保留，此沖洗更像是複製寫入文件的同步！

int msync ( void * addr , size_t len, int flags)
這個是手動沖洗映射區到文件中，然而實際上內核會維護一個守護進程定時對映射存儲區進行沖洗，所以我們對mmap返回的內存進行操作就相當於對文件操作，此守護進程滿足了內存映射與文件的實時性。但是因爲munmap是不會對映射內存進行沖洗的，它只會直接釋放映射內存，所以在當我們調用munmap之前，還是最好手動調用msync手動沖洗一下，因爲守護進程是定時沖洗，所以它的實時性也只是相對的，要想可靠保險，還是要自己勤快點！

另外，對映射內存的沖洗和對用戶標準I/O緩衝區的沖洗不同，對映射內存的沖洗並不會洗掉其內存存儲的內容，依然還在，只是將內容“複製"到文件裏。而用戶緩衝區的沖洗則是真正的清空寫入，緩衝區中的內容在沖洗後會變不見，但會寫入文件。

回頁首

三、mmap()範例

下面將給出使用mmap()的兩個範例：範例1給出兩個進程通過映射普通文件實現共享內存通信；範例2給出父子進程通過匿名映射實現共享內存。系統調用 mmap()有許多有趣的地方，下面是通過mmap（）映射普通文件實現進程間的通信的範例，我們通過該範例來說明mmap()實現共享內存的特點及注意事項。

範例1：兩個進程通過映射普通文件實現共享內存通信-------映射大小、讀寫大小與文件實際大小的關係

-------映射大小不應該超過文件的實際大小，否則在對映射內存進行寫的時候就有可能寫到其它文件的數據中去了，也許就會報錯，讀的話若越界就讀到其它無用數據去了，有可能像這次返回的是0（說明被映射的磁盤在溢出區域上還沒有文件）一樣，也有可能返回其它文件的值，至於是否報錯，那就看運氣了，看你映射的文件周圍的存儲區域是個什麼情況了。

範例1包含兩個子程序：map_normalfile1.c及map_normalfile2.c。編譯兩個程序，可執行文件分別爲 map_normalfile1及map_normalfile2。兩個程序通過命令行參數指定同一個文件來實現共享內存方式的進程間通信。 map_normalfile2試圖打開命令行參數指定的一個普通文件，把該文件映射到進程的地址空間，並對映射後的地址空間進行寫操作。 map_normalfile1把命令行參數指定的文件映射到進程地址空間，然後對映射後的地址空間執行讀操作。這樣，兩個進程通過命令行參數指定同一個文件來實現共享內存方式的進程間通信。

下面是兩個程序代碼：

<span style="font-family:Courier New;"><span style="font-weight: normal;">/*-------------map_normalfile1.c-----------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
typedef struct{
	char name[4];
	int age;
}people;

main(int argc, char** argv) // map a normal file as shared mem:
{
	int fd,i;
	people *p_map;
	char temp;
	 
	fd=open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777);//<span style="font-family: 宋體;font-size:12px; ">O_TRUNC 若文件存在並且以可寫的方式打開時，此旗標會令文件長度清爲0，而原來存於該文件的資料也會消失。</span>
	people *sp = (people *)malloc(sizeof(people));
	i = 5;
	temp = '1';
	while(i--)
	{
		memcpy(sp->name,&temp,1);
		sp->age = 10+i;
		temp++;
		write(fd,sp,sizeof(people));
	}
	//映射內存的大小爲實際文件的大小，對於新創建的文件，除了像上面那樣實際寫入來擴展文件大小以外，
	//也可以通過lseek來快捷擴展文件大小:
	//lseek(fd,sizeof(people)*5-1,SEEK_CUR);
	//write(fd,"",1);
	 
	p_map = (people*) mmap( NULL,sizeof(people)*10,<span style="color:#3333ff;">PROT_READ|PROT_WRITE,MAP_SHARED</span>,fd,0 );
	close( fd );//在映射完後就可以立刻關閉文件了，打開文件是爲了獲取文件秒速符來映射文件，文件是否打開對映射內存的操作沒有關係

	//最後一個參數offset 必須爲頁的整數倍，此處爲0 表示從文件頭開始，那麼後面通過映射的返回地址寫入的
	//10個結構體也就會將之前寫入的5 個結構體給覆蓋了。
	//sizeof(people)*10 爲從文件開始的10個結構的大小。
	//將返回的地址p_map 強制轉換爲結構體類型指針。

	temp = 'a';
	for(i=0; i<10; i++)  //寫10個結構體大小
	{
		memcpy( ( *(p_map+i) ).name, &temp,1 );
		( *(p_map+i) ).age = 20+i;
		temp += 1;

	}
	printf(" initialize over\n ");
	sleep(10);
	munmap( p_map, sizeof(people)*10 );
	printf( "umap ok \n" );
}</span>
</span>

<span style="font-weight: normal;"><span style="font-family:Courier New;">/*-------------map_normalfile2.c-----------*/
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include<stdio.h>
#include <unistd.h>
typedef struct{
char name[4];
int age;
}people;

main(int argc, char** argv)	// map a normal file as shared mem:
{
	int fd,i;
	people *p_map;
	fd=open( argv[1],O_CREAT|O_RDWR,00777 );//不可用<span style="font-size: 10px; ">O_TRUNC，因爲這裏你是打開讀的</span>

	p_map = (people*)mmap(NULL,sizeof(people)*15,<span style="color:#3333ff;">PROT_READ|PROT_WRITE,MAP_SHARED</span>,fd,0);//映射15 個結構體大小實際已經是超出了
	//這邊是讀15 的大小，雖然也可讀，可實際已經超出文件5個結構體的大小了，
	//只是編譯器沒報出錯而已，就像數組一樣，只是讀出界而已沒關係，只有
	//寫出界寫到了系統數據時纔會出錯。

	close(fd);
	//在映射完後就可以立刻關閉文件了，打開文件是爲了獲取文件秒速符來映射文件，
	//文件是否打開對映射內存的操作沒有關係。
	
	for(i = 0;i<15;i++)  
		printf( "name: %s age %d\n",(*(p_map+i)).name, (*(p_map+i)).age );

	munmap( p_map,sizeof(people)*10 );
}

file1.c首先定義了一個 people數據結構，（在這裏採用數據結構的方式是因爲，共享內存區的數據往往是有固定格式的，這由通信的各個進程決定，採用結構的方式有普遍代表性）。map_normfile1首先打開或創建一個文件，並把文件的長度設置爲5個people結構大小。然後從mmap()的返回地址開始，設置了 10個people結構。然後，進程睡眠10秒鐘，等待其他進程映射同一個文件，最後解除映射，否則程序一結束映射就解除了，內容就寫入文件，這樣即使另一個程序也映射了此文件，可操作意義就不是共享內存的事了，而是使用映射內存來讀寫文件的事了。映射內存只有在雙都同時映射向同一個文件時才爲共享內存，共享內存也就是一映射的虛擬內存(存在於各自的進程空間)，映射虛擬內存不是一直都存在的，當調用了munmap或程序結束時，映射內存都會被結束映射，但映射指向的物理內存一直都存在，文件也一直存在，同時會將進程映射的共享虛擬內存上的內容寫入文件，只是虛擬內存不存在了，也就是共享內存不再具有立即讀寫可見的共享性了，因爲另一方已經解除映射了，而這塊共享內存也就變成了另一方的獨角戲了，但文件仍存在，還在映射着的那方仍可以通過映射來讀取文件，來讀取之前解除方在共享內存上的寫入的內容，所謂的共享內存實質就是通過一個文件來共享而已，只是將該文件映射到內存中，將文件的存在形式從磁盤搬到內存中而已。雖然說共享內存要在解除共享時纔會寫入文件，但共享者雙方在共享內存上的操作時即時可見的，即不用一方寫完後解除映射將共享內存的內容寫入文件(然後在映射準備下一次的通信)，另一方再通過映射從文件中讀出，不用這樣，雖然是映射是映射到各自的進程虛擬內存空間，且映射的虛擬內存與磁盤上的文件也不同步，而且各個進程的進程虛擬內存空間是獨立，但就是可以實現在兩個進程間的映射向同一個磁盤文件的共享內存（各自的映射內存）上實時看見，這到底是爲什麼呢——在一、中有解釋了，只是涉及內核看不懂而已！

map_normfile2.c只是簡單的映射一個文件，並以people數據結構的格式從mmap()返回的地址處讀取10個people結構，並輸出讀取的值，然後解除映射。

分別把兩個程序編譯成可執行文件map_normalfile1和map_normalfile2後，在一個終端上先運行./map_normalfile2 /tmp/test_shm，程序輸出結果如下：

initialize over

umap ok

在map_normalfile1輸出initialize over 之後，輸出umap ok( munmap解除映射)之前，在另一個終端上運行map_normalfile2 /tmp/test_shm，將會產生如下輸出(爲了節省空間，輸出結果爲稍作整理後的結果)：

在map_normalfile1 輸出umap ok後，運行map_normalfile2則輸出如下結果：

從程序的運行結果中可以得出的結論

1、最終被映射文件的內容的長度不會超過文件本身的初始大小，即映射不能改變文件的大小；

2、可以用於進程通信的有效地址空間大小大體上受限於被映射文件的大小，但不完全受限於文件大小。打開文件被截短爲5個people結構大小，而在 map_normalfile1中初始化了10個people數據結構，在恰當時候（map_normalfile1輸出initialize over 之後，輸出umap ok之前）調用map_normalfile2會發現map_normalfile2將輸出全部10個people結構的值，後面將給出詳細討論。
注：在linux中，內存的保護是以頁爲基本單位的，即使被映射文件只有一個字節大小，內核也會爲映射分配一個頁面大小的內存。當被映射文件小於一個頁面大小時，進程可以對從mmap()返回地址開始的一個頁面大小進行訪問，而不會出錯；但是，如果對一個頁面以外的地址空間進行訪問，則導致錯誤發生，後面將進一步描述。因此，可用於進程間通信的有效地址空間大小不會超過文件大小及一個頁面大小的和。

3、文件一旦被映射後，調用mmap()的進程對返回地址的訪問是對某一內存區域的訪問，暫時脫離了磁盤上文件的影響。所有對mmap()返回地址空間的操作只在內存中有意義，只有在調用了munmap()後或者msync()時，才把內存中的相應內容寫回磁盤文件，所寫內容仍然不能超過文件的大小。

範例2：父子進程通過匿名映射實現共享內存

<pre name="code" class="cpp"><span style="font-family:Courier New;">#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
typedef struct{
char name[4];
int age;
}people;

main(int argc, char** argv)
{
	int i;
	people *p_map;
	char temp;
	pid_t child_pid;
	p_map=(people*)mmap(NULL,sizeof(people)*10,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0); //此處爲 MAP_ANONYMOUS 和-1
	if((child_pid = fork())== 0)
	{
		sleep(2);
		printf("the child pid read the shared :\n");
		for(i = 0;i<5;i++)
		{
			printf("child read: the %d people's age is %d\n",i+1,(*(p_map+i)).age);
			(*p_map).age = 100;
		}
			munmap(p_map,sizeof(people)*10); //實際上，進程終止時，會自動解除映射。
	}
	else
	{
		printf("the father pid write the shared :\n");
		temp = 'a';
		for(i = 0;i<5;i++)
		{
			temp += 1;
			memcpy((*(p_map+i)).name, &temp,2);
			(*(p_map+i)).age=20+i;
		}
		wait(0);//等待子進程結束後，父進程才接觸映射
		printf("the child over \n");
		printf("umap\n");
		munmap( p_map,sizeof(people)*10 );
		printf( "umap ok\n" );
	}
}
/*結果:
	the father pid write the shared :
	the child pid read the shared :
	child read: the 1 people's age is 20
	child read: the 2 people's age is 21
	child read: the 3 people's age is 22
	child read: the 4 people's age is 23
	child read: the 5 people's age is 24
	the child over 
	umap
	umap ok
*/</span>

四、對mmap()返回地址的訪問

前面對範例運行結構的討論中已經提到，linux採用的是頁式管理機制。對於用mmap()映射普通文件來說，進程會在自己的地址空間新增一塊空間，空間大小由mmap()的len參數指定，注意，進程並不一定能夠對全部新增空間都能進行有效訪問。進程能夠訪問的有效地址大小取決於文件被映射部分的大小。簡單的說，能夠容納文件被映射部分大小的最少頁面個數決定了進程從mmap()返回的地址開始，能夠有效訪問的地址空間大小。超過這個空間大小，內核會根據超過的嚴重程度返回發送不同的信號給進程。可用如下圖示說明：

注意：文件被映射部分而不是整個文件決定了進程能夠訪問的空間大小，另外，如果指定文件的偏移部分，一定要注意爲頁面大小的整數倍。下面是對進程映射地址空間的訪問範例：

<span style="font-weight: normal;"><span style="font-family:Courier New;">#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
typedef struct{
char name[4];
int age;
}people;
main(int argc, char** argv)
{
	int fd,i;
	int pagesize,offset;
	people *p_map;
	 
	pagesize = sysconf(_SC_PAGESIZE);
	printf("pagesize is %d/n",pagesize);
	fd = open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777);
	lseek(fd,pagesize*2-100,SEEK_SET);
	write(fd,"",1);
	offset = 0;	//此處offset = 0編譯成版本1；offset = pagesize編譯成版本2
	p_map = (people*)mmap(NULL,pagesize*3,PROT_READ|PROT_WRITE,MAP_SHARED,fd,offset);
	close(fd);
	 
	for(i = 1; i<10; i++)
	{
		(*(p_map+pagesize/sizeof(people)*i-2)).age = 100;
		printf("access page %d over/n",i);
		(*(p_map+pagesize/sizeof(people)*i-1)).age = 100;
		printf("access page %d edge over, now begin to access page %d/n",i, i+1);
		(*(p_map+pagesize/sizeof(people)*i)).age = 100;
		printf("access page %d over/n",i+1);
	}
	munmap(p_map,sizeof(people)*10);
}</span></span>

如程序中所註釋的那樣，把程序編譯成兩個版本，兩個版本主要體現在文件被映射部分的大小不同。文件的大小介於一個頁面與兩個頁面之間（大小爲：pagesize*2-99），版本1的被映射部分是整個文件，版本2的文件被映射部分是文件大小減去一個頁面後的剩餘部分，不到一個頁面大小(大小爲：pagesize-99)。程序中試圖訪問每一個頁面邊界，兩個版本都試圖在進程空間中映射pagesize*3的字節數。

版本1的輸出結果如下：

pagesize is 4096

access page 1 over

access page 1 edge over, now begin to access page 2

access page 2 over

access page 2 edge over, now begin to access page 3

Bus error //被映射文件在進程空間中覆蓋了兩個頁面，此時，進程試圖訪問第三個頁面

版本2的輸出結果如下：

pagesize is 4096

access page 1 over

access page 1 edge over, now begin to access page 2

Bus error //被映射文件在進程空間中覆蓋了一個頁面，此時，進程試圖訪問第二個頁面

結論：採用系統調用mmap()實現進程間通信是很方便的，在應用層上接口非常簡潔。內部實現機制區涉及到了linux存儲管理以及文件系統等方面的內容，可以參考一下相關重要數據結構來加深理解。在本專題的後面部分，將介紹系統v共享內存的實現。

參考資料

[1] Understanding the Linux Kernel, 2nd Edition, By Daniel P. Bovet, Marco Cesati , 對各主題闡述得重點突出，脈絡清晰。

[2] UNIX網絡編程第二卷：進程間通信，作者：W.Richard Stevens，譯者：楊繼張，清華大學出版社。對mmap()有詳細闡述。

[3] Linux內核源代碼情景分析（上），毛德操、胡希明著，浙江大學出版社，給出了mmap()相關的源代碼分析。

[4]mmap()手冊

mmap映射文件至內存( 實現共享內存與文件的另類訪問 )

mmap的用地：

一、內核怎樣保證各個進程尋址到同一個共享內存區域的內存頁面

---------------------------------看不懂，屬於內核的問題，只要記得共享內存在進程間是即時可見的就可以了！！

二、mmap()及其相關係統調用 mmap、munmap、msync

三、mmap()範例

範例1：兩個進程通過映射普通文件實現共享內存通信-------映射大小、讀寫大小與文件實際大小的關係

範例2：父子進程通過匿名映射實現共享內存

四、對mmap()返回地址的訪問

python gdal 安裝使用（Windows， python 3.6.8）

C 中的 setjmp 和 longjmp 用法

Linux 與 C 的非系統類型定義

實際用戶ID(RUID)，有效用戶ID(EUID)和設置用戶ID(SUID)-----沒看懂，先放着吧

Android的Message機制---Handler、Message、Looper

父子進程的併發性

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

mmap映射文件至內存( 實現 共享內存 與 文件的另類訪問 )

mmap的用地：

一、內核怎樣保證各個進程尋址到同一個共享內存區域的內存頁面

---------------------------------看不懂，屬於內核的問題，只要記得共享內存在進程間是即時可見的就可以了！！

二、mmap()及其相關係統調用 mmap、munmap、msync

三、mmap()範例

範例1：兩個進程通過映射普通文件實現共享內存通信-------映射大小、讀寫大小 與文件實際大小的關係

範例2：父子進程通過匿名映射實現共享內存

四、對mmap()返回地址的訪問

mmap映射文件至內存( 實現共享內存與文件的另類訪問 )

範例1：兩個進程通過映射普通文件實現共享內存通信-------映射大小、讀寫大小與文件實際大小的關係