perkamon - en to fr translation catalogue (74 entries)

note: type: TH
en: 2019-10-10
fr: 10 octobre 2019

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: mmap, munmap - map or unmap files or devices into memory
fr: mmap, munmap - Établir/supprimer une projection en mémoire (map/unmap) des fichiers ou des périphériques

note: type: Plain text
en: See NOTES for information on feature test macro requirements.
fr: Consultez la section NOTES pour plus d'informations sur les exigences de la macro de test de fonctionnalité.

note: type: Plain text
en: The contents of a file mapping (as opposed to an anonymous mapping; see B<MAP_ANONYMOUS> below), are initialized using I<length> bytes starting at offset I<offset> in the file (or other object) referred to by the file descriptor I<fd>.  I<offset> must be a multiple of the page size as returned by I<sysconf(_SC_PAGE_SIZE)>.
fr: Le contenu d'une projection de fichier (par opposition à une projection anonyme\ ; voir ci-dessous B<MAP_ANONYMOUS>) est initialisé avec I<length> octets à partir de la position I<offset> dans le fichier (ou autre objet) correspondant au descripteur de fichier I<fd>. I<offset> doit être un multiple de la taille de page, renvoyée par I<sysconf(_SC_PAGE_SIZE)>.

note: type: Plain text
en: The I<prot> argument describes the desired memory protection of the mapping (and must not conflict with the open mode of the file).  It is either B<PROT_NONE> or the bitwise OR of one or more of the following flags:
fr: L'argument I<prot> indique la protection que l'on désire pour cette zone de mémoire, et ne doit pas entrer en conflit avec le mode d'ouverture du fichier. Il s'agit soit de B<PROT_NONE> (le contenu de la mémoire est inaccessible) soit d'un OU binaire entre les constantes suivantes\ :

note: type: Plain text
en: Pages may be executed.
fr: On peut exécuter du code dans la zone mémoire.

note: type: Plain text
en: Pages may be read.
fr: On peut lire le contenu de la zone mémoire.

note: type: Plain text
en: Pages may be written.
fr: On peut écrire dans la zone mémoire.

note: type: Plain text
en: Pages may not be accessed.
fr: Les pages ne peuvent pas être accédées.

note: type: Plain text
en: The I<flags> argument determines whether updates to the mapping are visible to other processes mapping the same region, and whether updates are carried through to the underlying file.  This behavior is determined by including exactly one of the following values in I<flags>:
fr: Le paramètre I<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 I<flags>\ :

note: type: Plain text
en: Create a private copy-on-write mapping.  Updates to the mapping are not visible to other processes mapping the same file, and are not carried through to the underlying file.  It is unspecified whether changes made to the file after the B<mmap>()  call are visible in the mapped region.
fr: 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 B<mmap>() seront visibles.

note: type: Plain text
en: In addition, zero or more of the following values can be ORed in I<flags>:
fr: De plus, zéro ou plus des valeurs suivantes peuvent être incluses dans I<flags> (avec un OU binaire)\ :

note: type: TP
en: B<MAP_32BIT> (since Linux 2.4.20, 2.6)
fr: B<MAP_32BIT> (depuis Linux 2.4.20, 2.6)

note: type: Plain text
en: Synonym for B<MAP_ANONYMOUS>.  Deprecated.
fr: Synonyme de B<MAP_ANONYMOUS>. Déconseillé.

note: Introduced in 1.1.38, removed in 1.3.24. Flag tested in proc_follow_link. (Long ago, it signaled that the underlying file is an executable. However, that information was not really used anywhere.) Linus talked about DOS related to MAP_EXECUTABLE, but he was thinking of MAP_DENYWRITE? type: Plain tex
en: This flag is ignored.
fr: Cet attribut est ignoré.

note: On some systems, this was required as the opposite of MAP_ANONYMOUS -- mtk, 1 May 2007 type: Plain text
en: Compatibility flag.  Ignored.
fr: Attribut pour compatibilité. Ignoré.

note: type: TP
en: B<MAP_HUGETLB> (since Linux 2.6.32)
fr: B<MAP_HUGETLB> (depuis Linux 2.6.32)

note: type: TP
en: B<MAP_LOCKED> (since Linux 2.5.37)
fr: B<MAP_LOCKED> (depuis Linux 2.5.37)

note: type: TP
en: B<MAP_NONBLOCK> (since Linux 2.5.46)
fr: B<MAP_NONBLOCK> (depuis Linux 2.5.46)

note: type: Plain text
en: Do not reserve swap space for this mapping.  When swap space is reserved, one has the guarantee that it is possible to modify the mapping.  When swap space is not reserved one might get B<SIGSEGV> upon a write if no physical memory is available.  See also the discussion of the file I</proc/sys/vm/overcommit_memory> in B<proc>(5).  In kernels before 2.6, this flag had effect only for private writable mappings.
fr: 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 B<SIGSEGV> durant une écriture, s'il n'y a plus de place disponible. Consultez également la description du fichier I</proc/sys/vm/overcommit_memory> dans la page B<proc>(5). Dans les noyaux antérieurs à 2.6, cet attribut n'avait d'effet que pour les projections privées modifiables.

note: type: TP
en: B<MAP_POPULATE> (since Linux 2.5.46)
fr: B<MAP_POPULATE> (depuis Linux 2.5.46)

note: type: TP
en: B<MAP_STACK> (since Linux 2.6.27)
fr: B<MAP_STACK> (depuis Linux 2.6.27)

note: See http://lwn.net/Articles/294642 "Tangled up in threads", 19 Aug 08 commit cd98a04a59e2f94fa64d5bf1e26498d27427d5e7 http://thread.gmane.org/gmane.linux.kernel/720412 "pthread_create() slow for many threads; also time to revisit 64b context switch optimization?" type: Plain text
en: Allocate the mapping at an address suitable for a process or thread stack.  This flag is currently a no-op, but is used in the glibc threading implementation so that if some architectures require special treatment for stack allocations, support can later be transparently implemented for glibc.
fr: Alloue la projection à une adresse qui convient pour la pile d'un processus ou d'un thread. Cet attribut n'a pour l'instant aucun effet, mais est utilisé par l'implémentation des threads de la glibc de telle sorte que si certaines architectures nécessitent un traitement particulier pour l'allocation de la pile, leur prise en charge par la suite par la glibc pourra être implémentée de façon transparente.

note: type: TP
en: B<MAP_UNINITIALIZED> (since Linux 2.6.33)
fr: B<MAP_UNINITIALIZED> (depuis Linux 2.6.33)

note: type: Plain text
en: Don't clear anonymous pages.  This flag is intended to improve performance on embedded devices.  This flag is honored only if the kernel was configured with the B<CONFIG_MMAP_ALLOW_UNINITIALIZED> option.  Because of the security implications, that option is normally enabled only on embedded devices (i.e., devices where one has complete control of the contents of user memory).
fr: N'efface pas les pages anonymes. Cet attribut n'a pour l'instant un effet que si le noyau a été configuré avec l'option B<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).

note: type: Plain text
en: Memory mapped by B<mmap>()  is preserved across B<fork>(2), with the same attributes.
fr: La mémoire obtenue par B<mmap> est préservée au travers d'un B<fork>(2), avec les mêmes attributs.

note: type: Plain text
en: A file is mapped in multiples of the page size.  For a file that is not a multiple of the page size, the remaining memory is zeroed when mapped, and writes to that region are not written out to the file.  The effect of changing the size of the underlying file of a mapping on the pages that correspond to added or removed regions of the file is unspecified.
fr: La projection doit avoir une taille multiple de celle des pages. Pour un fichier dont la longueur n'est pas un multiple de la taille de page, la mémoire restante est remplie de zéros lors de la projection, et les écritures dans cette zone n'affectent pas le fichier. Les effets de la modification de la taille du fichier sous\(hyjacent sur les pages correspondant aux zones ajoutées ou supprimées ne sont pas précisés.

note: type: Plain text
en: The B<munmap>()  system call deletes the mappings for the specified address range, and causes further references to addresses within the range to generate invalid memory references.  The region is also automatically unmapped when the process is terminated.  On the other hand, closing the file descriptor does not unmap the region.
fr: L'appel système B<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.

note: type: SH
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: A file descriptor refers to a non-regular file.  Or a file mapping was requested, but I<fd> is not open for reading.  Or B<MAP_SHARED> was requested and B<PROT_WRITE> is set, but I<fd> is not open in read/write (B<O_RDWR>)  mode.  Or B<PROT_WRITE> is set, but the file is append-only.
fr: Le descripteur ne correspond pas à un fichier normal, ou on demande une projection de fichier mais I<fd> n'est pas ouvert en lecture, ou on demande une projection partagée B<MAP_SHARED> avec protection B<PROT_WRITE>, mais I<fd> n'est pas ouvert en lecture et écriture (B<O_RDWR>). Ou encore B<PROT_WRITE> est demandé, mais le fichier est ouvert en ajout seulement.

note: type: Plain text
en: The file has been locked, or too much memory has been locked (see B<setrlimit>(2)).
fr: Le fichier est verrouillé, ou trop de pages ont été verrouillées en mémoire (consultez B<setrlimit>(2)).

note: type: Plain text
en: I<fd> is not a valid file descriptor (and B<MAP_ANONYMOUS> was not set).
fr: I<fd> n'est pas un descripteur de fichier valable (et B<MAP_ANONYMOUS> n'était pas précisé).

note: type: Plain text
en: We don't like I<addr>, I<length>, or I<offset> (e.g., they are too large, or not aligned on a page boundary).
fr: I<addr> ou I<length> ou I<offset> sont invalides (par exemple\ : zone trop grande, ou non alignée sur une frontière de page).

note: type: Plain text
en: (since Linux 2.6.12)  I<length> was 0.
fr: (depuis Linux 2.6.12) I<length> est nul.

note: type: Plain text
en: The underlying filesystem of the specified file does not support memory mapping.
fr: Le système de fichiers sous\(hyjacent ne supporte pas la projection en mémoire.

note: type: Plain text
en: On 32-bit architecture together with the large file extension (i.e., using 64-bit I<off_t>): the number of pages used for I<length> plus number of pages used for I<offset> would overflow I<unsigned long> (32 bits).
fr: Sur architecture 32 bits avec l'extension de fichiers très grands (c'est-à-dire utilisant un I<off_t> sur 64 bits) : le nombre de pages utilisées pour I<length> plus le nombre de pages utilisées pour I<offset> dépasserait I<unsigned long> (32 bits).

note: (Since 2.4.25 / 2.6.0.) type: Plain text
en: The I<prot> argument asks for B<PROT_EXEC> but the mapped area belongs to a file on a filesystem that was mounted no-exec.
fr: L'argument I<prot> a demandé B<PROT_EXEC> mais la zone appartient à un fichier sur un système de fichiers monté sans permission d'exécution.

note: type: Plain text
en: B<MAP_DENYWRITE> was set but the object specified by I<fd> is open for writing.
fr: B<MAP_DENYWRITE> a été réclamé mais I<fd> est ouvert en écriture.

note: type: Plain text
en: Use of a mapped region can result in these signals:
fr: L'accès à une zone de projection peut déclencher les signaux suivants\ :

note: type: Plain text
en: Attempted write into a region mapped as read-only.
fr: Tentative d'écriture dans une zone en lecture seule.

note: type: Plain text
en: Attempted access to a portion of the buffer that does not correspond to the file (for example, beyond the end of the file, including the case where another process has truncated the file).
fr: Tentative d'accès à une portion de la zone qui ne correspond pas au fichier (par exemple après la fin du fichier, y compris lorsqu'un autre processus l'a tronqué).

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: tbl table
en: Value
fr: Valeur

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: SH
en: AVAILABILITY
fr: DISPONIBILITÉ

note: type: Plain text
en: On some hardware architectures (e.g., i386), B<PROT_WRITE> implies B<PROT_READ>.  It is architecture dependent whether B<PROT_READ> implies B<PROT_EXEC> or not.  Portable programs should always set B<PROT_EXEC> if they intend to execute code in the new mapping.
fr: Sur certaines architectures matérielles (par exemple, i386), B<PROT_WRITE> implique B<PROT_READ>. Cela dépend de l'architecture si B<PROT_READ> implique B<PROT_EXEC> ou non. Les programmes portables doivent toujours indiquer B<PROT_EXEC> s'ils veulent exécuter du code dans la projection.

note: type: Plain text
en: The portable way to create a mapping is to specify I<addr> as 0 (NULL), and omit B<MAP_FIXED> from I<flags>.  In this case, the system chooses the address for the mapping; the address is chosen so as not to conflict with any existing mapping, and will not be 0.  If the B<MAP_FIXED> flag is specified, and I<addr> is 0 (NULL), then the mapped address will be 0 (NULL).
fr: La manière portable de créer une projection est de spécifier I<addr> à 0 (NULL), et d'omettre B<MAP_FIXED> dans I<flags>. Dans ce cas, le système choisit l'adresse de la projection ; l'adresse est choisie de manière à ne pas entrer en conflit avec une projection existante et de ne pas être nulle. Si l'attribut B<MAP_FIXED> est indiqué et si I<addr> vaut 0 (NULL), l'adresse projetée sera zéro (NULL).

note: type: SS
en: Timestamps changes for file-backed mappings
fr: Modifications d'horodatage pour les projections supportées par un fichier

note: type: Plain text
en: For file-backed mappings, the I<st_atime> field for the mapped file may be updated at any time between the B<mmap>()  and the corresponding unmapping; the first reference to a mapped page will update the field if it has not been already.
fr: Pour les projections supportées par un fichier, le champ I<st_atime> du fichier peut être mis à jour à tout moment entre l'appel B<mmap>() et le B<munmap>() correspondant. Le premier accès dans la page projetée mettra le champ à jour si cela n'a pas été déjà fait.

note: type: Plain text
en: The I<st_ctime> and I<st_mtime> field for a file mapped with B<PROT_WRITE> and B<MAP_SHARED> will be updated after a write to the mapped region, and before a subsequent B<msync>(2)  with the B<MS_SYNC> or B<MS_ASYNC> flag, if one occurs.
fr: Les champs I<st_ctime> et I<st_mtime> pour un fichier projeté avec B<PROT_WRITE> et B<MAP_SHARED> seront mis à jour après une écriture dans la région projetée, et avant l'éventuel B<msync>(2) suivant avec attribut B<MS_SYNC> ou B<MS_ASYNC>.

note: Since around glibc 2.1/2.2, depending on the platform. type: Plain text
en: This page describes the interface provided by the glibc B<mmap>()  wrapper function.  Originally, this function invoked a system call of the same name.  Since kernel 2.4, that system call has been superseded by B<mmap2>(2), and nowadays the glibc B<mmap>()  wrapper function invokes B<mmap2>(2)  with a suitably adjusted value for I<offset>.
fr: Cette page décrit l'interface fournie par la fonction B<mmap>() de la glibc. Initialement, cette fonction appelait un appel système du même nom. Depuis le noyau 2.4, cet appel système a été remplacé par B<mmap2>(2). De nos jours, la fonction B<mmap>() de la glibc appelle B<mmap2>(2) avec la bonne valeur pour I<offset>.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: In kernels before 2.6.7, the B<MAP_POPULATE> flag has effect only if I<prot> is specified as B<PROT_NONE>.
fr: Dans les noyaux antérieurs à 2.6.7, le drapeau B<MAP_POPULATE> n'avait d'effet que si I<prot> était B<PROT_NONE>.

note: type: Plain text
en: SUSv3 specifies that B<mmap>()  should fail if I<length> is 0.  However, in kernels before 2.6.12, B<mmap>()  succeeded in this case: no mapping was created and the call returned I<addr>.  Since kernel 2.6.12, B<mmap>()  fails with the error B<EINVAL> for this case.
fr: SUSv3 indique que B<mmap>() devrait échouer si I<length> est 0. Cependant, avec les versions de Linux antérieures à 2.6.12, B<mmap>() réussissait dans ce cas\ : aucune projection n'était créée, et l'appel renvoyait I<addr>. Depuis le noyau 2.6.12, B<mmap>() échoue avec le code d'erreur B<EINVAL> si I<length> est nul.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The following program prints part of the file specified in its first command-line argument to standard output.  The range of bytes to be printed is specified via offset and length values in the second and third command-line arguments.  The program creates a memory mapping of the required pages of the file and then uses B<write>(2)  to output the desired bytes.
fr: Le programme suivant affiche la partie du fichier, précisé par le premier argument de la ligne de commande, sur la sortie standard. Les octets qui seront affichés sont précisés à partir d'un offset (déplacement) et d'une longueur en deuxième et troisième paramètre. Le code fait une projection mémoire des pages nécessaires du fichier puis utilise B<write>(2) pour afficher les octets voulus.

note: type: SS
en: Program source
fr: Source du programme

note: type: Plain text
en:     if (argc E<lt> 3 || argc E<gt> 4) {
            fprintf(stderr, "%s file offset [length]\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc E<lt> 3 || argc E<gt> 4) {
            fprintf(stderr, "%s fichier offset [longueur]\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     if (fstat(fd, &sb) == -1)           /* To obtain file size */
            handle_error("fstat");
fr:     if (fstat(fd, &sb) == -1)           /* Pour obtenir la taille du fichier */
            handle_error("fstat");

note: type: Plain text
en:     offset = atoi(argv[2]);
        pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);
            /* offset for mmap() must be page aligned */
fr:     offset = atoi(argv[2]);
        pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);
            /* l'offset pour mmap() doit être aligné sur une page */

note: type: Plain text
en:     if (offset E<gt>= sb.st_size) {
            fprintf(stderr, "offset is past end of file\en");
            exit(EXIT_FAILURE);
        }
fr:     if (offset E<gt>= sb.st_size) {
            fprintf(stderr, "L'offset dépasse la fin du fichier\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     if (argc == 4) {
            length = atoi(argv[3]);
            if (offset + length E<gt> sb.st_size)
                length = sb.st_size - offset;
                    /* Can\(aqt display bytes past end of file */
fr:     if (argc == 4) {
            length = atoi(argv[3]);
            if (offset + length E<gt> sb.st_size)
                length = sb.st_size - offset;
                    /* Impossible d'afficher les octets en dehors du fichier */

note: type: Plain text
en:     } else {    /* No length arg ==E<gt> display to end of file */
            length = sb.st_size - offset;
        }
fr:     } else {    /* Pas de paramètre longueur
                       ==E<gt> affichage jusqu'à la fin du fichier */
            length = sb.st_size - offset;
        }

note: type: Plain text
en:         fprintf(stderr, "partial write");
            exit(EXIT_FAILURE);
        }
fr:         fprintf(stderr, "écriture partielle");
            exit(EXIT_FAILURE);
        }

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: The descriptions of the following files in B<proc>(5): I</proc/[pid]/maps>, I</proc/[pid]/map_files>, and I</proc/[pid]/smaps>.
fr: Dans B<proc>(5), les descriptions des fichiers I</proc/[pid]/maps>, I</proc/[pid]/map_files>, and I</proc/[pid]/smaps>.

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.03 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2019-02-27
fr: 27 février 2019

note: type: Plain text
en: I<flags> contained neither B<MAP_PRIVATE> or B<MAP_SHARED>, or contained both of these values.
fr: I<flags> ne contient ni B<MAP_PRIVATE> ni B<MAP_SHARED>, ou les contient tous les deux.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.02 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.01 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.
