Het vlaggen argument

De vlaggen argument bepaald of updates van de uit-legging zichtbaar zijn voor andere proces uit-leggingen in dezelfde regio, en of updates worden doorgegeven naar het onderliggende bestand. Het gedrag wordt bepaald door exact een van de volgende waarden in vlaggen:

MAP_SHARED

Deel deze uit-legging. Updates van deze uit-legging zijn zichtbaar voor andere proces uitleggingen in dezelfde regio, en (in het geval van een bestands uit-legging) worden doorgegeven naar het onderliggende bestand. (Om precies te bepalen wanneer updates worden uitgevoerd naar het onderliggende bestand is het nodig om msync(2) te gebruiken.)

MAP_SHARED_VALIDATE (sinds Linux 4.15)

Deze vlag voorziet in hetzelfde gedrag als MAP_SHARED behalve dat MAP_SHARED uit-leggingen negeert bij onbekende vlaggen in vlaggen. Wanneer daarentegen een uit-legging wordt gemaakt met MAP_SHARED_VALIDATE, dan verifieert de kernel of alle doorgegeven vlaggen bekend zijn en stopt met het aanmaken met de fout EOPNOTSUPP voor onbekende vlaggen. Het uit-legging type is ook vereist om in staat te zijn om sommige uit-leggings vlaggen te gebruiken (b.v., MAP_SYNC).

MAP_PRIVATE

Maakt een kopiëren-op-schrijven uit-legging aan. Updates aan de uit-legging zijn niet zichtbaar voor andere processen die hetzelfde bestand bewerken, en worden niet doorgegeven aan het onderliggende bestand. Niet gespecificeerd is of veranderingen gemaakt aan het bestand na de mmap() aanroep zichtbaar zijn in de uit-leggings regio.

Zowel MAP_SHARED en MAP_PRIVATE worden beschreven in POSIX.1-2001 en POSIX.1-2008. MAP_SHARED_VALIDATE is een Linux uitbreiding.

In aanvulling, nul of meer van de volgende waarden kunnen worden geOF´ed in vlaggen:

MAP_32BIT (sinds Linux 2.4.20, 2.6)

Plaats de uit-legging in de eerste 2 gigabyte van de proces adres ruimte. Deze vlag wordt alleen op een x86-64 ondersteund, voor 64-bit programma´s. Hij werd toegevoegd om thread stacks toe te staan ergens in de eerste 2 GB van het geheugen, om zo de context-switch prestaties van de eerste 64-bit processoren te verbeteren. Moderne x86-64 processoren hebben dit prestatie probleem niet meer, daarom is deze vlag op die systemen niet meer nodig. De MAP_32BIT vlag wordt genegeerd als MAP_FIXED is gezet.

MAP_ANON

Synoniem voor MAP_ANONYMOUS; voorzien voor overdraagbaarheid met andere implementaties.

MAP_ANONYMOUS

De uit-legging wordt niet ondersteund door enig bestand; zijn inhoud wordt op nul geïnitialiseerd. Het bi argument wordt genegeerd; hoewel sommige implementaties vereisen dat bi -1 is indien de MAP_ANONYMOUS (of MAP_ANON) werd opgegeven, en overdraagbare applicaties zouden die moeten zeker stellen. Het positie argument moet nul zijn. Het gebruik van MAP_ANONYMOUS in verbinding met MAP_SHARED wordt alleen ondersteund op Linux 2.4.

MAP_DENYWRITE

Deze vlag wordt genegeerd. (Lang geleden—Linux 2.0 en eerder—it signaleerde dat pogingen om te schrijven naar het onderliggende bestand zouden falen met ETXTBSY. Maar dit bleek een bron voor denial-of-service aanvallen.)

MAP_EXECUTABLE

Deze vlag word genegeerd.

MAP_FILE

Overdraagbaarheid vlag. Genegeerd.

MAP_FIXED

Interpreteer start niet als een hint: plaats de uit-legging exact op dit adres. start moet juist uitgelijnd zij: voor de meeste architecturen is een meervoud van de pagina grootte voldoende; hoewel sommige architecturen additionele beperkingen kunnen vereisen. Als de geheugen regio opgegeven door start en lengte pagina´s overlapt van enige bestaande uit-legging(en), dan wordt het overlappende deel van de bestaande uit-legging verworpen. Als het opgegeven adres niet kan worden gebruikt dan zal mmap() falen.

Software die pretendeert overdraagbaar te zijn zou de MAP_FIXED vlag zorgvuldig moeten gebruiken, bedenk dat de exacte layout van de uit-legging van een proces erg mag veranderen tussen Linux versies, C bibliotheek versie en versies van het besturingssysteem. Lees de discussie over deze vlag in NOTITIES!

MAP_FIXED_NOREPLACE (sinds Linux 4.17)

Deze vlag voorziet in gedrag dat vergelijkbaar is met MAP_FIXED rekeninghoudende met de start handhaving, maar verschilt erin dat MAP_FIXED_NOREPLACE nooit een reeds bestaand uit-gelegd gebied vervuild. Indien het gevraagde gebied botst met een bestaande uit-legging, dan faalt deze aanroep met de fout EEXIST. Deze vlag kan daarom worden gebruikt om op een atomaire manier (met het oog op andere threads) te proberen om een adres bereik uit te leggen: een thread zal slagen; alle andere zullen een fout rapporteren.

Let op dat oudere kernels die de MAP_FIXED_NOREPLACE vlag niet herkennen (bij het detecteren van een reeds bestaande uit-legging) terug zullen vallen op een “niet-MAP_FIXED” type of behavior: zij zullen een adres teruggeven dat verschilt van het gevraagde adres. Daarom moet overdraagbare software altijd het teruggegeven adres moeten vergelijken met het gevraagde adres.

MAP_GROWSDOWN

Deze vlag wordt gebruikt door stacks. Hij geeft aan het virtuele geheugen systeem in de kernel aan dat de uit-legging neerwaarts moet uitgebreid worden in het geheugen. Het teruggegeven adres is een pagina lager dan de het geheugen gebied dat daadwerkelijk is aangemaakt in de virtuele adres ruimte van het proces. Het aanraken van een adres in de "bewaakte" pagina onder de uit-legging zal er voor zorgen dat de uit-legging met een pagina groeit. Deze groei kan worden herhaald totdat de uit-legging groeit tot in een pagina aan de hoge kant van de volgende lagere uit-legging, waardoor het aanraken van een "bewaakte" pagina zal resulteren in een SIGSEGV signaal.

MAP_HUGETLB (sinds Linux 2.6.32)

Ken de uit-legging toe gebruik makend van "enorme" pagina´s. Zie het Linux kernel broncode bestand Documentation/admin-guide/mm/hugetlbpage.rst voor meer informatie, en ook NOTITIES, hieronder.

MAP_HUGE_2MB

MAP_HUGE_1GB (sinds Linux 3.8)

Gebruikt in combinatie met MAP_HUGETLB om alternatieve hugetlb pagina maten te selecteren (respectievelijk 2 MB en 1 GB) op systemen die meerdere hugetlb pagina maten ondersteunen.

In het algemeen kan de gewenste enorme pagina worden geconfigureerd door op basis van de 2-logaritme van de gewenste pagina grootte op de zes bits op de positie MAP_HUGE_SHIFT. (Een nul-waarde in dit veld voorziet in de standaard enorme pagina grootte; de standaard enorme pagina grootte kan worden ontdekt door middel van het Hugepagesize veld aangeduid in /proc/meminfo.) Daarom worden de twee constanten hierboven gedefinieerd als:

#define MAP_HUGE_2MB    (21 << MAP_HUGE_SHIFT)
#define MAP_HUGE_1GB    (30 << MAP_HUGE_SHIFT)

Het bereik van de enorme pagina maten die ondersteund worden door het systeem kan worden ontdekt door het oplijsten van de submappen in /sys/kernel/mm/hugepages.

MAP_LOCKED (sinds Linux 2.5.37)

Markeer de uit-gelegde regio op dezelfde manier opgesloten als mlock(2). Deze implementatie zal proberen het gehele gebied te beschrijven (voorgegeven) maar de mmap() aanroep faalt niet met ENOMEM als dit mislukt. Daarom kunnen later forse fouten optreden. Daarom is de semantiek niet zo sterk als mlock(2). Men moet mmap() en mlock(2) gebruiken wanneer forse fouten niet geaccepteerd kunnen worden na de initialisatie van de uit-legging. De MAP_LOCKED vlag wordt genegeerd in oudere kernels.

MAP_NONBLOCK (sinds Linux 2.5.46)

Deze vlag is alleen van betekenis in combinatie met MAP_POPULATE. Voer geen read-ahead uit: creëer pagina tabel ingangen alleen voor pagina´s die al aanwezig zijn in RAM. Vanaf Linux 2.6.23 zorgt deze vlag ervoor dat MAP_POPULATE niks doet. Op een dag kan de combinatie van MAP_POPULATE en MAP_NONBLOCK opnieuw worden geïmplementeerd.

MAP_NORESERVE

Reserveer geen swap ruimte voor deze uit-legging. Indien de swap ruimte wordt gereserveerd, dan moet men garanderen dat het mogelijk is de uit-legging te modificeren. Indien swap ruimte niet gereserveerd werd dan zou met een SIGSEGV kunnen krijgen bij het schrijven als geen fysiek geheugen beschikbaar is. Zie ook de discussie over het bestand /proc/sys/vm/overcommit_memory in proc(5). In Linux voor 2.6, had deze vlag alleen effect in private schrijfbare uit-leggingen.

MAP_POPULATE (sinds Linux 2.5.46)

Gebruik (voorgegeven) pagina tabellen voor een uit-legging. Dit veroorzaakt het voor-lezen van een bestand voor een bestands uit-legging. Het helpt om het blokkeren van pagina fouten nadien te reduceren. De mmap() aanroep mislukt niet als de uit-legging niet kan worden voorgegeven (bij voorbeeld, vanwege limitaties op het aantal uit-gelegde enorme pagina´s bij het gebruik van MAP_HUGETLB). MAP_POPULATE wordt alleen ondersteund voor private uit-leggingen vanaf Linux 2.6.23.

MAP_STACK (sinds Linux 2.6.27)

Wijs de uit-legging toe aan een adres dat geschikt is voor een proces of thread stack.

Deze vlag doet momenteel niks op Linux. Hoewel, door deze vlag te gebruiken kunnen applicaties zeker stellen dat zij transparant ondersteund worden zodra deze vlag in de toekomst ondersteund wordt. Dan zal hij worden gebruikt in de glibc threading implementatie om toe te staan dat sommige architecturen (later) speciale behandeling voor stack toewijzingen vereisen. En andere reden om deze vlag te gebruiken is overdraagbaarheid: MAP_STACK bestaat (en heeft een effect) op sommige andere systemen (b.v. sommige van de BSDs).

MAP_SYNC (sinds Linux 4.15)

Deze vlag is alleen beschikbaar bij het MAP_SHARED_VALIDATE uit-legging type; uit-leggingen van het MAP_SHARED type negeren deze vlag stilzwijgend. Deze vlag wordt alleen ondersteund op bestanden die DAX (direct uit-leggen van blijvend geheugen) ondersteunen. Voor andere bestanden, zal het aanmaken van een uit-legging met deze vlag resulteren in een EOPNOTSUPP fout.

Gedeelde bestands uit-leggingen met deze vlag voorzien in de garantie dat terwijl sommig geheugen schrijfbaar is uit-gelegd in de adres ruimte van dat proces, het zichtbaar zal zijn in hetzelfde bestand op dezelfde positie, zelfs nadat het systeem is gecrasht of is geherstart. In combinatie met het gebruik van de gepaste CPU instructies, worden gebruikers van deze uit-leggingen voorzien in een meer efficiënte manier van het persistent maken van de data wijzigingen.

MAP_UNINITIALIZED (vanaf Linux 2.6.33)

Wis anonieme pagina´s niet. Deze vlag is bedoeld om prestaties te verbeteren op embedded apparaten. Deze vlag wordt alleen gebruikt indien de kernel werd geconfigureerd met de CONFIG_MMAP_ALLOW_UNINITIALIZED optie. Vanwege de veiligheid implicaties wordt deze optie alleen aangezet op embedded apparaten (m.a.w. apparaten waarin met complete controle heeft over de inhoud van het geheugen.

Van de bovenstaande vlaggen is alleen MAP_FIXED gespecificeerd in POSIX.1-2001 en POSIX.1-2008. Hoewel de meeste systemen ook MAP_ANONYMOUS ondersteunen (of zijn synoniem MAP_ANON).

munmap()

De mummap() systeem aanroep verwijderd de uit-leggingen voor het aangegeven adres gebied, en zorgt er voor dat verdere referenties naar adressen in het gebied niet-geldige geheugen referenties op leveren. Het gebied wordt ook automatisch ont-uit-gelegd wanneer het proces wordt beëindigt. Aan de andere kant zal het sluiten van de bestandsindicator het gebied niet on-uitleggen.

Het adres start moet een meervoud zijn van de pagina grootte (maar lengte hoeft dat niet te zijn). Alle pagina´s die een deel van het aangegeven gebied bevatten worden ont-uit-gelegd, en volgende referenties naar deze pagina´s zullen een SIGSEGV opleveren. Het is geen fout als het aangegeven gebied enige uit-gelegde pagina´s bevat.

C library/kernel verschillen

Deze pagina beschrijft het interface waarin glibc mmap() omwikkel functie voorziet. Origineel riep deze functie een systeem aanroep aan van dezelfde naam. Vanaf Linux 2.4 is deze systeem aanroep opgevolgd door mmap2(2), en momenteel roept de glibc mmap() omwikkel functie mmap2(2) met een geschikt aangepaste waarde voor positie.

Gebruik MAP_FIXED veilig

Het enige veilige gebruik van MAP_FIXED is indien het adresbereik gespecificeerd door start en lengte voordien gereserveerd werd door een andere uit-legging; anders is het gebruik van MAP_FIXED foutgevoelig om het bestaande uit-leggingen geforceerd verwijderd, hetgeen het mogelijk maakt voor een multithreaded proces om zijn eigen adresruimte te corrumperen.

Bijvoorbeeld, neem aan dat thread A door /proc/pid/maps loopt om de niet gebruikte adres ruimte te vinden die het kan uit-leggen door MAP_FIXED te gebruiken, terwijl thread B tegelijkertijd een deel of alles van dezelfde adres ruimte acquireert. Wanneer nu thread A vervolgens mmap(MAP_FIXED) gebruikt dan zal deze effectief de uit-legging die thread B maakte kapot maken. In dit scenario zou thread B niet direct een uit-legging moeten maken; eenvoudig weg het aanroepen van een bibliotheek functie die, intern, dlopen(3) gebruikt, om een andere gedeelde bibliotheek te laden, is voldoende. De dlopen(3) aanroep zal de bibliotheek op de adresruimte van het proces uit-leggen. Bovendien kan bijna elke bibliotheek aanroep worden geïmplementeerd op een manier die geheugen uit-legging toevoegt aan de adres ruimte, ofwel met deze techniek, ofwel door eenvoudigweg geheugen te alloceren. Voorbeelden hiervan zijn onder anderen brk(2), malloc(3), pthread_create(3), en de PAM bibliotheken http://www.linux-pam.org.

Vanaf Linux 4.17 kan een multithreaded programma de MAP_FIXED_NOREPLACE vlaggen gebruiken om het hierboven beschreven gevaar te voorkomen bij het aanmaken van een uit-legging op een vast adres dat werd gereserveerd door een bestaande uit-legging.

Tijdstempel veranderingen voor bestand-backed uit-leggingen

Voor bestand-backed uit-leggingen, mag het st_atime veld van het uit-gelegde bestand worden geüpdatet met elk tijdstip tussen de mmap() en de daarmee overeenkomende ont-uit-legging; de eerste referentie naar een uit-gelegde pagina zal het veld updaten als het al niet geüpdatet was.

De st_ctime en st_mtime velden voor een uit-gelegd bestand met PROT_WRITE en MAP_SHARED worden geüpdatet na het schrijven naar een uit-gelegde regio, en voor een volgende msync(2) met de MS_SYNC of MS_ASYNC vlag, als er een optreed.

Enorme pagina (ENORME TLB) uit-leggingen.

Voor uit-leggingen die enorme pagina´s gebruiken, verschillen de eisen voor de argumenten van mmap() en munmap() iets van de eisen voor de uit-leggingen die de eigen systeem pagina grootte gebruiken.

Voor mmap(), moet positie en lengte een meervoud van de onderliggende enorme pagina grootte zijn. Het systeem lijnt automatisch lengte op een meervoud van de onderliggende enorme pagina grootte aan.

Voor munmap(), start en lengte moeten beiden een meervoud van de onderliggende enorme pagina grootte zijn.

Programma bron

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#define handle_error(msg) \
    do { perror(msg); exit(EXIT_FAILURE); } while (0)
int
main(int argc, char *argv[])
{
    int          fd;
    char         *addr;
    off_t        offset, pa_offset;
    size_t       length;
    ssize_t      s;
    struct stat  sb;
    if (argc < 3 || argc > 4) {
        fprintf(stderr, "%s file offset [length]\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    fd = open(argv[1], O_RDONLY);
    if (fd == -1)
        handle_error("open");
    if (fstat(fd, &sb) == -1)           /* To obtain file size */
        handle_error("fstat");
    offset = atoi(argv[2]);
    pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);
        /* offset for mmap() must be page aligned */
    if (offset >= sb.st_size) {
        fprintf(stderr, "offset is past end of file\n");
        exit(EXIT_FAILURE);
    }
    if (argc == 4) {
        length = atoi(argv[3]);
        if (offset + length > sb.st_size)
            length = sb.st_size - offset;
                /* Can't display bytes past end of file */
    } else {    /* No length arg ==> display to end of file */
        length = sb.st_size - offset;
    }
    addr = mmap(NULL, length + offset - pa_offset, PROT_READ,
                MAP_PRIVATE, fd, pa_offset);
    if (addr == MAP_FAILED)
        handle_error("mmap");
    s = write(STDOUT_FILENO, addr + offset - pa_offset, length);
    if (s != length) {
        if (s == -1)
            handle_error("write");
        fprintf(stderr, "partial write");
        exit(EXIT_FAILURE);
    }
    munmap(addr, length + offset - pa_offset);
    close(fd);
    exit(EXIT_SUCCESS);
}