Le paramètre des attributs¶

Le paramètre flags détermine si les modifications de la projection sont visibles depuis les autres processus projetant la même région et si les modifications sont appliquées au fichier sous-jacent. Ce comportement est déterminé en incluant exactement une des valeurs suivantes dans flags :

MAP_SHARED

Partager la projection. Les modifications de la projection sont visibles dans les autres processus qui projettent la même région et (en cas de projection file-backed) elles sont appliquées au fichier sous-jacent (pour contrôler précisément le moment des mises à jour du fichier sous-jacent, il faut utiliser msync(2)).

MAP_SHARED_VALIDATE (depuis Linux 4.15)

Cet attribut apporte le même comportement que MAP_SHARED sauf que les projections MAP_SHARED ignorent les attributs inconnus dans flags. Au contraire, lors de la création d'une projection en utilisant MAP_SHARED_VALIDATE, le noyau vérifie que tous les attributs passés sont connus et il fait échouer la projection avec l'erreur EOPNOTSUPP pour les attributs inconnus. Ce type de projection est aussi nécessaire pour pouvoir utiliser certains attributs de projection (comme MAP_SYNC).

MAP_PRIVATE

Créer une projection privée, utilisant la méthode de copie à l'écriture. Les modifications de la projection ne sont pas visibles depuis les autres processus projetant le même fichier, et ne modifient pas le fichier lui-même. Il n'est pas précisé si les changements effectués dans le fichier après l'appel mmap() seront visibles dans la région projetée.

MAP_SHARED et MAP_PRIVATE sont décrits dans POSIX.1-2001 et POSIX.1-2008. MAP_SHARED_VALIDATE est une extension Linux.

De plus, zéro ou plus des valeurs suivantes peuvent être incluses dans flags (avec un OU binaire) :

MAP_32BIT (depuis Linux 2.4.20, 2.6)

Placer la projection dans les deux premiers gigaoctets de l'espace d'adressage du processus. Cet attribut n'est pris en charge que sous x86-64, pour les programmes 64 bits. Il a été ajouté pour permettre à la pile d'un fil d'exécution d'être allouée dans les deux premiers gigaoctets de mémoire, afin d'améliorer les performances des changements de contexte sur les premiers processeurs 64 bits. Les processeurs x86-64 modernes n'ont plus ces problèmes de performance, donc l'utilisation de cet attribut n'est pas nécessaire sur ces systèmes. L'attribut MAP_32BIT est ignoré quand MAP_FIXED est positionné.

MAP_ANON

Synonyme de MAP_ANONYMOUS ; fourni pour une compatibilité avec d'autres implémentations.

MAP_ANONYMOUS

La projection n'est prise en charge par aucun fichier ; son contenu est initialisé à 0. L'argument fd est ignoré ; cependant, certaines implémentations demandent que fd soit -1 si MAP_ANONYMOUS (ou MAP_ANON) est utilisé, et les applications portables doivent donc s'en assurer. L'argument offset devrait être 0. La prise en charge de MAP_ANONYMOUS avec MAP_SHARED a été ajoutée dans Linux 2.4.

MAP_DENYWRITE

Cet attribut est ignoré (autrefois — Linux 2.0 et antérieur — il signalait une tentative d'écriture dans le fichier sous-jacent et qui échouait avec l'erreur ETXTBUSY. Mais cela permettait des attaques par déni de service).

MAP_EXECUTABLE

Cet attribut est ignoré.

MAP_FILE

Attribut pour compatibilité. Ignoré.

MAP_FIXED

Ne pas considérer addr comme une indication : n'utiliser que l'adresse indiquée. addr doit être correctement alignée : pour la plupart des architectures, un multiple de la taille de page suffit, toutefois certaines architectures imposent des limitations supplémentaires. Si la zone mémoire indiquée par addr et length recouvre des pages d'une projection existante, la partie recouverte de la projection existante sera ignorée. Si l'adresse indiquée ne peut être utilisée, mmap() échouera.

Les logiciels qui aspirent à la portabilité devraient utiliser l'attribut MAP_FIXED prudemment, en gardant à l'esprit que l'aspect exact des projections de mémoire du processus est autorisé à changer significativement entre les versions de Linux, de la glibc et du système d'exploitation. Lisez attentivement le point sur cet attribut dans les NOTES !

MAP_FIXED_NOREPLACE (depuis Linux 4.17)

Cet attribut offre un comportement identique à MAP_FIXED par rapport à l'application de addr, mais il s'en distingue en ce que MAP_FIXED_NOREPLACE n’écrase jamais une plage projetée existante. Si la plage demandée entre en conflit avec une projection existante, cet appel échoue avec l'erreur EEXIST. Cet attribut peut donc être utilisé comme une façon d'essayer de projeter une plage d'adresses de manière atomique (vis-à-vis d'autres fils d'exécutions) : un thread réussira, tous les autres signaleront un échec.

Remarquez que les anciens noyaux qui ne reconnaissent pas l'attribut MAP_FIXED_NOREPLACE se rabattront généralement (en détectant une collision avec une projection existante) sur un type de comportement « sans MAP_FIXED » : ils renverront une adresse différente de celle demandée. Les logiciels rétro-compatibles devront donc vérifier l'adresse renvoyée vis-à-vis de l'adresse demandée.

MAP_GROWSDOWN

Cet attribut est utilisé pour les piles. Il indique au noyau le système de mémoire virtuelle vers lequel la projection devrait descendre dans la mémoire. L'adresse renvoyée est une page inférieure à la zone de mémoire créée dans l'espace d'adressage virtuel du processus. La modification d'une adresse dans la page de « garde » sous la projection fera agrandir la projection d’une page. Cette croissance peut se répéter jusqu'à ce que la taille de la projection dans la page atteigne l’extrémité haute de la projection plus basse suivante, point où la modification de la page de « garde » donnera un signal SIGSEGV.

MAP_HUGETLB (depuis Linux 2.6.32)

Allouer la projection à l'aide de « pages immenses ». Consultez le fichier Documentation/vm/hugetlbpage.txt des sources du noyau Linux pour plus d'informations ainsi que les NOTES ci-dessous.

MAP_HUGE_2MB, MAP_HUGE_1GB (depuis Linux 3.8)

Utilisé avec MAP_HUGETLB pour sélectionner d'autres tailles de pages immenses (hugetlb) (respectivement 2 Mo et 1 Go) sur les systèmes qui gèrent plusieurs tailles de page hugetlb.

Plus généralement, la taille de la page immense souhaitée peut être configurée en encodant le logarithme de base 2 de la taille de la page désirée dans les six bits situés sur MAP_HUGE_SHIFT (une valeur de zéro dans ce champ de bit fournit la taille de page immense par défaut ; vous pouvez connaître celle-ci à l'aide du champ Hugepagesize qui apparaît dans /proc/meminfo). Ainsi, les deux constantes ci-dessus sont définies comme suit :

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

Vous pouvez connaître l'intervalle de tailles des pages immenses gérées par le système en listant les sous-répertoires de /sys/kernel/mm/hugepages.

MAP_LOCKED (depuis Linux 2.5.37)

Marquer la région projetée pour qu'elle soit verrouillée de la même manière que mlock(2). Cette implémentation essaiera de remplir (prefault) toute la plage mais l'appel mmap() n’échouera pas avec ENOMEM si cela échoue. Des erreurs énormes pourraient donc se produire ultérieurement. La sémantique n'est donc pas aussi robuste que mlock(2). Vous devriez utiliser mmap() et mlock(2) si d'énormes erreurs ne sont pas acceptables après l'initialisation de la projection. L'attribut MAP_LOCKED est ignoré sur les anciens noyaux.

MAP_NONBLOCK (depuis Linux 2.5.46)

Cet attribut n'a de sens qu'en conjonction avec MAP_POPULATE. Ne pas effectuer de lecture anticipée : créer seulement les entrées de tables de page pour les pages déjà présentes en RAM. Depuis Linux 2.6.23, cet attribut fait que MAP_POPULATE n'a aucun effet. Un jour la combinaison de MAP_POPULATE et MAP_NONBLOCK pourra être implémentée de nouveau.

MAP_NORESERVE

Ne pas réserver d'espace de swap pour les pages de cette projection. Une telle réservation garantit que l'on puisse modifier les zones soumises à une copie-en-écriture. Sans réservation, on peut recevoir un signal SIGSEGV durant une écriture, s'il n'y a plus de place disponible. Consultez également la description du fichier /proc/sys/vm/overcommit_memory dans la page proc(5). Avant Linux 2.6, cet attribut n'avait d'effet que pour les projections privées modifiables.

MAP_POPULATE (depuis Linux 2.5.46)

Remplir (prefault) les tables de pages pour une projection. Pour une projection de fichier, cela provoque une lecture anticipée du fichier. Les accès ultérieurs à la projection ne seront pas bloqués par des erreurs de pages. L'appel mmap n'échoue pas si la projection ne peut pas être remplie (par exemple à cause de limitation sur le nombre de pages immenses mappées lors de l'utilisation de MAP_HUGETLB). La prise en charge de MAP_POPULATE avec les projections privées a été ajoutée dans Linux 2.6.23.

MAP_STACK (depuis Linux 2.6.27)

Allouer la projection à une adresse qui convient à la pile d'un processus ou d'un thread.

Cet attribut n'est pas opérationnel pour l'instant sur Linux. Mais son utilisation permet aux applications de s'assurer qu'elles le gèreront de manière transparente s'il est implémenté dans le futur. Ainsi, il est utilisé dans l'implémentation de threading de la glibc pour accepter le fait que certaines architectures pourront (plus tard) nécessiter un traitement spécial pour allouer des piles. Une autre raison d'utiliser cet attribut est la portabilité : MAP_STACK existe et a un effet sur d'autres systèmes (comme certains BSD).

MAP_SYNC (depuis Linux 4.15)

Cet attribut n'est possible qu'avec le type de projection MAP_SHARED_VALIDATE ; les projections de type MAP_SHARED ignoreront silencieusement cet attribut. Il n'est pris en charge que pour des fichiers gérant le DAX (projection directe de mémoire persistante). Pour les autres fichiers, créer une projection avec cet attribut provoquera une erreur EOPNOTSUPP.

Les projections de fichier partagé ayant cet attribut fournissent une garantie que tant que la mémoire est projetée avec accès en écriture dans l'espace d'adressage du processus, elle sera visible dans le même fichier et au même endroit même après un plantage ou un redémarrage du système. Couplé à l'utilisation des instructions adéquates du processeur, cela offre aux utilisateurs de telles projections une manière plus efficace de rendre des modifications de données persistantes.

MAP_UNINITIALIZED (depuis Linux 2.6.33)

Ne pas effacer pas les pages anonymes. Cet attribut n'a pour l'instant un effet que si le noyau a été configuré avec l'option CONFIG_MMAP_ALLOW_UNINITIALIZED. À cause des implications sur la sécurité, cette option n'est normalement active que sur des périphériques embarqués (c'est-à-dire avec des périphériques avec lesquels il est possible d'avoir un contrôle total de la mémoire utilisateur).

Parmi les attributs ci-dessus, seul MAP_FIXED est spécifié dans POSIX.1-2001 et POSIX.1-2008. Cependant, la plupart des systèmes gèrent aussi MAP_ANONYMOUS (ou son synonyme MAP_ANON).

munmap()¶

L'appel système munmap() détruit la projection dans la zone de mémoire spécifiée et s'arrange pour que toute référence ultérieure à cette zone mémoire déclenche une erreur d'adressage. La projection est aussi automatiquement détruite lorsque le processus se termine. À l'inverse, la fermeture du descripteur de fichier ne supprime pas la projection.

L'adresse addr doit être un multiple de la taille de la page (mais ce n'est pas obligatoire pour length). Toutes les pages contenant une partie de l'intervalle indiqué sont libérées, et tout accès ultérieur déclenchera SIGSEGV. Aucune erreur n'est détectée si l'intervalle indiqué ne contient pas de page projetée.

Utilisation sûre de MAP_FIXED¶

La seule utilisation sûre de MAP_FIXED est quand la plage d'adresses indiquée par addr et length a été préalablement réservée en utilisant une autre projection ; sans quoi l'utilisation de MAP_FIXED est hasardeuse car elle supprime brutalement des projections préexistantes, ce qui facilite la corruption par un processus multithread de son propre espace d'adressage.

Par exemple, supposons qu'un thread A cherche dans /proc/<pid>/maps une plage d'adresses inutilisée où il peut se projeter en utilisant MAP_FIXED, tandis qu'un thread B acquiert en même temps tout ou partie de cette même plage d'adresses. Quand le thread A utilisera ensuite mmap(MAP_FIXED), il va de fait écraser la projection créée par le thread B. Dans ce scénario, le thread B ne doit pas créer de projection directement ; un appel de bibliothèque qui, en interne, utilise dlopen(3) pour charger d'autres bibliothèques partagées, est suffisant. L'appel dlopen(3) projettera la bibliothèque dans l'espace d'adressage du processus. De plus, presque tous les appels de bibliothèques peuvent être implémentés d'une manière qui ajoute des projections de mémoire aux espaces d'adressage, à l'aide de cette technique ou en allouant simplement de la mémoire. Parmi les exemples, figurent brk(2), malloc(3), pthread_create(3) et les bibliothèques PAM http://www.linux-pam.org.

Depuis Linux 4.17, un programme multithreadé peut utiliser l'attribut MAP_FIXED_NOREPLACE pour éviter le risque décrit ci-dessus quand on essaie de créer une projection à une adresse fixe non réservée par une projection préexistante.

Modifications d'horodatage pour les projections prises en charge par un fichier¶

Pour les projections prises en charge par un fichier, le champ st_atime du fichier peut être mis à jour à tout moment entre l'appel mmap() et le munmap() correspondant. Le premier accès dans la page projetée mettra le champ à jour si cela n'a pas été déjà fait.

Les champs st_ctime et st_mtime pour un fichier projeté avec PROT_WRITE et MAP_SHARED seront mis à jour après une écriture dans la région projetée, et avant l'éventuel msync(2) suivant avec l'attribut MS_SYNC ou MS_ASYNC.

Projections de pages immenses (Huge TLB)¶

Pour les projections qui utilisent des pages immenses, les exigences des attributs de mmap() et de munmap() diffèrent quelque peu de celles pour des projections qui utilisent la taille native des pages du système.

Pour mmap(), offset doit être un multiple de la taille de la page immense sous-jacente. Le système aligne automatiquement length pour qu'il soit un multiple de la taille de la page immense sous-jacente.

Pour munmap(), addr et length doivent être tous deux un multiple de la taille de la page immense sous-jacente.

Différences entre bibliothèque C et noyau¶

Cette page décrit l'interface fournie par la fonction mmap() de la glibc. Initialement, cette fonction appelait un appel système du même nom. Depuis Linux 2.4, cet appel système a été remplacé par mmap2(2). De nos jours, la fonction mmap() de la glibc appelle mmap2(2) avec la bonne valeur pour offset.

Source du programme¶

#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 fichier offset [longueur]\n", argv[0]);


        exit(EXIT_FAILURE);


    }


    fd = open(argv[1], O_RDONLY);


    if (fd == -1)


        handle_error("open");


    if (fstat(fd, &sb) == -1)           /* Pour obtenir la taille du fichier */


        handle_error("fstat");


    offset = atoi(argv[2]);


    pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);


        /* la position de mmap() doit être alignée sur la page */


    if (offset >= sb.st_size) {


        fprintf(stderr, "L'offset dépasse la fin du fichier\n");


        exit(EXIT_FAILURE);


    }


    if (argc == 4) {


        length = atoi(argv[3]);


        if (offset + length > sb.st_size)


            length = sb.st_size - offset;


                /* Impossible d'afficher les octets en dehors du fichier */


    } else {    /* Pas de paramètre longueur


                   ==> affichage jusqu'à la fin du fichier */


        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, "écriture partielle");


        exit(EXIT_FAILURE);


    }


    munmap(addr, length + offset - pa_offset);


    close(fd);


    exit(EXIT_SUCCESS);
}