Provided by: manpages-nl-dev_4.21.0-2_all 
NAAM
mmap, munmap - leg-uit of ont-leg-uit bestanden of apparaten in het werkgeheugen
BIBLIOTHEEK
Standard C bibliotheek (libc, -lc)
SAMENVATTING
#include <sys/mman.h>
void *mmap(void *start, size_t lengte, int prot, int vlaggen,
int bi, off_t positie);
int munmap(void start[.lengte], size_t lengte);
Zie NOTITIES voor informatie over functie test macro vereisten.
BESCHRIJVING
mmap() maakt nieuwe uit-legging aan in de virtuele adres ruimte van het aanroepende
proces. Het begin adres van de nieuwe uit-legging wordt opgegeven in start. Het lengte
argument specificeert de lengte van de uit-legging (die groter moet zijn dan 0).
Als start NULL is, dan kiest de kernel een (aan een pagina-uitgelijnd) adres waarop de
uit-legging gemaakt moet worden; dit is de meest overdraagbare methode van het aanmaken
van een nieuwe uit-legging. Als start niet NULL is, dan gebruikt de kernel het als een
hint waarop de uit-legging geplaatst zou moeten worden; op Linux, zal de kernel een
nabijgelegen pagina grens selecteren (maar altijd hoger of gelijk aan de waarde opgegeven
in /proc/sys/vm/mmap_min_addr) en proberen om daar de uit-legging te maken. Als daar al
een andere uit-legging bestaat, dan selecteert de kernel een nieuw adres dat al of niet
afhankelijk is van de hint. Het adres van de nieuwe uit-legging wordt teruggegeven als
resultaat van de aanroep.
De inhoud van de bestand uit-legging (in tegenstelling tot een anonieme uit-legging; zie
MAP_ANONYMOUS hieronder), wordt geïnitialiseerd door lengte bytes beginnende bij de
positie in het bestand (of ander object( aangewezen door de bestandsindicator bi. positie
moet een meervoud zijn van de pagina grootte zoals teruggegeven door
sysconf(_SC_PAGE_SIZE).
Nadat de mmap() aanroep is beëindigt kan de bestandsindicator bi onmiddellijk worden
gesloten zonder het ongeldig maken van de uit-legging.
Het prot argument beschrijft de vereiste geheugen bescherming van de uit-legging (dit moet
niet conflicteren met de open modus van het bestand). Het is of PROT_NONE of de
bitsgewijze OR of een een of meer van de volgende vlaggen:
PROT_EXEC Pagina's mogen uitgevoerd worden.
PROT_READ Pagina's mogen gelezen worden.
PROT_WRITE Pagina's mogen geschreven worden.
PROT_NONE Pagina's zijn niet toegankelijk.
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.
EIND WAARDE
Bij succes geeft mmap() een pointer naar een uit-gelegd gebied terug. Bij een fout, wordt
de waarde MAP_FAILED (dat is, (void *) -1) terug gegeven, en wordt errno overeenkomstig
gezet.
Bij succes geeft munmap() 0 terug. Bij falen geeft het -1 terug en errno wordt
overeenkomstig gezet (waarschijnlijk op EINVAL).
FOUTEN
EACCES Een bestands indicator wijst naar een niet-regulier bestand. Of een bestands
uit-legging werd gevraagd, maar bi is niet open voor lezen. Of MAP_SHARED werd
gevraagd en PROT_WRITE is gezet, maar bi is niet open in schrijf/lees (O_RDWR)
modus. Of PROT_WRITE werd gezet, maar het bestand is alleen-achteraan-toevoegen.
EAGAIN Het bestand was vergrendeld of teveel geheugen was vergrendeld (zie setrlimit(2)).
EBADF bi is geen geldige bestandindicator (en MAP_ANONYMOUS was niet gezet).
EEXIST MAP_FIXED_NOREPLACE werd specified in vlaggen, en het bereik bedekt door start and
lengte botst met een bestand
EINVAL We houden niet van start of lengte of positie (ze zijn b.v. te groot of niet
uitgelijnd op een pagina grens.
EINVAL (sinds Linux 2.6.12) lengte was 0.
EINVAL vlaggen bevatte noch MAP_PRIVATE, MAP_SHARED, of MAP_SHARED_VALIDATE.
ENFILE De grens aan het aantal open bestanden van het systeem is bereikt.
ENODEV Het onderliggende bestandssysteem van het opgegeven bestand ondersteund uit-leggen
van het geheugen niet.
ENOMEM Geen geheugen beschikbaar.
ENOMEM Het maximaal aantal uit-leggingen zou zijn overschreden. Deze fout kan ook optreden
voor munmap() bij het on-uitleggen van een regio in het midden van een bestaande
uit-legging, omdat dit resulteert in twee kleinere uit-leggingen aan beide zijden
van de regio die ont-uit-gelegd wordt.
ENOMEM (vanaf Linux 4.7) De proces limiet RLIMIT_DATA beschreven in getrlimit(2), zou zijn
overschreden.
ENOMEM We houden niet van start, omdat dit de virtuele adres ruimte van de CPU
overschrijd.
EOVERFLOW
Op 32-bit architecturen samen met de grote bestand uitbreiding (m.a.w. gebruik van
64-bit off_t): het aantal pagina´s gebruikt voor lengte plus het aantal pagina´s
gebruikt voor positie zou de unsigned long (32 bits) overlopen.
EPERM Het prot argument vraag om PROT_EXEC maar het uitgelegde gebied behoort bij een
bestand op een bestandssysteem dat als niet-executeerbaar gekoppeld is.
EPERM De operatie werd voorkomen door een bestandszegel; zie fcntl(2).
EPERM De MAP_HUGETLB vlag werd opgegeven, maar de aanroeper was niet gerechtigd (had niet
de CAP_IPC_LOCK capaciteit) en is geen lid van de sysctl_hugetlb_shm_group groep;
zie de beschrijving van /proc/sys/vm/sysctl_hugetlb_shm_group in
ETXTBSY
MAP_DENYWRITE werd gezet maar het voorwerp opgegeven door bi is open voor
schrijven.
Het gebruik van een uit-gelegde regio kan resulteren in deze signalen:
SIGSEGV
Poging om te schrijven in een als alleen-lezen uit-gelegd gebied.
SIGBUS Een toegangspoging naar een pagina van de buffer die verder ligt dan het einde van
het in kaart gebrachte bestand. Voor een uitleg van de behandeling van de bytes in
de pagina die overeenkomt met het einde van een in kaart gebracht bestand die geen
meervoud is van de pagina grootte, zie NOTITIES.
ATTRIBUTEN
Voor een uitleg van de termen in deze sectie, zie attributes(7).
┌───────────────────────────────────────────────────────────┬───────────────────┬─────────┐
│Interface │ Attribuut │ Waarde │
├───────────────────────────────────────────────────────────┼───────────────────┼─────────┤
│mmap(), munmap() │ Thread veiligheid │ MT-Safe │
└───────────────────────────────────────────────────────────┴───────────────────┴─────────┘
VOLDOET AAN
POSIX.1-2001, POSIX.1-2008, SVr4, 4.4BSD.
Op POSIX systemen waarop mmap(), msync(2), en munmap() beschikbaar zijn, is
_POSIX_MAPPED_FILES gedefinieerd in <unistd.h> met een waarde groter dan 0. (Zie ook
sysconf(3).)
OPMERKINGEN
Door mmap() in kaart gebracht geheugen wordt bewaard langs fork(2), met dezelfde
attributen.
Een bestand is uit-gelegd in meervouden van de pagina grootte. Van een bestand dat geen
meervoud van de pagina grootte is, worden de resterende bytes in de gedeeltelijke pagina
aan het einde van de uit-legging op nul gezet tijdens het uit-leggen, en modificaties aan
die regio worden niet geschreven naar het bestand. Het effect van de verandering van de
grootte van het onderliggende bestand van een uit-legging op de pagina´s die overeenkomen
met toegevoegde of verwijderde regio´s van dat bestand is niet gespecificeerd.
Op sommige hardware architecturen (b.v. i386), impliceert PROT_WRITE PROT_READ. Het is
architectuur afhankelijk of PROT_READ al dan niet PROT_EXEC impliceert. Overdraagbare
programma´s zouden altijd PROT_EXEC moeten zetten als ze van plan zijn om code uit te
voeren in het nieuwe overzicht.
De overdraagbare manier om uit-leggingen te maken is door start als 0 (NULL) op te geven,
en MAP_FIXED weg te laten uit vlaggen. In dat geval kiest het systeem het adres voor de
uit-legging; dit adres wordt zodanig gekozen dat het niet conflicteert met enige bestaande
uit-legging, en zal niet 0 zijn. Als de MAP_FIXED flag werd opgegeven, en start is 0
(NULL), dan zal het uit-gelegde adres 0 (NULL) zijn.
Bepaalde vlaggen constanten zijn alleen gedefinieerd als bepaalde feature test macro´s
werden gedefinieerd (mogelijk standaard): _DEFAULT_SOURCE met glibc 2.19 of later; of
_BSD_SOURCE of _SVID_SOURCE in glibc 2.19 en eerder. (Gebruik van _GNU_SOURCE is genoeg,
deze macro specifiek vereisen zou meer logisch geweest zijn, omdat deze vlaggen allen
Linux-specifiek zijn.) De relevante vlaggen zijn: MAP_32BIT, MAP_ANONYMOUS (en zijn
synoniem MAP_ANON), MAP_DENYWRITE, MAP_EXECUTABLE, MAP_FILE, MAP_GROWSDOWN, MAP_HUGETLB,
MAP_LOCKED, MAP_NONBLOCK, MAP_NORESERVE, MAP_POPULATE, en MAP_STACK.
Een applicatie kan bepalen welke pagina´s van een uit-legging aanwezig zijn in de
buffer/pagina cache door mincore(2) te gebruiken.
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.
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.
BUGS
Op Linux zijn er geen garanties zoals die, die hierboven gesuggereerd werden onder
MAP_NORESERVE. Standaard kan elke proces op elke moment worden beëindigd zodra het
geheugen van het systeem vol raakt.
In Linux vóór 2.6.7, heeft de MAP_POPULATE vlag alleen effect als prot werd opgegeven als
PROT_NONE
SUSv3 specificeert dat mmap() moet falen als length 0 is. Echter, in kernels voor
2.6.12, was mmap() succesvol in dit geval: er werd geen uit-legging gemaakt en de aanroep
retourneerde adres. Vanaf Linux 2.6.12, faalt mmap() in dit geval met de foutmelding
EINVAL.
POSIX specificeert dat het systeem altijd enige gedeeltelijke pagina vult met nullen aan
het einde van een object en dat het systeem nooit enige wijziging van het object zal
schrijven voorbij zijn einde. Wanneer u data schrijft naar zo´n gedeeltelijke pagina na
het einde van een object op Linux, dan zal deze data op de pagina cache aanwezig blijven
zelfs nadat het bestand werd gesloten en ont-uit-gelegd en zelfs als de data nooit werd
geschreven naar het bestand zelf, volgende uit-leggingen kunnen de gewijzigde inhoud zien.
In sommige gevallen kan dit worden opgelost door het aanroepen van msync(2) voordat het
ont-uit-leggen plaats vind; hoewel dit niet werkt voor tmpfs(5), (b.v. bij het gebruik
van het van het POSIX gedeeld geheugen interface, zoals gedocumenteerd in
shm_overview(7)).
VOORBEELDEN
Het volgende programma schrijft delen van het bestand, opgegeven in het eerste argument op
de commando regel, naar standaard uitvoer. Het bereik van de te schrijven bytes wordt
bepaald door middel van de positie en lengte waarden opgegeven in het tweede en derde
argument op de commando regel. Het programma maakt een geheugen uit-legging aan van de
vereiste pagina´s van het bestand en gebruikt vervolgens write(2) om de gewenste bytes te
tonen.
Programma bron
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.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) /* om bestand grootte te verkrijgen */
handle_error("fstat");
offset = atoi(argv[2]);
pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);
/* positie voor mmap() moet uitgelijnd zijn op een pagina */
if (offset >= sb.st_size) {
fprintf(stderr, "positie voorbij einde van het bestand\n");
exit(EXIT_FAILURE);
}
if (argc == 4) {
length = atoi(argv[3]);
if (offset + length > sb.st_size)
length = sb.st_size - offset;
/* Kan geen bytes tonen voorbij einde van het bestand */
} else { /* No length arg ==> display to end of file */
length = sb.st_size - offset;
}
start = mmap(NULL, lengte + offset - pa_offset, PROT_READ,
MAP_PRIVATE, fd, pa_offset);
if (start == MAP_FAILED)
handle_error("mmap");
s = write(STDOUT_FILENO, start + offset - pa_offset, lengte);
if (s != lengte) {
if (s == -1)
handle_error("write");
fprintf(stderr, "partial write");
exit(EXIT_FAILURE);
}
munmap(start, lengte + offset - pa_offset);
close(fd);
exit(EXIT_SUCCESS);
}
ZIE OOK
ftruncate(2), getpagesize(2), memfd_create(2), mincore(2), mlock(2), mmap2(2),
mprotect(2), mremap(2), msync(2), remap_file_pages(2), setrlimit(2), shmat(2),
userfaultfd(2), shm_open(3), shm_overview(7)
De beschrijving van de volgende bestanden in proc(5): /proc/[pid]/maps,
/proc/[pid]/map_files, en /proc/[pid]/smaps.
B.O. Gallmeister, POSIX.4, O'Reilly, pp. 128–129 en 389–391.
VERTALING
De Nederlandse vertaling van deze handleiding is geschreven door Jos Boersema
<joshb@xs4all.nl>, Mario Blättermann <mario.blaettermann@gmail.com> en Luc Castermans
<luc.castermans@gmail.com>
Deze vertaling is vrije documentatie; lees de GNU General Public License Version 3
⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ of later over de Copyright-voorwaarden. Er is
geen AANSPRAKELIJKHEID.
Indien U fouten in de vertaling van deze handleiding zou vinden, stuur een e-mail naar
⟨debian-l10n-dutch@lists.debian.org⟩.