.\" -*- coding: UTF-8 -*- .\" Copyright (C) 2014 Michael Kerrisk .\" and Copyright (C) 2014 David Herrmann .\" .\" SPDX-License-Identifier: GPL-2.0-or-later .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH memfd_create 2 "2 mai 2024" "Pages du manuel de Linux 6.8" .SH NOM memfd_create \- Créer un fichier anonyme .SH BIBLIOTHÈQUE Bibliothèque C standard (\fIlibc\fP, \fI\-lc\fP) .SH SYNOPSIS .nf \fB#define _GNU_SOURCE\fP /* Consultez feature_test_macros(7) */ \fB#include \fP .P \fBint memfd_create(const char *\fP\fIname\fP\fB, unsigned int \fP\fIflags\fP\fB);\fP .fi .SH DESCRIPTION .\" David Herrmann: .\" memfd uses VM_NORESERVE so each page is accounted on first access. .\" This means, the overcommit-limits (see __vm_enough_memory()) and the .\" memory-cgroup limits (mem_cgroup_try_charge()) are applied. Note that .\" those are accounted on "current" and "current->mm", that is, the .\" process doing the first page access. \fBmemfd_create\fP() crée un fichier anonyme et renvoie un descripteur de fichier qui s'y rapporte. Le fichier se comporte comme un fichier normal, il peut donc être modifié, tronqué, projeté en mémoire, et ainsi de suite. Mais contrairement à un fichier normal, il réside dans la RAM et son stockage est volatile. Une fois que toutes les références au fichier ont disparu, il est automatiquement libéré. La mémoire anonyme est utilisée pour toutes les pages de sauvegarde du fichier. Les fichiers créés par \fBmemfd_create\fP() ont donc la même sémantique que les autres allocations de mémoire anonyme telles que celles qui utilisent \fBmmap\fP(2) avec l'attribut \fBMAP_ANONYMOUS\fP. .P La taille initiale du fichier est positionnée à \fB0\fP. Après l'appel, elle devrait être définie en utilisant \fBftruncate\fP(2) (ou le fichier peut être rempli par des appels à \fBwrite\fP(2) ou équivalent). .P Le nom fourni dans \fIname\fP est utilisé comme nom de fichier et sera affiché en tant que cible du lien symbolique correspondant dans le répertoire \fI/proc/self/fd/\fP. Le nom affiché a toujours un préfixe \fImemfd:\fP et il ne sert que pour le débogage. Les noms ne changent pas le comportement du descripteur de fichier et en tant que tels plusieurs fichiers peuvent avoir le même nom sans effets de bord. .P Les valeurs suivantes peuvent subir une opération OU logique bit à bit dans \fIflags\fP pour modifier le comportement de \fBmemfd_create\fP() : .TP \fBMFD_CLOEXEC\fP Placer l'attribut « close\-on\-exec » (\fBFD_CLOEXEC\fP) sur le nouveau descripteur de fichier. Consultez la description de l'attribut \fBO_CLOEXEC\fP dans \fBopen\fP(2) pour savoir pourquoi cela peut être utile. .TP \fBMFD_ALLOW_SEALING\fP .\" FIXME Why is the MFD_ALLOW_SEALING behavior not simply the default? .\" Is it worth adding some text explaining this? Permettre des opérations de verrouillage sur ce fichier. Voir le point sur les opérations \fBF_ADD_SEALS\fP et \fBF_GET_SEALS\fP dans \fBfcntl\fP(2), ainsi que les NOTES ci\-dessous. Le positionnement initial des verrous est vide. Si cet attribut n'est pas défini, le positionnement initial des verrous sera \fBF_SEAL_SEAL\fP, ce qui veut dire qu'aucun autre verrou ne peut être positionné sur le fichier. .TP \fBMFD_HUGETLB\fP (depuis Linux 4.14) .\" commit 749df87bd7bee5a79cef073f5d032ddb2b211de8 .\" commit 47b9012ecdc747f6936395265e677d41e11a31ff Le fichier anonyme sera créé sur le système de fichiers hugetlbfs en utilisant d'immenses pages. Voir le fichier \fIDocumentation/admin\-guide/mm/hugetlbpage.rst\fP des sources du noyau Linux pour plus d'informations sur hugetlbfs. Le fait d'indiquer à la fois \fBMFD_HUGETLB\fP et \fBMFD_ALLOW_SEALING\fP dans \fIflags\fP est pris en charge depuis Linux 4.16. .TP \fBMFD_HUGE_2MB\fP .TQ \fBMFD_HUGE_1GB\fP .TQ \&.\|.\|. Utilisé avec \fBMFD_HUGETLB\fP pour sélectionner d'autres tailles de page hugetlb (respectivement 2 Mo, 1 Go, ...) sur les systèmes qui gèrent plusieurs tailles de page hugetlb. Les définitions des tailles de page immenses connues figurent dans le fichier d'entête \fI\fP. .IP Pour des détails sur l'encodage des tailles des pages immenses ne figurant pas dans le fichier d'entête, voir le point sur les constantes du même nom dans \fBmmap\fP(2). .P Les bits inusitées dans \fIflags\fP doivent valoir \fB0\fP. .P En code de retour, \fBmemfd_create\fP() renvoie un nouveau descripteur de fichier qui peut être utilisé pour se référer au fichier. Ce descripteur de fichier est ouvert en lecture et en écriture (\fBO_RDWR\fP) et \fBO_LARGEFILE\fP est positionné pour le descripteur de fichier. .P Par rapport à \fBfork\fP(2) et \fBexecve\fP(2), la sémantique habituelle s'applique au descripteur de fichier créé par \fBmemfd_create\fP(). Une copie du descripteur de fichier est récupérée par l'enfant produit par \fBfork\fP(2) et elle se rapporte au même fichier. Le descripteur de fichier est préservé pendant un \fBexecve\fP(2), sauf si l'attribut close\-on\-exec a été positionné. .SH "VALEUR RENVOYÉE" En cas de succès, \fBmemfd_create\fP() renvoie un nouveau descripteur de fichier. En cas d'erreur, \fB\-1\fP est renvoyé et \fIerrno\fP est positionné pour indiquer l'erreur. .SH ERREURS .TP \fBEFAULT\fP L'adresse dans \fIname\fP pointe vers une mémoire non valable. .TP \fBEINVAL\fP \fIflags\fP comprend des bits inconnus. .TP \fBEINVAL\fP .\" NAME_MAX - strlen("memfd:") \fIname\fP était trop long (la limite de 249 octets, n'incluant pas l'octet NULL final). .TP \fBEINVAL\fP \fBMFD_HUGETLB\fP et \fBMFD_ALLOW_SEALING\fP ont tous deux été indiqués dans \fIflags\fP. .TP \fBEMFILE\fP La limite du nombre de descripteurs de fichiers par processus a été atteinte. .TP \fBENFILE\fP La limite du nombre total de fichiers ouverts pour le système entier a été atteinte. .TP \fBENOMEM\fP Mémoire insuffisante pour créer un nouveau fichier anonyme. .TP \fBEPERM\fP L'attribut \fBMFD_HUGETLB\fP a été spécifié, mais l'appelant n'est pas un utilisateur privilégié (il n'a pas la capacité \fBCAP_IPC_LOCK\fP) et il n'est pas membre du groupe \fIsysctl_hugetlb_shm_group\fP ; consultez la description de \fI/proc/sys/vm/sysctl_hugetlb_shm_group\fP dans \fBproc\fP(5). .SH STANDARDS Linux. .SH HISTORIQUE Linux 3.17, glibc 2.27. .SH NOTES .\" See also http://lwn.net/Articles/593918/ .\" and http://lwn.net/Articles/594919/ and http://lwn.net/Articles/591108/ L'appel système \fBmemfd_create\fP() offre une alternative simple au montage manuel d'un système de fichiers \fBtmpfs\fP(5) et à la création et l'ouverture d'un fichier dans ce système de fichiers. Le premier objectif de \fBmemfd_create\fP() est de créer des fichiers et leur descripteur associé, utilisés avec les API de verrou de fichiers fournis par \fBfcntl\fP(2). .P L'appel système \fBmemfd_create\fP() s'utilise également sans verrou de fichier (c'est pourquoi le verrouillage de fichier a été désactivé sauf demande explicite avec l'attribut \fBMFD_ALLOW_SEALING\fP). En particulier, il peut être utilisé comme alternative pour créer des fichiers dans \fItmp\fP ou pour utiliser \fBO_TMPFILE\fP de \fBopen\fP(2), si vous ne voulez pas rattacher le fichier résultant au système de fichiers. .SS "Verrou de fichiers" En l'absence de verrou de fichier, les processus qui communiquent à travers la mémoire partagée doivent soit se faire confiance entre eux, soit prendre des mesures pour gérer la possibilité qu'un pair non fiable manipule la région de mémoire partagée de manière problématique. Par exemple, un pair non fiable pourrait modifier le contenu de la mémoire partagée n'importe quand ou rétrécir la zone de mémoire partagée. La première éventualité rend le processus local vulnérable aux conflits (race conditions) time\-of\-check\-to\-time\-of\-use (généralement gérés en copiant les données de la zone de mémoire partagée avant de les vérifier et de les utiliser). La deuxième éventualité rend le processus local vulnérable aux signaux \fBSIGBUS\fP quand on essaie d'accéder à un emplacement inexistant dans la zone de mémoire partagée (gérer cette éventualité implique d'utiliser un gestionnaire pour le signal \fBSIGBUS\fP). .P La gestion de pairs non fiables impose une plus grande complexité du code qui utilise la mémoire partagée. Les verrous mémoire éliminent cette complexité, en permettant à un processus d'agir en toute sécurité en sachant que son pair ne peut pas modifier la mémoire partagée de manière non souhaitée. .P Voici un exemple d'utilisation du mécanisme de verrouillage : .IP (1) 5 Le premier processus crée un fichier \fBtmpfs\fP(5) en utilisant \fBmemfd_create\fP(). L'appel donne un descripteur de fichier utilisé dans les étapes ultérieures. .IP (2) Le premier processus dimensionne le fichier créé à l'étape précédente en utilisant \fBftruncate\fP(2), il le projette en utilisant \fBmmap\fP(2) et il remplit la mémoire partagée avec les données désirées. .IP (3) Le premier processus utilise l'opération \fBF_ADD_SEALS\fP de \fBfcntl\fP(2) pour poser un ou plusieurs verrous sur le fichier afin de restreindre des modifications ultérieures (si on pose un verrou \fBF_SEAL_WRITE\fP, il sera nécessaire de désassocier la projection modifiable partagée créée à l'étape précédente. Sinon, on peut obtenir un comportement identique à \fBF_SEAL_WRITE\fP en utilisant \fBF_SEAL_FUTURE_WRITE\fP, qui empêchera des écritures ultérieures à l'aide de \fBmmap\fP(2) et de \fBwrite\fP(2), tout en conservant les projections modifiables partagées existantes). .IP (4) Un deuxième processus obtient un descripteur de fichier pour le fichier \fBtmpfs\fP(5) et le projette. Parmi les origines possibles de cela, vous trouverez : .RS .IP \- 3 Le processus qui a appelé \fBmemfd_create\fP() a pu transférer le descripteur de fichier consécutif au deuxième processus à l'aide d'un socket de domaine UNIX (voir \fBunix\fP(7) et \fBcmsg\fP(3)). Le deuxième processus projette alors le fichier en utilisant \fBmmap\fP(2). .IP \- Le deuxième processus est créé à l'aide de \fBfork\fP(2) et, ainsi, il récupère automatiquement le descripteur de fichier et sa projection (remarquez que dans ce cas et dans le prochain, il existe une relation de confiance naturelle entre les deux processus puisqu'ils tournent sous le même identifiant utilisateur. Donc, un verrou de fichier n'est, en principe, pas nécessaire). .IP \- Le deuxième processus ouvre le fichier \fI/proc/\fPpid\fI/fd/\fPfd où \fI\fP est l'identifiant de processus du premier processus (celui qui a appelé \fBmemfd_create\fP()) et \fI\fP est le numéro du descripteur de fichier renvoyé par l'appel à \fBmemfd_create\fP dans ce processus. Le deuxième processus projette ensuite le fichier en utilisant \fBmmap\fP(2). .RE .IP (5) Le deuxième processus utilise l'opération \fBF_GET_SEALS\fP de \fBfcntl\fP(2) pour récupérer le masque de bits de verrous appliqué au fichier. Ce masque peut être examiné pour déterminer le type de restrictions posées aux modifications du fichier. Si vous le souhaitez, le deuxième processus peut appliquer des verrous supplémentaires pour imposer d'autres restrictions (tant que le verrou \fBF_SEAL_SEAL\fP n'a pas encore été appliqué). .SH EXEMPLES Voici deux exemples de programme montrant l'utilisation de \fBmemfd_create\fP() et de l'API de verrou de fichier. .P Le premier programme, \fIt_memfd_create.c\fP, crée un fichier \fBtmpfs\fP(5) en utilisant \fBmemfd_create\fP(), donne une taille au fichier, le projette en mémoire et, en option, pose des verrous sur le fichier. Le programme accepte jusqu'à trois paramètres en ligne de commande, dont les deux premiers sont requis. Le premier paramètre est le nom à donner au fichier, le deuxième est la taille à lui donner, le troisième, optionnel, est une chaîne de caractères qui indique les verrous à poser sur le fichier. .P Le deuxième programme, \fIt_get_seals.c\fP, peut être utilisé pour ouvrir un fichier existant créé à l'aide de \fBmemfd_create\fP() et examiner les verrous qui y sont posés. .P La session d'interpréteur suivant montre l'utilisation de ces programmes. Nous créons d'abord un fichier \fBtmpfs\fP(5) et nous posons des verrous dessus : .P .in +4n .EX $ \fB./t_memfd_create my_memfd_file 4096 sw &\fP [1] 11775 PID: 11775; fd: 3; /proc/11775/fd/3 .EE .in .P À ce moment, le programme \fIt_memfd_create\fP continue à s'exécuter en tâche de fond. À partir d'un autre programme, nous pouvons obtenir un descripteur de fichier pour le fichier créé par \fBmemfd_create\fP() en ouvrant \fI/proc/\fPpid\fI/fd\fP qui correspond au descripteur de fichier ouvert par \fBmemfd_create\fP(). En utilisant ce chemin, nous examinons le contenu du lien symbolique \fI/proc/\fPpid\fI/fd\fP et nous utilisons notre programme \fIt_get_seals\fP pour voir les verrous posés sur le fichier : .P .in +4n .EX $ \fBreadlink /proc/11775/fd/3\fP /memfd:my_memfd_file (deleted) $ \fB./t_get_seals /proc/11775/fd/3\fP Verrous existants : WRITE SHRINK .EE .in .SS "Source du programme : t_memfd_create.c" .\" SRC BEGIN (t_memfd_create.c) \& .EX #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include \& int main(int argc, char *argv[]) { int fd; char *name, *seals_arg; ssize_t len; unsigned int seals; \& if (argc < 3) { fprintf(stderr, "%s name size [seals]\en", argv[0]); fprintf(stderr, "\et\[aq]seals\[aq] peut contenir un des " "caractères suivants :\en"); fprintf(stderr, "\et\etg \- F_SEAL_GROW\en"); fprintf(stderr, "\et\ets \- F_SEAL_SHRINK\en"); fprintf(stderr, "\et\etw \- F_SEAL_WRITE\en"); fprintf(stderr, "\et\etW \- F_SEAL_FUTURE_WRITE\en"); fprintf(stderr, "\et\etS \- F_SEAL_SEAL\en"); exit(EXIT_FAILURE); } \& name = argv[1]; len = atoi(argv[2]); seals_arg = argv[3]; \& /* Créer un fichier anonyme dans tmpfs ; permet de poser des verrous sur le fichier. */ \& fd = memfd_create(name, MFD_ALLOW_SEALING); if (fd == \-1) err(EXIT_FAILURE, "memfd_create"); \& /* Taille du fichier indiquée sur la ligne de commande. */ \& if (ftruncate(fd, len) == \-1) err(EXIT_FAILURE, "truncate"); \& printf("PID: %jd; fd: %d; /proc/%jd/fd/%d\en", (intmax_t) getpid(), fd, (intmax_t) getpid(), fd); \& /* Code pour projeter le fichier et remplir la projection avec des données omises. */ \& /* Si un paramètre \[aq]seals\[aq] de la ligne de commande est fourni, poser des verrous sur le fichier. */ \& if (seals_arg != NULL) { seals = 0; \& if (strchr(seals_arg, \[aq]g\[aq]) != NULL) seals |= F_SEAL_GROW; if (strchr(seals_arg, \[aq]s\[aq]) != NULL) seals |= F_SEAL_SHRINK; if (strchr(seals_arg, \[aq]w\[aq]) != NULL) seals |= F_SEAL_WRITE; if (strchr(seals_arg, \[aq]W\[aq]) != NULL) seals |= F_SEAL_FUTURE_WRITE; if (strchr(seals_arg, \[aq]S\[aq]) != NULL) seals |= F_SEAL_SEAL; \& if (fcntl(fd, F_ADD_SEALS, seals) == \-1) err(EXIT_FAILURE, "fcntl"); } \& /* Continuer l’exécution pour que le fichier créé par memfd_create() continue à exister. */ \& pause(); \& exit(EXIT_SUCCESS); } .EE .\" SRC END .SS "Source du programme : t_get_seals.c" .\" SRC BEGIN (t_get_seals.c) \& .EX #define _GNU_SOURCE #include #include #include #include \& int main(int argc, char *argv[]) { int fd; unsigned int seals; \& if (argc != 2) { fprintf(stderr, "%s /proc/PID/fd/FD\en", argv[0]); exit(EXIT_FAILURE); } \& fd = open(argv[1], O_RDWR); if (fd == \-1) err(EXIT_FAILURE, "open"); \& seals = fcntl(fd, F_GET_SEALS); if (seals == \-1) err(EXIT_FAILURE, "fcntl"); \& printf("Verrous existants :"); if (seals & F_SEAL_SEAL) printf(" SEAL"); if (seals & F_SEAL_GROW) printf(" GROW"); if (seals & F_SEAL_WRITE) printf(" WRITE"); if (seals & F_SEAL_FUTURE_WRITE) printf(" FUTURE_WRITE"); if (seals & F_SEAL_SHRINK) printf(" SHRINK"); printf("\en"); \& /* Code pour associer le fichier et l'accès au contenu de la projection résultante omise. */ \& exit(EXIT_SUCCESS); } .EE .\" SRC END .SH "VOIR AUSSI" \fBfcntl\fP(2), \fBftruncate\fP(2), \fBmemfd_secret\fP(2), \fBmmap\fP(2), \fBshmget\fP(2), \fBshm_open\fP(3) .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Christophe Blaess , Stéphan Rafin , Thierry Vignaud , François Micaux, Alain Portal , Jean-Philippe Guérard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas François , Florentin Duneau , Simon Paillard , Denis Barbier , David Prévot et Jean-Philippe MENGUAL . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .