Das Argument »flags«¶

MAP_SHARED

Das Mapping gemeinsam benutzen. Aktualisierungen dieses Mappings sind für andere Prozesse in dem gleichen Bereich sichtbar und (falls es sich um Datei-basierende Mappings handelt) werden zu der zugrundeliegenden Datei weitergereicht. (Um genau zu steuern, wann Aktualisierungen zu der zugrundeliegenden Datei weitergereicht werden, muss msync(2) eingesetzt werden.)

MAP_SHARED_VALIDATE (seit Linux 4.15)

Dieser Schalter stellt das gleiche Verhalten wie MAP_SHARED bereit, außer dass MAP_SHARED-Mappings unbekannte Schalter in flags ignorieren. Im Gegensatz überprüft der Kernel, wenn er Mappings mittels MAP_SHARED_VALIDATE erstellt, dass alle übergebenen Schalter bekannt sind und schlägt mit dem Fehler EOPNOTSUPP bei unbekannten Schaltern fehl. Dieser Mapping-Typ wird auch benötigt, um bestimmte Mapping-Schalter (z.B. MAP_SYNC) verwenden zu können.

MAP_PRIVATE

Erstellt ein privates, beim Kopieren zu schreibendes Mapping. Aktualisierungen an dem Mapping sind für andere Prozesse, die die gleiche Datei mappen, nicht sichtbar, und werden nicht an die zugrundeliegende Datei weitergeleitet. Es ist nicht spezifiziert, ob Änderungen an der Datei, die nach dem Aufruf von mmap() erfolgen, in der gemappten Region sichtbar sind.

Sowohl MAP_SHARED als auch MAP_PRIVATE werden in POSIX.1-2001 und POSIX.1-2008 beschrieben. MAP_SHARED_VALIDATE ist eine Linux-Erweiterung.

Zusätzlich können null oder mehrere der folgenden Werte mit OR in flags hinzugefügt werden:

MAP_32BIT (seit Linux 2.4.20, 2.6)

Legt das Mapping in die ersten zwei Gigabyte des Prozessadressraums. Dieser Schalter wird nur auf X86-64 für 64-Bit-Programme unterstützt. Er wurde hinzugefügt, damit Thread-Stacks irgendwo innerhalb der ersten 2 GB Speicher zugewiesen werden können, damit die Leistung des Kontext-Umschaltens auf einigen der ersten 64-Bit-Prozessoren erhöht wird. Moderne X86-64-Prozessoren haben dieses Leistungsproblem nicht mehr, wodurch der Einsatz dieses Schalters auf diesen Systemen nicht mehr benötigt wird. Der Schalter MAP_32BIT wird ignoriert, wenn MAP_FIXED gesetzt ist.

MAP_ANON

Synonym für MAP_ANONYMOUS; zur Kompatibilität mit anderen Implementierungen bereitgestellt.

MAP_ANONYMOUS

Diesem Mapping liegt keine Datei zugrunde; ihr Inhalt wird mit Nullen initialisiert. Das Argument fd wird ignoriert, einige Implementierungen verlangen aber, dass fd -1 ist, falls MAP_ANONYMOUS (oder MAP_ANON) festgelegt ist, und portable Anwendungen sollten dies sicherstellen. Das Argument offset sollte 0 sein. Unter Linux wird die Kombination von MAP_ANONYMOUS mit MAP_SHARED erst ab Kernelversion 2.4 unterstützt.

MAP_DENYWRITE

Dieser Schalter wird ignoriert. (Vor langer Zeit — Linux 2.0 und älter — signalisierte er, dass Schreibversuche auf die zugrundeliegende Datei mit ETXTBSY fehlschlagen sollten. Dies war aber eine Quelle von Diensteverweigerungsangriffen.

MAP_EXECUTABLE

Dieser Schalter wird ignoriert.

MAP_FILE

Kompatibilitätsschalter. Ignoriert.

MAP_FIXED

addr wird nicht als Hinweis interpretiert; legt das Mapping genau an dieser Adresse an. addr muss geeignet ausgerichtet sein: bei den meisten Architekturen reicht ein Vielfaches der Seitengröße aus, allerdings könnten einige Architekturen zusätzliche Anforderungen stellen. Falls der mit addr und len festgelegte Speicherbereich bestehende Mappings überlappt, dann wird der überlappende Anteil des bestehenden Mappings verworfen. Falls die angegebene Adresse nicht verwandt werden kann, wird mmap() fehlschlagen.

Software, die Portierbarkeit anstrebt, sollte den Schalter MAP_FIXED mit Vorsicht verwenden und dabei berücksichtigen, dass sich die genaue Anordnung der Mappings des Prozesses im Speicher deutlich zwischen Kernelversionen, C-Bibliotheksversionen und Betriebssystemveröffentlichungen unterscheiden kann. Lesen Sie die Erörterung dieses Schalters im Abschnitt ANMERKUNGEN sorgfältig!

MAP_FIXED_NOREPLACE (seit Linux 4.17)

Dieser Schalter stellt ein Verhalten bereit, das MAP_FIXED im Hinblick auf die Erzwingung von addr ähnelt, sich aber dadurch unterscheidet, dass MAP_FIXED_NOREPLACE einen bereits bestehenden, gemappten Bereich durcheinanderbringt. Falls der angeforderte Bereich mit einem bestehenden Mapping kollidieren würde, dann schlägt dieser Aufruf mit EEXIST fehl. Dieser Schalter kann daher für atomare (im Hinblick auf andere Threads) Versuche, einen Adressbereich zu mappen, verwandt werden: ein Thread hat Erfolg, alle anderen berichten einen Fehlschlag.

Note that older kernels which do not recognize the MAP_FIXED_NOREPLACE flag will typically (upon detecting a collision with a preexisting mapping) fall back to a "non-MAP_FIXED" type of behavior: they will return an address that is different from the requested address. Therefore, backward-compatible software should check the returned address against the requested address.

MAP_GROWSDOWN

Dieser Schalter wird für Stacks verwandt. Er zeigt dem Kernelsystem für virtuellen Speicher an, dass sich das Mapping nach unten im Speicher ausdehnen soll. Die zurückgelieferte Adresse ist eine Seite tiefer als der Speicherbereich, der tatsächlich im virtuellen Adressraum des Prozesses erstellt wird. Wird eine Adresse in der »Wächter«-Seite unterhalb des Mappings berührt, dann wächst das Mapping um eine Seite. Dieses Wachstum kann wiederholt werden, bis das Mapping bis auf eine Seite innerhalb des hohen Endes des nächst-niedrigeren Mappings anwächst - zu diesem Zeitpunkt führt das Berühren der »Wächter«-Seite zu einem SIGSEGV-Signal.

MAP_HUGETLB (seit Linux 2.6.32)

Reserviert das Mapping mittels »großer Speicherseiten«. Siehe die Linux-Kernelquelldatei Documentation/admin-guide/mm/hugetlbpage.rst sowie die nachfolgenden ANMERKUNGEN für weitere Details.

MAP_HUGE_2MB, MAP_HUGE_1GB (seit Linux 3.8)

Wird in Zusammenhang mit MAP_HUGETLB verwandt, um alternative hugetlb-Seitengrößen (respektive 2 MB und 1 GB) auf Systemen auszuwählen, die mehrere hugetlb-Seitengrößen unterstützen.

Allgemeiner kann die gewünschte Größe der großen Seiten durch Kodierung des Logarithmus zur Basis 2 der gewünschten Seitengröße in den sechs Bits am Versatz MAP_HUGE_SHIFT konfiguriert werden. (Ein Wert 0 in diesem Bitfeld stellt die Vorgabe »große Seitengröße« bereit; die Vorgabe große Seitengröße kann mittels des durch /proc/meminfo offengelegten Feldes Hugepagesize ermittelt werden.) Daher sind die obigen zwei Konstanten wie folgt definiert:

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

    

Der von dem System unterstützte Bereich der Größe der großen Seiten kann durch Auflisten der Unterverzeichnisse in /sys/kernel/mm/hugepages ermittelt werden.

MAP_LOCKED (seit Linux 2.5.37)

Markiert den gemappten Bereich auf die gleiche Art wie mlock(2). Diese Implementierung wird versuchen, den gesamten Bereich vorzubelegen (»prefault«) aber der Aufruf von mmap() wird nicht mit ENOMEM fehlschlagen, falls dies nicht gelingt. Daher können später große Ausnahmebehandlungen passieren. Daher ist die Semantik nicht so stark wie mlock(2). Sie sollten mmap() mit mlock(2) verwenden, wenn große Ausnahmebehandlungen nach der Initialisierung des Mappings nicht akzeptierbar sind. Der Schalter MAP_LOCKED wird unter älteren Kerneln ignoriert.

MAP_NONBLOCK (seit Linux 2.5.46)

Dieser Schalter ergibt nur im Zusammenhang mit MAP_POPULATE Sinn. Es wird kein Vorauslesen durchgeführt, es werden Seitentabelleneinträge nur für Seiten erstellt, die bereits im RAM vorhanden sind. Seit Linux 2.6.23 führt dieser Schalter dazu, dass MAP_POPULATE nichts macht. Irgendwann könnte die Kombination von MAP_POPULATE und MAP_NONBLOCK wieder implementiert werden.

MAP_NORESERVE

Reserviert für dieses Mapping keinen Auslagerungsspeicher. Wenn Auslagerungsspeicher reserviert wird, muss garantiert werden, dass Änderungen an dem Mapping möglich sind. Wird kein Auslagerungsspeicher reserviert, könnte beim Schreiben ein SIGSEGV empfangen werden, falls kein physischer Speicher verfügbar ist. Siehe auch die Diskussion der Datei /proc/sys/vm/overcommit_memory in proc(5). In Kerneln vor 2.6 hatte dieser Schalter nur eine Wirkung für private, schreibbare Mappings.

MAP_POPULATE (seit Linux 2.5.46)

Belegt (»prefault«) Seitentabellen für ein Mapping. Für ein Datei-Mapping führt dies zu einem Vorablesen der Datei. Dies hilft dabei, später Blockierungen bei Seitenausnahmebehandlungen zu vermeiden. MAP_POPULATE wird für private Mappings erst seit Linux 2.6.23 unterstützt.

MAP_STACK (seit Linux 2.6.27)

Reserverviert ein Mapping an einer Adresse, die für einen Stack eines Prozesses oder Threads geeignet ist.

Dieser Schalter löst derzeit nichts aus. Durch Einsatz dieses Schalters können Anwendungen aber transparent sicherstellen, dass sie die Unterstützung erlangen, wenn dieser Schalter in der Zukunft implementiert wird. Daher wird er in der Glibc-Threading-Implementierung verwandt, um der Tatsache Rechnung zu tragen, dass auf einigen Architekturen (später) eine besondere Behandlung von Stack-Zuweisungen nötig sein könnte. Ein weiterer Grund, diesen Schalter einzusetzen, ist die Portabilität: MAP_STACK existiert (und hat eine Auswirkung) auf einigen anderen Systemen (z.B. einigen BSDs).

MAP_SYNC (seit Linux 4.15)

Dieser Schalter ist nur mit dem Mapping-Typ MAP_SHARED_VALIDATE verfügbar. Mappings vom Typ MAP_SHARED ignorieren diesen Schalter ohne Rückmeldung. Dieser Schalter wird nur für Dateien, die DAX (direktes Mapping von dauerhaftem Speicher) unterstützen, unterstützt. Für andere Dateien wird das Erstellen eines Mappings mit diesem Schalter zu einem EOPNOTSUPP-Fehler führen.

Gemeinsame Datei-Mappings mit diesem Schalter garantieren, dass der schreibbare eingemappte Speicheranteil im Adressraum des Prozesses auch in der gleichen Datei an dem gleichen Versatz selbst nach einem Systemabsturz oder -neustart sichtbar ist. Im Zusammenhang mit dem Einsatz geeigneter CPU-Anweisungen stellt dieses Benutzern solcher Mappings eine effizientere Art bereit, solche Datenveränderungen dauerhaft zu machen.

MAP_UNINITIALIZED (seit Linux 2.6.33)

Die anonymen Seiten nicht bereinigen. Dieser Schalter ist für die Verbesserung der Leistung auf eingebetteten Systemen gedacht. Dieser Schalter wird nur berücksichtigt, falls der Kernel mit der Option CONFIG_MMAP_ALLOW_UNINITIALIZED konfiguriert worden war. Aufgrund der Sicherheitsauswirkungen wird diese Option normalerweise nur auf eingebetteten Geräten (d.h. Geräten, bei denen komplette Kontrolle über die Speicherinhalte besteht) aktiviert.

Von den obigen Schaltern ist nur MAP_FIXED in POSIX.1-2001 und POSIX.1-2008 spezifiziert. Allerdings unterstützen die meisten Systeme MAP_ANONYMOUS (oder sein Synonym MAP_ANON).

munmap()¶

Die Adresse addr muss ein Vielfaches der Seitengröße sein (für length ist das nicht der Fall). Alle Seiten, die einen Teil des angezeigten Bereichs enthalten, werden ausgemappt, und nachfolgende Referenzen auf diese Seiten führen zu SIGSEGV. Es ist kein Fehler, falls der angezeigte Bereich keine gemappten Seiten enthält.

MAP_FIXED sicher benutzen¶

Nehmen wir beispielsweise an, dass Thread A /proc/<PID>/maps durchsucht, um einen nicht benutzten Adressbereich zu finden, den er mittels MAP_FIXED mappen kann, während Thread B gleichzeitig Teile des gleichen Adressbereichs (oder den gesamten Adressbereich) erlangt. Wenn Thread A anschließend mmap(MAP_FIXED) einsetzt, wird es das Mapping, das Thread B erstellte, durcheinanderbringen. In diesem Szenario muss Thread B nicht das Mapping direkt erstellen: einfach ein Aufruf einer Bibliotheksfunktion, die intern dlopen(3) zum Laden einer anderen dynamische Bibliothek verwendet, reicht aus. Der Aufruf von dlopen(3) wird die Bibliothek in den Adressraum des Prozesses einmappen. Desweiteren kann fast jeder Bibliotheksaufruf auf eine Art implementiert sein, die Speicher-Mappings zu dem Adressraum hinzufügt, entweder mit dieser Technik oder einfach durch Reservierung von Speicher. Beispiele sind brk(2), malloc(3), pthread_create(3) und die PAM-Bibliotheken http://www.linux-pam.org.

Seit Linux 4.17 kann ein Multithread-Programm den Schalter MAP_FIXED_NOREPLACE verwenden, um die oben beschriebene Gefahr zu vermeiden, dass ein Mapping an einer festen Adresse versucht wird, die nicht durch ein bereits existierendes Mapping reserviert wurde.

Zeitstempeländerungen für Datei-basierte Mappings¶

Das Feld st_ctime und st_mtime für eine mit PROT_WRITE und MAP_SHARED gemappte Datei wird nach einem Schreibzugriff auf den gemappten Bereich und vor dem nachfolgenden msync(2) mit den Schalter MS_SYNC oder MS_ASYNC, falls dieser erfolgt, aktualisiert.

Mappings großer Seiten (Huge TLB)¶

Für mmap() muss offset ein Vielfaches der unterliegenden Größe der großen Seiten sein. Das System richtet length automatisch aus, dass es ein Vielfaches der unterliegenden Größe der großen Seiten ist.

Für munmap() müssen sowohl addr als auch length ein Vielfaches der unterliegenden Größe der großen Seiten sein.

Unterschiede C-Bibliothek/Kernel¶

Programmquelltext¶

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define handle_error(msg) \
    do { perror(msg); exit(EXIT_FAILURE); } while (0)
int
main(int argc, char *argv[])
{
    char *addr;
    int fd;
    struct stat sb;
    off_t offset, pa_offset;
    size_t length;
    ssize_t s;
    if (argc < 3 || argc > 4) {
        fprintf(stderr, "%s Dateiversatz [Länge]\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    fd = open(argv[1], O_RDONLY);
    if (fd == -1)
        handle_error("open");
    if (fstat(fd, &sb) == -1)           /* Um die Dateigröße zu erhalten */
        handle_error("fstat");
    offset = atoi(argv[2]);
    pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);
        /* Versatz für mmap() muss an der Seite ausgerichtet sein */
    if (offset >= sb.st_size) {
        fprintf(stderr, "Versatz ist hinter dem Dateiende\n");
        exit(EXIT_FAILURE);
    }
    if (argc == 4) {
        length = atoi(argv[3]);
        if (offset + length > sb.st_size)
            length = sb.st_size - offset;
                /* Bytes hinter dem Dateiende können nicht angezeigt werden */
    } else {    /* Kein Längen-Argument ==> Anzeige bis zum Dateiende */
        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, "Schreiben unvollständig");
        exit(EXIT_FAILURE);
    }
    munmap(addr, length + offset - pa_offset);
    close(fd);
    exit(EXIT_SUCCESS);
}