Was ist der Zweck des flag MAP_ANONYMOUS in mmap-Systemaufruf?

Anonyme mappings können abgebildet werden als zeroized virtuellen Datei.
Anonyme mappings sind einfach große, null-gefüllten Speicherblöcke bereit für den Einsatz.
Diese Zuordnungen, die Ihren Wohnsitz außerhalb des heap, also nicht zur Daten-segment Fragmentierung.

MAP_ANONYMOUS + MAP_PRIVATE:

• jeder Aufruf erzeugt eine eindeutige Zuordnung
• Kinder, Erben die Eltern Zuordnungen
• Kinder", schreibt auf die geerbten mapping berücksichtigt werden, in copy-on-write Weise
• der Hauptzweck der Verwendung dieser Art von mapping zuweisen eine neue zeroized Speicher
• malloc beschäftigt anonymen privaten Zuordnungen zu dienen Speicherzuordnung größer als MMAP_THRESHOLD bytes.
  
  in der Regel, MMAP_THRESHOLD ist 128kB.

MAP_ANONYMOUS + MAP_SHARED:

• jeder Aufruf erzeugt eine eindeutige Zuordnung nicht teilen, Seiten mit anderen mapping
• Kinder, Erben die Eltern Zuordnungen
• keine copy-on-write, wenn jemand anderes teilen die mapping-Schreibvorgänge auf freigegebenen mapping -
• shared anonymous mappings ermöglichen IPC in einer Art und Weise ähnlich zu System-V-memory-Segmente, aber nur zwischen verwandten Prozessen

Unter Linux, es gibt zwei Möglichkeiten zum erstellen von anonymen mappings:

• angeben MAP_ANONYMOUS-flag und übergeben Sie -1 für fd

      addr = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); 
      if (addr == MAP_FAILED)
          exit(EXIT_FAILURE);  
  

• open /dev/null und übergeben Sie diese öffnete fd

      fd = open("/dev/zero", O_RDWR);   
      addr = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
  

  (diese Methode wird normalerweise verwendet, auf Systemen wie BSD, die keine flag MAP_ANONYMOUS)

Vorteile der anonymen mappings:

- keine virtuellen Adressraum Fragmentierung; nach der Abkopplung, der Speicher wird sofort an das system zurückgegeben

- Sie sind veränderbar in Bezug auf die Zuweisung Größe, Berechtigungen und können Sie auch beraten, wie normale mappings

- jede Zuordnung ist eine eindeutige Zuordnung, getrennt von globalen heap

Nachteile der anonymen mappings:

- Größe der einzelnen mapping ist ein ganzzahliges Vielfaches der system-Seite die Größe, so kann es führen, um die Verschwendung von Adressraum

- erstellen und zurückgeben Zuordnungen mehr Aufwand als der aus der pre-allokierten heap

wenn ein Programm mit solchen Zuordnung, Gabeln eines Prozesses, das Kind erbt die Zuordnung.
Das folgende Programm veranschaulicht diese Art der Vererbung:

#ifdef USE_MAP_ANON
#define _BSD_SOURCE
#endif  
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
    /*Pointer to shared memory region*/    
    int *addr;   

#ifdef USE_MAP_ANON      /*Use MAP_ANONYMOUS*/           
     addr = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);     
     if (addr == MAP_FAILED) {     
         fprintf(stderr, "mmap() failed\n");     
         exit(EXIT_FAILURE);
     }      

#else        /*Map /dev/zero*/     
    int fd;    
    fd = open("/dev/zero", O_RDWR);      
    if (fd == -1) {    
        fprintf(stderr, "open() failed\n");
        exit(EXIT_FAILURE);
    }    

    addr = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);    
    if (addr == MAP_FAILED) {    
        fprintf(stderr, "mmap() failed\n");    
        exit(EXIT_FAILURE);    
    }     

    if (close(fd) == -1) {          /*No longer needed*/    
        fprintf(stderr, "close() failed\n");    
        exit(EXIT_FAILURE);    
    }
#endif    
    *addr = 1;      /*Initialize integer in mapped region*/    

    switch(fork()) {        /*Parent and child share mapping*/     
    case -1:    
        fprintf(stderr, "fork() failed\n");
        exit(EXIT_FAILURE);    

    case 0:         /*Child: increment shared integer and exit*/     
        printf("Child started, value = %d\n", *addr);    
        (*addr)++;    

        if (munmap(addr, sizeof(int)) == -1) {    
            fprintf(stderr, "munmap()() failed\n");    
            exit(EXIT_FAILURE);    
        }     
        exit(EXIT_SUCCESS);     

    default:        /*Parent: wait for child to terminate*/      
        if (wait(NULL) == -1) {    
            fprintf(stderr, "wait() failed\n");    
            exit(EXIT_FAILURE);      
        }     

        printf("In parent, value = %d\n", *addr);         
        if (munmap(addr, sizeof(int)) == -1) {       
            fprintf(stderr, "munmap()() failed\n");      
            exit(EXIT_FAILURE);       
        }        
        exit(EXIT_SUCCESS);
}

Quellen:

The Linux Programming Interface

Kapitel 49: Speicher-Mappings

Autor: Michael Kerrisk

Linux System Programming (3rd edition)

Kapitel 8: Speicherverwaltung

Autor: Robert Liebe