perkamon - en to fr translation catalogue (125 entries)

note: type: TH
en: 2023-05-03
fr: 3 mai 2023

note: type: TH
en: Linux man-pages 6.05.01
fr: Pages du manuel de Linux 6.05.01

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: core - core dump file
fr: core — Fichier image de la mémoire

note: type: Plain text
en: The default action of certain signals is to cause a process to terminate and produce a I<core dump file>, a file containing an image of the process's memory at the time of termination.  This image can be used in a debugger (e.g., B<gdb>(1))  to inspect the state of the program at the time that it terminated.  A list of the signals which cause a process to dump core can be found in B<signal>(7).
fr: L'action par défaut de certains signaux consiste à faire se terminer un processus et à produire un I<fichier image de la mémoire> (« core dump file »). C'est un fichier qui contient l'image mémoire du processus au moment où il s'est terminé. Cette image peut être utilisée dans un débogueur (par exemple, B<gdb>(1)) pour étudier l'état du programme au moment où il s'est terminé. Une liste des signaux provoquant la création de cette image mémoire se trouve dans B<signal>(7).

note: type: Plain text
en: A process can set its soft B<RLIMIT_CORE> resource limit to place an upper limit on the size of the core dump file that will be produced if it receives a "core dump" signal; see B<getrlimit>(2)  for details.
fr: Un processus peut définir sa propre limite de ressource souple B<RLIMIT_CORE> afin de définir une limite supérieure à la taille du fichier image de la mémoire qui sera créé s'il reçoit un signal « core dump » ; consultez B<getrlimit>(2) pour davantage d'informations.

note: type: Plain text
en: There are various circumstances in which a core dump file is not produced:
fr: Il y a diverses circonstances dans lesquelles un fichier image de la mémoire (« core dump ») n'est pas produit :

note: type: IP
en: \[bu]
fr: -

note: type: Plain text
en: The process does not have permission to write the core file.  (By default, the core file is called I<core> or I<core.pid>, where I<pid> is the ID of the process that dumped core, and is created in the current working directory.  See below for details on naming.)  Writing the core file fails if the directory in which it is to be created is not writable, or if a file with the same name exists and is not writable or is not a regular file (e.g., it is a directory or a symbolic link).
fr: Le processus ne possède pas les droits pour écrire le fichier image de la mémoire (par défaut, le fichier image de la mémoire s'appelle I<core> ou I<core.pid>, où I<pid> est l'identifiant du processus qui a généré une image de la mémoire. Il est créé dans le répertoire de travail en cours. Voir ci-dessous pour davantage d'informations sur les règles de nommage). L'écriture du fichier image de la mémoire échouera si le répertoire dans lequel il devrait être écrit n'est pas accessible en écriture ou si un fichier avec le même nom existe et n'est pas accessible en écriture ou n'est pas un fichier ordinaire (par exemple, si c'est un répertoire ou un lien symbolique).

note: type: Plain text
en: A (writable, regular) file with the same name as would be used for the core dump already exists, but there is more than one hard link to that file.
fr: Un fichier (ordinaire et accessible en écriture) avec le même nom que celui qui serait utilisé pour l'image de la mémoire existe déjà, mais il y a plusieurs liens physiques vers ce fichier.

note: type: Plain text
en: The filesystem where the core dump file would be created is full; or has run out of inodes; or is mounted read-only; or the user has reached their quota for the filesystem.
fr: Le système de fichiers dans lequel serait écrit le fichier image de la mémoire est plein, il n'a plus d'inœud, il est monté en lecture seule ou l'utilisateur a atteint son quota pour le système de fichiers.

note: type: Plain text
en: The directory in which the core dump file is to be created does not exist.
fr: Le répertoire dans lequel le fichier image de la mémoire doit être créé n'existe pas.

note: type: Plain text
en: The B<RLIMIT_CORE> (core file size) or B<RLIMIT_FSIZE> (file size) resource limits for the process are set to zero; see B<getrlimit>(2)  and the documentation of the shell's I<ulimit> command (I<limit> in B<csh>(1)).  However, B<RLIMIT_CORE> will be ignored if the system is configured to pipe core dumps to a program.
fr: Les limites de ressources B<RLIMIT_CORE> (taille des fichiers « core ») ou B<RLIMIT_FSIZE> (taille des fichiers) pour un processus sont définies à zéro ; consultez B<getrlimit>(2) et la documentation de la commande I<ulimit> de l'interpréteur de commande (I<limit> dans B<csh>(1)). B<RLIMIT_CORE> sera cependant ignorée si le système est configuré pour tuber les vidages mémoire vers un programme.

note: type: Plain text
en: The binary being executed by the process does not have read permission enabled.  (This is a security measure to ensure that an executable whose contents are not readable does not produce a\[em]possibly readable\[em]core dump containing an image of the executable.)
fr: Le binaire actuellement exécuté par le processus n'est pas accessible en lecture. Il s'agit d'une mesure de sécurité pour s'assurer qu'un exécutable dont le contenu n'est pas accessible en lecture ne produira pas de vidage mémoire \[em]\ éventuellement lisible\ \[em] contenant une image de l'exécutable.

note: FIXME . Perhaps relocate discussion of /proc/sys/fs/suid_dumpable and PR_SET_DUMPABLE to this page? type: Plain text
en: The process is executing a set-user-ID (set-group-ID) program that is owned by a user (group) other than the real user (group)  ID of the process, or the process is executing a program that has file capabilities (see B<capabilities>(7)).  (However, see the description of the B<prctl>(2)  B<PR_SET_DUMPABLE> operation, and the description of the I</proc/sys/fs/suid_dumpable> file in B<proc>(5).)
fr: Le processus exécute un programme set-user-ID (ou set-group-ID) dont le propriétaire (ou le groupe) est différent de l'identifiant d'utilisateur (ou de groupe) réel du processus, ou le processus exécute un programme qui possède des capacités de fichier (voir B<capabilities>(7)). Consultez cependant la description de l'opération B<prctl>(2) B<PR_SET_DUMPABLE>, et la description du fichier I</proc/sys/fs/suid_dumpable> dans B<proc>(5).

note: type: Plain text
en: I</proc/sys/kernel/core_pattern> is empty and I</proc/sys/kernel/core_uses_pid> contains the value 0.  (These files are described below.)  Note that if I</proc/sys/kernel/core_pattern> is empty and I</proc/sys/kernel/core_uses_pid> contains the value 1, core dump files will have names of the form I<.pid>, and such files are hidden unless one uses the B<ls>(1)  I<-a> option.
fr: I</proc/sys/kernel/core_pattern> est vide et I</proc/sys/kernel/core_uses_pid> contient la valeur B<0> (ces fichiers sont décrits plus loin). Notez que si I</proc/sys/kernel/core_pattern> est vide et si I</proc/sys/kernel/core_uses_pid> contient la valeur B<1>, les fichiers image de la mémoire posséderont des noms de la forme I<.pid>, et que ces fichiers sont cachés, à moins d'utiliser l'option I<-a> de B<ls>(1).

note: commit 046d662f481830e652ac34cd112249adde16452a type: Plain text
en: (Since Linux 3.7)  The kernel was configured without the B<CONFIG_COREDUMP> option.
fr: (Depuis Linux 3.7) Le noyau a été compilé sans l'option B<CONFIG_COREDUMP>.

note: type: Plain text
en: In addition, a core dump may exclude part of the address space of the process if the B<madvise>(2)  B<MADV_DONTDUMP> flag was employed.
fr: De plus, le vidage mémoire peut exclure des portions de l'espace d'adressage du processus si l'attribut B<madvise>(2) B<MADV_DONTDUMP> est utilisé.

note: type: Plain text
en: On systems that employ B<systemd>(1)  as the I<init> framework, core dumps may instead be placed in a location determined by B<systemd>(1).  See below for further details.
fr: Sur les systèmes qui utilisent B<systemd>(1) comme cadriciel pour I<init>, les vidages mémoire peuvent être écrits à un emplacement déterminé par B<systemd>(1). Voir plus loin pour plus de détails.

note: type: SS
en: Naming of core dump files
fr: Nommage des fichiers image de la mémoire

note: type: Plain text
en: By default, a core dump file is named I<core>, but the I</proc/sys/kernel/core_pattern> file (since Linux 2.6 and 2.4.21)  can be set to define a template that is used to name core dump files.  The template can contain % specifiers which are substituted by the following values when a core file is created:
fr: Par défaut, un fichier image de la mémoire s'appelle I<core>, mais le fichier I</proc/sys/kernel/core_pattern> (depuis Linux 2.6 et 2.4.21) peut être configuré de manière à définir un motif qui sera utilisé pour le nommage des fichiers image de la mémoire. Le motif peut contenir des spécificateurs % qui sont remplacés par les valeurs suivantes lorsqu'une image de la mémoire est créée :

note: type: Plain text
en: A single % character.
fr: Caractère % unique

note: type: Plain text
en: Core file size soft resource limit of crashing process (since Linux 2.6.24).
fr: Limite de ressource souple de la taille du fichier image de la mémoire créé lors du plantage d'un processus (depuis Linux 2.6.24).

note: Added in git commit 12a2b4b2241e318b4f6df31228e4272d2c2968a1 type: Plain text
en: Dump mode\[em]same as value returned by B<prctl>(2)  B<PR_GET_DUMPABLE> (since Linux 3.7).
fr: Mode vidage (« dump mode ») \(em\ identique à la valeur renvoyée par B<prctl>(2) B<PR_GET_DUMPABLE> (depuis Linux 3.7).

note: type: Plain text
en: The process or thread's I<comm> value, which typically is the same as the executable filename (without path prefix, and truncated to a maximum of 15 characters), but may have been modified to be something different; see the discussion of I</proc/>pidI</comm> and I</proc/>pidI</task/>tidI</comm> in B<proc>(5).
fr: La valeur de I<comm> du processus ou du thread, qui correspond en général au nom de l'exécutable (sans le chemin et tronqué à un maximum de 15 caractères), mais peut avoir été modifiée en quelque chose de différent ; voir la discussion à propos de I</proc/>pidI</comm> et I</proc/>pidI</task/>tidI</comm> dans B<proc>(5).

note: type: Plain text
en: Pathname of executable, with slashes (\[aq]/\[aq]) replaced by exclamation marks (\[aq]!\[aq])  (since Linux 3.0).
fr: Chemin d'accès de l'exécutable, où les barres obliques «\ /\ » sont remplacées par des points d'exclamation «\ !\ » (depuis Linux 3.0).

note: type: Plain text
en: Numeric real GID of dumped process.
fr: GID numérique réel du processus dont l'image mémoire a été vidée.

note: type: Plain text
en: Hostname (same as I<nodename> returned by B<uname>(2)).
fr: Nom d'hôte (identique à I<nodename> renvoyé par B<uname>(2)).

note: commit b03023ecbdb76c1dec86b41ed80b123c22783220 type: Plain text
en: TID of thread that triggered core dump, as seen in the PID namespace in which the thread resides (since Linux 3.18).
fr: TID du thread qui a déclenché le vidage mémoire, tel qu'il est vu dans l'espace de noms du PID dans lequel le thread se trouve (depuis Linux 3.18).

note: commit b03023ecbdb76c1dec86b41ed80b123c22783220 type: Plain text
en: TID of thread that triggered core dump, as seen in the initial PID namespace (since Linux 3.18).
fr: TID du thread qui a déclenché le vidage mémoire, tel qu'il est vu dans l'espace de noms du PID initial (depuis Linux 3.18).

note: type: Plain text
en: PID of dumped process, as seen in the PID namespace in which the process resides.
fr: PID du processus dont l'image mémoire a été vidée, tel qu'il est vu dans l'espace de noms du PID dans lequel le processus se trouve.

note: Added in git commit 65aafb1e7484b7434a0c1d4c593191ebe5776a2f type: Plain text
en: PID of dumped process, as seen in the initial PID namespace (since Linux 3.12).
fr: PID du processus dont l'image mémoire a été vidée, tel qu'il est vu dans l'espace des noms du PID initial (depuis Linux 3.12).

note: type: Plain text
en: Number of signal causing dump.
fr: Numéro du signal ayant provoqué le vidage mémoire

note: type: Plain text
en: Time of dump, expressed as seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).
fr: Heure du vidage mémoire exprimée en secondes depuis l'époque, 1er\ janvier 1970 à 00:00:00 +0000 (UTC).

note: type: Plain text
en: Numeric real UID of dumped process.
fr: UID numérique réel du processus «\ vidé\ ».

note: type: Plain text
en: A single % at the end of the template is dropped from the core filename, as is the combination of a % followed by any character other than those listed above.  All other characters in the template become a literal part of the core filename.  The template may include \[aq]/\[aq] characters, which are interpreted as delimiters for directory names.  The maximum size of the resulting core filename is 128 bytes (64 bytes before Linux 2.6.19).  The default value in this file is "core".  For backward compatibility, if I</proc/sys/kernel/core_pattern> does not include I<%p> and I</proc/sys/kernel/core_uses_pid> (see below)  is nonzero, then .PID will be appended to the core filename.
fr: Un % isolé à la fin du motif est éliminé du nom de fichier de l'image mémoire, et il en sera de même pour un % suivi d'un caractère autre que ceux de la liste ci-dessus. Tous les autres caractères du motif conservent leur valeur littérale dans le nom de fichier de l'image mémoire. Un motif peut contenir des caractères « / », ils sont interprétés comme des délimiteurs pour les noms de répertoires. La taille maximale du nom de fichier de l'image mémoire résultant est de 128 octets (64 octets avant Linux 2.6.19). La valeur par défaut de ce nom de fichier est « core ». Afin d'assurer une rétrocompatibilité, si I</proc/sys/kernel/core_pattern> ne contient pas « %p » et si I</proc/sys/kernel/core_uses_pid> (voir ci-dessous) est différent de zéro, « .PID » est ajouté au nom de fichier de l'image mémoire.

note: type: Plain text
en: Paths are interpreted according to the settings that are active for the crashing process.  That means the crashing process's mount namespace (see B<mount_namespaces>(7)), its current working directory (found via B<getcwd>(2)), and its root directory (see B<chroot>(2)).
fr: Les chemins sont interprétés en tenant compte des paramètres actifs pour le processus qui a planté. Ces paramètres comprennent l'espace de noms montage du processus qui a planté (voir B<mount_namespaces>(7)), son répertoire de travail actuel (déterminé à l'aide de B<getcwd>(2)) et son répertoire racine (voir B<chroot>(2)).

note: type: Plain text
en: Since Linux 2.4, Linux has also provided a more primitive method of controlling the name of the core dump file.  If the I</proc/sys/kernel/core_uses_pid> file contains the value 0, then a core dump file is simply named I<core>.  If this file contains a nonzero value, then the core dump file includes the process ID in a name of the form I<core.PID>.
fr: Depuis Linux 2.4, Linux procure aussi une méthode plus primitive pour contrôler le nom du fichier image de la mémoire. Si le fichier I</proc/sys/kernel/core_uses_pid> contient la valeur 0, le fichier image de la mémoire est tout simplement appelé I<core>. Si ce fichier contient une valeur différente de zéro, le fichier image de la mémoire intégrera dans son nom le numéro d'identification du processus sous la forme I<core.PID>.

note: 9520628e8ceb69fa9a4aee6b57f22675d9e1b709 type: Plain text
en: Since Linux 3.6, if I</proc/sys/fs/suid_dumpable> is set to 2 ("suidsafe"), the pattern must be either an absolute pathname (starting with a leading \[aq]/\[aq] character) or a pipe, as defined below.
fr: A partir de Linux 3.6, si I</proc/sys/fs/suid_dumpable> a pour valeur 2 (« suidsafe »), le motif doit être soit un chemin absolu (commençant par le caractère «\ /\ », soit un tube, comme indiqué plus bas.

note: type: SS
en: Piping core dumps to a program
fr: Tuber les vidages mémoire vers un programme

note: type: Plain text
en: Since Linux 2.6.19, Linux supports an alternate syntax for the I</proc/sys/kernel/core_pattern> file.  If the first character of this file is a pipe symbol (B<|>), then the remainder of the line is interpreted as the command-line for a user-space program (or script) that is to be executed.
fr: Depuis le noyau 2.6.19, Linux prend en charge une syntaxe alternative pour le fichier I</proc/sys/kernel/core_pattern>. Si le premier caractère de ce fichier est le symbole du tube (B<|>), le reste de la ligne est interprété comme une ligne de commande pour un programme de l'espace utilisateur (ou un script) à exécuter.

note: commit 315c69261dd3fa12dbc830d4fa00d1fad98d3b03 type: Plain text
en: Since Linux 5.3.0, the pipe template is split on spaces into an argument list I<before> the template parameters are expanded.  In earlier kernels, the template parameters are expanded first and the resulting string is split on spaces into an argument list.  This means that in earlier kernels executable names added by the I<%e> and I<%E> template parameters could get split into multiple arguments.  So the core dump handler needs to put the executable names as the last argument and ensure it joins all parts of the executable name using spaces.  Executable names with multiple spaces in them are not correctly represented in earlier kernels, meaning that the core dump handler needs to use mechanisms to find the executable name.
fr: Depuis Linux 5.3.0, le modèle de tube est divisé en tenant compte des espaces en une liste d'arguments I<avant> l'interprétation des paramètres du modèle. Avec les noyaux plus anciens, les paramètres du modèle sont interprétés en premier et la chaîne résultante est divisée en tenant compte des espaces en une liste d'arguments. Cela signifie qu'avec les noyaux plus anciens, les noms d'exécutable ajoutés par les paramètres de modèle I<%e> et I<%E> pouvaient être divisés en plusieurs arguments. Le gestionnaire de vidage mémoire doit donc définir le dernier argument avec les noms d'exécutable et s'assurer de « recoller » toutes les parties du nom de l'exécutable en tenant compte des espaces. Les noms d'exécutable qui contiennent plusieurs espaces ne sont pas correctement représentés dans les noyaux plus anciens, et dans ce cas, le gestionnaire de vidage mémoire devra utiliser des mécanismes permettant de déterminer le nom de l'exécutable.

note: type: Plain text
en: Instead of being written to a file, the core dump is given as standard input to the program.  Note the following points:
fr: Au lieu d'être écrit dans un fichier, le vidage mémoire est envoyé sur l'entrée standard du programme. Notez les points suivants :

note: type: Plain text
en: The program must be specified using an absolute pathname (or a pathname relative to the root directory, I</>), and must immediately follow the '|' character.
fr: Le programme doit être indiqué avec un chemin d'accès absolu (ou un chemin relatif par rapport au répertoire racine, I</>) et doit immédiatement suivre le caractère « | ».

note: type: Plain text
en: The command-line arguments can include any of the % specifiers listed above.  For example, to pass the PID of the process that is being dumped, specify I<%p> in an argument.
fr: Les arguments de la ligne de commande peuvent inclure tout spécificateur % indiqué plus haut. Par exemple, pour transmettre le PID du processus vidé, indiquez I<%p> dans un argument.

note: type: Plain text
en: The process created to run the program runs as user and group I<root>.
fr: Le processus créé pour exécuter le programme s'exécute avec les utilisateur et groupe I<root>.

note: type: Plain text
en: Running as I<root> does not confer any exceptional security bypasses.  Namely, LSMs (e.g., SELinux) are still active and may prevent the handler from accessing details about the crashed process via I</proc/>pid.
fr: L'exécution en tant que I<root> ne permet pas de raccourcis de sécurité exceptionnels. À ce titre, les LSM (comme SELinux) sont toujours actifs et peuvent empêcher le gestionnaire d'accéder aux détails du processus ayant planté à l'aide de I</proc/>pid.

note: type: Plain text
en: The program pathname is interpreted with respect to the initial mount namespace as it is always executed there.  It is not affected by the settings (e.g., root directory, mount namespace, current working directory)  of the crashing process.
fr: Le nom de chemin du programme est interprété en respectant l'espace de noms montage initial car il est toujours exécuté dans ce contexte. Il n'est pas affecté par les paramètres du processus ayant planté (à savoir le répertoire racine, l'espace de noms montage et le répertoire de travail actuel).

note: type: Plain text
en: The process runs in the initial namespaces (PID, mount, user, and so on)  and not in the namespaces of the crashing process.  One can utilize specifiers such as I<%P> to find the right I</proc/>pid directory and probe/enter the crashing process's namespaces if needed.
fr: Le processus s'exécute dans les espaces de noms initiaux (PID, montage, utilisateur, etc.) et non dans les espaces de noms du processus ayant planté. On peut utiliser des spécificateurs comme I<%P> pour trouver le répertoire I</proc/>pid correct et sonder/entrer les espaces de noms du processus ayant planté si nécessaire.

note: type: Plain text
en: The process starts with its current working directory as the root directory.  If desired, it is possible change to the working directory of the dumping process by employing the value provided by the I<%P> specifier to change to the location of the dumping process via I</proc/>pidI</cwd>.
fr: Le processus démarre avec son répertoire de travail courant comme répertoire racine. Il est cependant possible de passer au répertoire de travail du processus de vidage en utilisant la valeur fournie par le spécificateur I<%P> pour passer à l'emplacement du processus de vidage à l'aide de I</proc/>pidI</cwd>.

note: type: Plain text
en: Command-line arguments can be supplied to the program (since Linux 2.6.24), delimited by white space (up to a total line length of 128 bytes).
fr: Depuis Linux 2.6.24, il est possible de fournir au programme des arguments séparés par des espaces dans la ligne de commande (jusqu'à une longueur de ligne de 128 octets).

note: type: Plain text
en: The B<RLIMIT_CORE> limit is not enforced for core dumps that are piped to a program via this mechanism.
fr: La limite B<RLIMIT_CORE> ne s'applique pas aux vidages mémoire tubés vers un programme à l'aide de ce mécanisme.

note: type: Plain text
en: When collecting core dumps via a pipe to a user-space program, it can be useful for the collecting program to gather data about the crashing process from that process's I</proc/>pid directory.  In order to do this safely, the kernel must wait for the program collecting the core dump to exit, so as not to remove the crashing process's I</proc/>pid files prematurely.  This in turn creates the possibility that a misbehaving collecting program can block the reaping of a crashed process by simply never exiting.
fr: Lorsqu'on collecte des vidages mémoire à l'aide d'un tube vers un programme de l'espace utilisateur, il peut s'avérer utile pour le programme collecteur d'extraire les données à propos du processus ayant planté depuis le répertoire I</proc/>pid de ce dernier. Pour ce faire en toute sécurité, le noyau doit attendre que le programme collecteur de vidage mémoire se termine, de façon à ne pas supprimer prématurément les fichiers contenus dans le répertoire I</proc/>pid du processus ayant planté, ce qui a pour inconvénient de donner la possibilité à un programme de collecte défectueuxde bloquer le vidage d’un processus planté en ne se terminant jamais.

note: commit a293980c2e261bd5b0d2a77340dd04f684caff58 type: Plain text
en: Since Linux 2.6.32, the I</proc/sys/kernel/core_pipe_limit> can be used to defend against this possibility.  The value in this file defines how many concurrent crashing processes may be piped to user-space programs in parallel.  If this value is exceeded, then those crashing processes above this value are noted in the kernel log and their core dumps are skipped.
fr: Depuis Linux 2.6.32, on peut utiliser I</proc/sys/kernel/core_pipe_limit> pour limiter cette possibilité. La valeur contenue dans ce fichier définit le nombre de processus plantés simultanés qui peuvent être tubés en parallèle vers des programmes de l'espace utilisateur. Si cette valeur est dépassée, les processus plantés concernés seront consignés dans le journal du noyau et leurs vidages mémoires omis.

note: type: Plain text
en: A value of 0 in this file is special.  It indicates that unlimited processes may be captured in parallel, but that no waiting will take place (i.e., the collecting program is not guaranteed access to I</proc/E<lt>crashing-PIDE<gt>>).  The default value for this file is 0.
fr: Une valeur de B<0> dans ce fichier a une signification particulière. Elle indique qu'il n'y a pas de limite au nombre de processus qui peuvent être interceptés en parallèle, mais qu'aucune attente ne sera observée (autrement dit, le programme collecteur n'a aucune garantie d'accéder à I</proc/E<lt>crashing-PIDE<gt>>). Par défaut, ce fichier contient la valeur B<0>.

note: type: SS
en: Controlling which mappings are written to the core dump
fr: Contrôler quelles projections seront écrites dans le vidage mémoire

note: type: Plain text
en: Since Linux 2.6.23, the Linux-specific I</proc/>pidI</coredump_filter> file can be used to control which memory segments are written to the core dump file in the event that a core dump is performed for the process with the corresponding process ID.
fr: Depuis Linux 2.6.23, le fichier I</proc/>pidI</coredump_filter> spécifique à Linux permet de contrôler quels segments de mémoire seront écrits dans le fichier image de la mémoire si un vidage mémoire est effectué pour le processus avec le PID correspondant.

note: type: Plain text
en: The value in the file is a bit mask of memory mapping types (see B<mmap>(2)).  If a bit is set in the mask, then memory mappings of the corresponding type are dumped; otherwise they are not dumped.  The bits in this file have the following meanings:
fr: La valeur dans ce fichier est un masque de bits des types de projection mémoire (consultez B<mmap>(2)). Si un bit est positionné dans le masque, les projections mémoire du type correspondant sont vidées ; dans le cas contraire, elles ne le sont pas. Les bits dans ce fichier ont les significations suivantes :

note: type: Plain text
en: Dump anonymous private mappings.
fr: Vider les projections privées anonymes.

note: type: Plain text
en: Dump anonymous shared mappings.
fr: Vider les projections partagées anonymes.

note: type: Plain text
en: Dump file-backed private mappings.
fr: Vider les projections privées sauvegardées sur fichier

note: file-backed shared mappings of course also update the underlying mapped file. type: Plain text
en: Dump file-backed shared mappings.
fr: Vider les projections partagées sauvegardées sur fichier

note: type: TP
en: bit 4 (since Linux 2.6.24)
fr: bit 4 (depuis Linux 2.6.24)

note: type: Plain text
en: Dump ELF headers.
fr: Vider les en-têtes ELF.

note: type: TP
en: bit 5 (since Linux 2.6.28)
fr: bit 5 (depuis Linux 2.6.28)

note: type: Plain text
en: Dump private huge pages.
fr: Vider les pages privées volumineuses.

note: type: TP
en: bit 6 (since Linux 2.6.28)
fr: bit 6 (depuis Linux 2.6.28)

note: type: Plain text
en: Dump shared huge pages.
fr: Vider les pages partagées volumineuses.

note: type: TP
en: bit 7 (since Linux 4.4)
fr: bit 7 (depuis Linux 4.4)

note: commit ab27a8d04b32b6ee8c30c14c4afd1058e8addc82 type: Plain text
en: Dump private DAX pages.
fr: Vider les pages DAX privées.

note: type: TP
en: bit 8 (since Linux 4.4)
fr: bit 8 (depuis Linux 4.4)

note: commit ab27a8d04b32b6ee8c30c14c4afd1058e8addc82 type: Plain text
en: Dump shared DAX pages.
fr: Vider les pages DAX partagées.

note: type: Plain text
en: By default, the following bits are set: 0, 1, 4 (if the B<CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS> kernel configuration option is enabled), and 5.  This default can be modified at boot time using the I<coredump_filter> boot option.
fr: Par défaut, les bits suivants sont positionnés : 0, 1, 4 (si l'option de configuration du noyau I<CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS> est activée) et 5. L'option d'amorçage I<coredump_filter> permet de modifier ce réglage par défaut.

note: type: Plain text
en: The value of this file is displayed in hexadecimal.  (The default value is thus displayed as 33.)
fr: La valeur dans ce fichier est enregistrée en hexadécimal (la valeur par défaut est donc B<33>).

note: type: Plain text
en: Memory-mapped I/O pages such as frame buffer are never dumped, and virtual DSO (B<vdso>(7))  pages are always dumped, regardless of the I<coredump_filter> value.
fr: Les pages d'entrées-sorties projetées en mémoire telles que les tampons de trame ne sont jamais vidées, et les pages DSO virtuelles (B<vdso>(7)) le sont toujours, quelle que soit la valeur de I<coredump_filter>.

note: type: Plain text
en: A child process created via B<fork>(2)  inherits its parent's I<coredump_filter> value; the I<coredump_filter> value is preserved across an B<execve>(2).
fr: Un processus enfant créé avec B<fork>(2) hérite de la valeur de I<coredump_filter> de son parent ; la valeur de I<coredump_filter> est préservée au travers d'un B<execve>(2).

note: type: Plain text
en: It can be useful to set I<coredump_filter> in the parent shell before running a program, for example:
fr: Il peut être utile de définir I<coredump_filter> dans l'interpréteur de commande parent avant d'exécuter le programme ; par exemple :

note: type: Plain text
en: $B< echo 0x7 E<gt> /proc/self/coredump_filter>
    $B< ./some_program>
fr: $B< echo 0x7 E<gt> /proc/self/coredump_filter>
    $B< ./un_programme>

note: type: Plain text
en: This file is provided only if the kernel was built with the B<CONFIG_ELF_CORE> configuration option.
fr: Ce fichier n'existe que si le noyau a été compilé avec l'option de configuration B<CONFIG_ELF_CORE>.

note: type: SS
en: Core dumps and systemd
fr: Vidages mémoire et systemd

note: type: Plain text
en: On systems using the B<systemd>(1)  I<init> framework, core dumps may be placed in a location determined by B<systemd>(1).  To do this, B<systemd>(1)  employs the I<core_pattern> feature that allows piping core dumps to a program.  One can verify this by checking whether core dumps are being piped to the B<systemd-coredump>(8)  program:
fr: Sur les systèmes qui utilisent B<systemd>(1) comme cadriciel pour I<init>, les vidages mémoire peuvent être écrits à un emplacement déterminé par B<systemd>(1). À cet effet, B<systemd>(1) utilise la fonctionnalité I<core_pattern> qui permet de tuber les vidages mémoire vers un programme. Cela peut être vérifié en regardant si les vidages mémoires sont tubés vers le programme B<systemd-coredump>(8) :

note: type: Plain text
en: In this case, core dumps will be placed in the location configured for B<systemd-coredump>(8), typically as B<lz4>(1)  compressed files in the directory I</var/lib/systemd/coredump/>.  One can list the core dumps that have been recorded by B<systemd-coredump>(8)  using B<coredumpctl>(1):
fr: Dans ce cas, les vidages mémoire seront enregistrés à l'emplacement configuré pour B<systemd-coredump>(8), en général sous la forme de fichiers compressés B<lz4>(1) dans le répertoire I</var/lib/systemd/coredump/>. Pour lister les vidages mémoires qui ont été enregistrés par B<systemd-coredump>(8), on peut utiliser B<coredumpctl>(1) :

note: type: Plain text
en: The information shown for each core dump includes the date and time of the dump, the PID, UID, and GID of the dumping process, the signal number that caused the core dump, and the pathname of the executable that was being run by the dumped process.  Various options to B<coredumpctl>(1)  allow a specified coredump file to be pulled from the B<systemd>(1)  location into a specified file.  For example, to extract the core dump for PID 2955 shown above to a file named I<core> in the current directory, one could use:
fr: Les informations contenues dans tout vidage mémoire comprennent la date et l'heure du vidage, les PID, UID et GID du processus de vidage, le numéro du signal qui a déclenché le vidage et le chemin de l'exécutable qui était exécuté par le processus vidé. Plusieurs options de B<coredumpctl>(1) permettent de déplacer le fichier image de la mémoire donné depuis l'emplacement de B<systemd>(1) vers le fichier spécifié. Par exemple, pour extraire le vidage mémoire du PID 2955 montré plus haut dans un fichier nommé I<core> dans le répertoire actuel, on peut utiliser :

note: type: Plain text
en: For more extensive details, see the B<coredumpctl>(1)  manual page.
fr: Pour des détails plus exhaustifs, voir la page de manuel de B<coredumpctl>(1).

note: type: Plain text
en: To (persistently) disable the B<systemd>(1)  mechanism that archives core dumps, restoring to something more like traditional Linux behavior, one can set an override for the B<systemd>(1)  mechanism, using something like:
fr: Pour désactiver de manière permanente le mécanisme de B<systemd>(1) qui archive les vidages mémoire et rétablir un fonctionnement plus proche du comportement traditionnel de Linux, on peut définir un contournement du mécanisme de B<systemd>(1) en utilisant quelque chose du genre :

note: type: Plain text
en: It is also possible to temporarily (i.e., until the next reboot) change the I<core_pattern> setting using a command such as the following (which causes the names of core dump files to include the executable name as well as the number of the signal which triggered the core dump):
fr: On peut aussi modifier le I<core_pattern> temporairement (jusqu'au prochain redémarrage) en utilisant par exemple la commande suivante (qui inclut dans le nom des fichiers image de la mémoire le nom de l'exécutable et le numéro du signal qui a déclenché le vidage mémoire) :

note: type: Plain text
en: The B<gdb>(1)  I<gcore> command can be used to obtain a core dump of a running process.
fr: La commande B<gdb>(1) I<gcore> permet d'obtenir une image mémoire d'un processus en cours d'exécution.

note: Changed with commit 6409324b385f3f63a03645b4422e3be67348d922 Always including the PID in the name of the core file made sense for LinuxThreads, where each thread had a unique PID, but doesn't seem to serve any purpose with NPTL, where all the threads in a process share the same PID (as POSIX.1 requi
en: In Linux versions up to and including 2.6.27, if a multithreaded process (or, more precisely, a process that shares its memory with another process by being created with the B<CLONE_VM> flag of B<clone>(2))  dumps core, then the process ID is always appended to the core filename, unless the process ID was already included elsewhere in the filename via a I<%p> specification in I</proc/sys/kernel/core_pattern>.  (This is primarily useful when employing the obsolete LinuxThreads implementation, where each thread of a process has a different PID.)
fr: Jusqu'à Linux 2.6.27, si un processus multithreadé (ou plus précisément, un processus qui partage son espace mémoire avec un autre processus parce que créé avec l'indicateur B<CLONE_VM> de B<clone>(2)) crée une image mémoire, l'identifiant du processus (PID) est toujours ajouté au nom du fichier image de la mémoire, à moins que l'identifiant du processus ne fasse déjà partie du nom de fichier de par la présence d'une spécification %p dans I</proc/sys/kernel/core_pattern> (cela s'avère principalement utile lors de l'utilisation de l'implémentation obsolète LinuxThreads pour laquelle chaque thread d'un processus a son propre PID).

note: type: SH
en: EXAMPLES
fr: EXEMPLES

note: type: Plain text
en: The program below can be used to demonstrate the use of the pipe syntax in the I</proc/sys/kernel/core_pattern> file.  The following shell session demonstrates the use of this program (compiled to create an executable named I<core_pattern_pipe_test>):
fr: Le programme ci-dessous montre l'utilisation de la syntaxe de tubage dans le fichier I</proc/sys/kernel/core_pattern>. La session de l'interpréteur de commande suivante montre l'utilisation de ce programme (compilé pour créer un exécutable nommé I<core_pattern_pipe_test>) :

note: type: Plain text
en: $B< cc -o core_pattern_pipe_test core_pattern_pipe_test.c>
    $B< su>
    Password:
    #B< echo \[dq]|$PWD/core_pattern_pipe_test %p UID=%u GID=%g sig=%s\[dq] E<gt> \e>
    B</proc/sys/kernel/core_pattern>
    #B< exit>
    $B< sleep 100>
    B<\[ha]\e>                     # type control-backslash
    Quit (core dumped)
    $B< cat core.info>
    argc=5
    argc[0]=E<lt>/home/mtk/core_pattern_pipe_testE<gt>
    argc[1]=E<lt>20575E<gt>
    argc[2]=E<lt>UID=1000E<gt>
    argc[3]=E<lt>GID=100E<gt>
    argc[4]=E<lt>sig=3E<gt>
    Total bytes in core dump: 282624
fr: $B< cc -o core_pattern_pipe_test core_pattern_pipe_test.c>
    $B< su>
    Password:
    #B< echo \[dq]|$PWD/core_pattern_pipe_test %p UID=%u GID=%g sig=%s\[dq] E<gt> \e>
    B</proc/sys/kernel/core_pattern>
    #B< exit>
    $B< sleep 100>
    B<\[ha]\e>                     # taper control-backslash
    Quit (core dumped)
    $B< cat core.info>
    argc=5
    argc[0]=E<lt>/home/mtk/core_pattern_pipe_testE<gt>
    argc[1]=E<lt>20575E<gt>
    argc[2]=E<lt>UID=1000E<gt>
    argc[3]=E<lt>GID=100E<gt>
    argc[4]=E<lt>sig=3E<gt>
    Total bytes in core dump: 282624

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

note: type: Plain text
en: /* core_pattern_pipe_test.c */
    \&
    #define _GNU_SOURCE
    #include E<lt>sys/stat.hE<gt>
    #include E<lt>fcntl.hE<gt>
    #include E<lt>limits.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>unistd.hE<gt>
    \&
    #define BUF_SIZE 1024
    \&
    int
    main(int argc, char *argv[])
    {
        ssize_t nread, tot;
        char buf[BUF_SIZE];
        FILE *fp;
        char cwd[PATH_MAX];
    \&
        /* Change our current working directory to that of the
           crashing process. */
    \&
        snprintf(cwd, PATH_MAX, "/proc/%s/cwd", argv[1]);
        chdir(cwd);
    \&
        /* Write output to file "core.info" in that directory. */
    \&
        fp = fopen("core.info", "w+");
        if (fp == NULL)
            exit(EXIT_FAILURE);
    \&
        /* Display command-line arguments given to core_pattern
           pipe program. */
    \&
        fprintf(fp, "argc=%d\en", argc);
        for (size_t j = 0; j E<lt> argc; j++)
            fprintf(fp, "argc[%zu]=E<lt>%sE<gt>\en", j, argv[j]);
    \&
        /* Count bytes in standard input (the core dump). */
    \&
        tot = 0;
        while ((nread = read(STDIN_FILENO, buf, BUF_SIZE)) E<gt> 0)
            tot += nread;
        fprintf(fp, "Total bytes in core dump: %zd\en", tot);
    \&
        fclose(fp);
        exit(EXIT_SUCCESS);
    }
fr: /* core_pattern_pipe_test.c */
    \&
    #define _GNU_SOURCE
    #include E<lt>sys/stat.hE<gt>
    #include E<lt>fcntl.hE<gt>
    #include E<lt>limits.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>unistd.hE<gt>
    \&
    #define BUF_SIZE 1024
    \&
    int
    main(int argc, char *argv[])
    {
        ssize_t nread, tot;
        char buf[BUF_SIZE];
        FILE *fp;
        char cwd[PATH_MAX];
    \&
        /* Changer notre répertoire de travail actuel pour celui du
           processus qui a planté. */
    \&
        snprintf(cwd, PATH_MAX, "/proc/%s/cwd", argv[1]);
        chdir(cwd);
    \&
        /* Écrire la sortie dans le fichier "core.info" dans ce répertoire. */
    \&
        fp = fopen("core.info", "w+");
        if (fp == NULL)
            exit(EXIT_FAILURE);
    \&
        /* Afficher les arguments de ligne de commande passés au programme 
           cible du tube configuré dans core_pattern. */
    \&
        fprintf(fp, "argc=%d\en", argc);
        for (size_t j = 0; j E<lt> argc; j++)
            fprintf(fp, "argc[%zu]=E<lt>%sE<gt>\en", j, argv[j]);
    \&
        /* Compter les octets sur l'entrée standard (le vidage mémoire). */
    \&
        tot = 0;
        while ((nread = read(STDIN_FILENO, buf, BUF_SIZE)) E<gt> 0)
            tot += nread;
        fprintf(fp, "Taille en octets du vidage mémoire : %zd\en", tot);
    \&
        fclose(fp);
        exit(EXIT_SUCCESS);
    }

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

note: type: TH
en: 2023-02-05
fr: 5 février 2023

note: type: TH
en: Linux man-pages 6.03
fr: Pages du manuel de Linux 6.03

note: type: Plain text
en:     /* Change our current working directory to that of the
           crashing process. */
fr:     /* Changer notre répertoire de travail actuel pour celui du
           processus qui a planté. */

note: type: Plain text
en:     /* Write output to file "core.info" in that directory. */
fr: /* Écrire la sortie dans le fichier "core.info" dans ce répertoire. */

note: type: Plain text
en:     /* Display command-line arguments given to core_pattern
           pipe program. */
fr:     /* Afficher les arguments de ligne de commande passés au programme 
           cible du tube configuré dans core_pattern. */

note: type: Plain text
en:     /* Count bytes in standard input (the core dump). */
fr:     /* Compter les octets sur l'entrée standard (le vidage mémoire). */

note: type: Plain text
en:     tot = 0;
        while ((nread = read(STDIN_FILENO, buf, BUF_SIZE)) E<gt> 0)
            tot += nread;
        fprintf(fp, "Total bytes in core dump: %zd\en", tot);
fr:     tot = 0;
        while ((nread = read(STDIN_FILENO, buf, BUF_SIZE)) E<gt> 0)
            tot += nread;
        fprintf(fp, "Taille en octets du vidage mémoire : %zd\en", tot);

note: type: TH
en: Linux man-pages 6.05
fr: Pages du manuel de Linux 6.05

note: type: TH
en: Linux man-pages 6.04
fr: Pages du manuel de Linux 6.04

note: type: TH
en: 2023-05-03
fr: 3 mai 2023

en: NAME
fr: NOM

note: type: IP
en: \[bu]
fr: -

note: type: Plain text
en: The filesystem where the core dump file would be created is full; or has run out of inodes; or is mounted read-only; or the user has reached their quota for the filesystem.
fr: Le système de fichiers dans lequel serait écrit le fichier image de la

note: type: Plain text
en: The directory in which the core dump file is to be created does not exist.
fr: Le répertoire dans lequel le fichier image de la mémoire doit être créé n'existe pas.

en: The B<RLIMIT_CORE> (core file size) or B<RLIMIT_FSIZE> (file size) resource limits for the process are set to zero; see B<getrlimit>(2)  and the documentation of the shell's I<ulimit> command (I<limit> in B<csh>(1)).  However, B<RLIMIT_CORE> will be ignored if the system is configured to pipe core dumps to a program.
fr: Les limites de ressources B<RLIMIT_CORE> (taille des fichiers « core ») ou

en: A single % character.
fr: Caractère % unique

en: A single % at the end of the template is dropped from the core filename, as is the combination of a % followed by any character other than those listed above.  All other characters in the template become a literal part of the core filename.  The template may include \[aq]/\[aq] characters, which are interpreted as delimiters for directory names.  The maximum size of the resulting core filename is 128 bytes (64 bytes before Linux 2.6.19).  The default value in this file is "core".  For backward compatibility, if I</proc/sys/kernel/core_pattern> does not include I<%p> and I</proc/sys/kernel/core_uses_pid> (see below)  is nonzero, then .PID will be appended to the core filename.
fr: Un % isolé à la fin du motif est éliminé du nom de fichier de l'image

en: Since Linux 3.6, if I</proc/sys/fs/suid_dumpable> is set to 2 ("suidsafe"), the pattern must be either an absolute pathname (starting with a leading \[aq]/\[aq] character) or a pipe, as defined below.
fr: A partir de Linux 3.6, si I</proc/sys/fs/suid_dumpable> a pour valeur 2

note: type: SS
en: Piping core dumps to a program
fr: Tuber les vidages mémoire vers un programme

note: type: Plain text
en: The process created to run the program runs as user and group I<root>.
fr: Le processus créé pour exécuter le programme s'exécute avec les utilisateur et groupe I<root>.

note: type: SS
en: Controlling which mappings are written to the core dump
fr: Contrôler quelles projections seront écrites dans le vidage mémoire

note: type: Plain text
en: The value in the file is a bit mask of memory mapping types (see B<mmap>(2)).  If a bit is set in the mask, then memory mappings of the corresponding type are dumped; otherwise they are not dumped.  The bits in this file have the following meanings:
fr: La valeur dans ce fichier est un masque de bits des types de projection mémoire (consultez B<mmap>(2)). Si un bit est positionné dans le masque, les

en: Dump file-backed shared mappings.
fr: Vider les projections partagées sauvegardées sur fichier

note: type: Plain text
en: Dump ELF headers.
fr: Vider les en-têtes ELF.

en: By default, the following bits are set: 0, 1, 4 (if the B<CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS> kernel configuration option is enabled), and 5.  This default can be modified at boot time using the I<coredump_filter> boot option.
fr: Par défaut, les bits suivants sont positionnés : 0, 1, 4 (si l'option de configuration du noyau I<CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS> est activée)

en: Memory-mapped I/O pages such as frame buffer are never dumped, and virtual DSO (B<vdso>(7))  pages are always dumped, regardless of the I<coredump_filter> value.
fr: Les pages d'entrées-sorties projetées en mémoire telles que les tampons de

note: type: SH
en: EXAMPLES
fr: EXEMPLES

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

en:     fprintf(fp, "argc=%d\en", argc);
        for (size_t j = 0; j E<lt> argc; j++)
            fprintf(fp, "argc[%zu]=E<lt>%sE<gt>\en", j, argv[j]);
fr:     fprintf(fp, "argc=%d\en", argc);

en:     tot = 0;
        while ((nread = read(STDIN_FILENO, buf, BUF_SIZE)) E<gt> 0)
            tot += nread;
        fprintf(fp, "Total bytes in core dump: %zd\en", tot);
fr:     tot = 0;
        while ((nread = read(STDIN_FILENO, buf, BUF_SIZE)) E<gt> 0)
            tot += nread;

note: type: Plain text
en:     fclose(fp);
        exit(EXIT_SUCCESS);
    }
fr:     fclose(fp);
