Provided by: manpages-fr_3.17.1-1_all bug

NOM

       core - Fichier image de la mémoire

DESCRIPTION

       L’action  par  défaut  de  certains  signaux et de faire se terminer un
       processus et de produire un fichier image mmoire (« core dump file »).
       C’est  un  fichier  disque qui contient l’image mémoire du processus au
       moment où il s’est terminé. Cette  image  peut  être  utilisé  dans  un
       débogueur  (par  exemple,  gdb(1))  pour étudier l’état du programme au
       moment où il a  été  terminé.  Une  liste  des  signaux  provoquant  la
       création de cette image mémoire se trouve dans signal(7).

       Un  processus  peut  définir  sa propre limite de ressource RLIMIT_CORE
       afin de fixer une limite  supérieure  à  la  taille  du  fichier  image
       mémoire  qui  sera  créé  s’il  reçoit  un  signal « core dump » ; voir
       getrlimit(2) pour davantage d’informations.

       Il y a diverses circonstances pour lesquelles un fichier image  mémoire
       (« core dump ») n’est pas produit :

       *  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
          core,  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  n’est pas un fichier normal (par exemple, si c’est un répertoire
          ou un lien symbolique).

       *  Un fichier (régulier et dans lequel on peut écrire) 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.

       *  Le système de fichiers dans lequel serait écrit le fichier image  de
          la  mémoire  est  plein  ou  il n’a plus d’inode, ou il est monté en
          lecture seule, ou l’utilisateur a atteint son quota pour le  système
          de fichiers.

       *  Le  répertoire  dans lequel le fichier image de la mémoire doit être
          créé n’existe pas.

       *  Les limites de ressources RLIMIT_CORE (taille des fichiers « core »)
          ou  RLIMIT_FSIZE  (taille  des  fichiers)  pour un processus ont une
          valeur nulle ; consultez getrlimit(2)  et  la  documentation  de  la
          commande ulimit de l’interpréteur de commande (limit dans csh(1)).

       *  Le  binaire en cours d’exécution par le processus n’a pas les droits
          en écriture activés.

       *  Le  processus  exécute  un  programme  set-user-ID  (respectivement,
          set-group-ID)  qui est détenu par un utilisateur (respectivement, un
          groupe) autre que l’identifiant  d’utilisateur  (respectivement,  de
          groupe)  réel  du  processus.  (Voir  cependant  la  description  de
          l’opération prctl(2) PR_SET_DUMPABLE, et la description  du  fichier
          /proc/sys/fs/suid_dumpable dans proc(5)).

   Nommage des fichiers image mémoire
       Par  défaut,  un  fichier  image  de la mémoire s’appelle core, mais le
       fichier /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  substitués  par  les  valeurs  suivantes
       lorsqu’une image de la mémoire est créée :

           %%  Caractère % unique
           %p  PID du processus « dumpé »
           %u  UID (numérique) réel du processus « dumpé »
           %g  GID (numérique) réel du processus « dumpé »
           %s  Numéro du signal ayant provoqué le « dump »
           %t  Heure du « dump », exprimé en secondes depuis l’Époque (le  1er
               janvier 1970, 00H00 UTC)
           %h  Nom d’hôte (identique à nodename tel que le renvoie uname(2))
           %e  Nom du fichier exécutable (sans le chemin)
           %c  Limite  de ressource souple de la taille des fichiers core lors
               du plantage d’un processus (depuis Linux 2.6.24)

       Un % isolé à la fin du motif est éliminé du nom de fichier  de  l’image
       mémoire,  de  même 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ère  « / »,  ils  sont   interprétés   comme   des
       délimiteurs  pour  les noms de répertoires. La taille maximum du nom de
       fichier de l’image mémoire résultant est de 128 octets (64 octets  dans
       les  noyaux  antérieurs  au  2.6.19). La valeur par défaut de ce nom de
       fichier est « core ». Afin d’assurer une compatibilité  ascendante,  si
       /proc/sys/kernel/core_pattern    ne   contient   pas   « %p »   et   si
       /proc/sys/kernel/core_uses_pid (voir  ci-dessous)  est  non-nul,  alors
       .PID est ajouté au nom de fichier de l’image mémoire.

       Depuis  la  version 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
       /proc/sys/kernel/core_uses_pid  contient  la valeur 0, alors le fichier
       image de la mémoire est tout simplement  appelé  core.  Si  ce  fichier
       contient  une  valeur  non nulle, alors, le fichier image de la mémoire
       intégrera dans son nom le numéro d’identification du processus sous  la
       forme core.PID.

   Tuber les vidages mémoire vers un programme
       Depuis  le  noyau 2.6.19,  Linux  gère  une syntaxe alternative pour le
       fichier /proc/sys/kernel/core_pattern. Si le premier  caractère  de  ce
       fichier est le symbole du tube (|), le reste de la ligne est interprété
       comme étant un programme à exécuter. Le vidage mémoire est alors fourni
       comme  entrée  standard  au  programme  plutôt que d’être écrit dans un
       fichier sur le disque. Veuillez noter les points suivants :

       *  Le programme doit être indiqué avec un chemin d’accès absolu (ou  un
          chemin  relatif  par  rapport  au  répertoire  racine,  /)  et  doit
          immédiatement suivre le caractère « | ».

       *  Le processus créé pour exécuter  le  programme  s’exécute  avec  les
          utilisateur et groupe root.

       *  Des paramètre en ligne de commande peuvent être fournis au programme
          (depuis le noyau 2.6.24),  séparés  par  des  espaces  (jusqu’à  une
          longueur de ligne de 128 octets).

       *  Les  paramètres  de  la  ligne  de  commande  peuvent  inclure  tout
          spécificateur % indiqué plus haut. Par exemple, pour passer  le  PID
          du processus à vider, indiquez %p dans un paramètre.

   Contrôler quelles projections seront écrites dans le vidage mémoire
       Depuis le noyau 2.6.23, le fichier /proc/PID/coredump_filter spécifique
       à Linux peut être utilisé pour  contrôler  quels  segments  de  mémoire
       seront  écrits  dans  le  fichier  d’image de mémoire dans le cas où le
       vidage  mémoire  est  effectué  pour   le   processus   avec   le   PID
       correspondant.

       La valeur dans ce fichier est un masque de bits des types de projection
       mémoire (voir mmap(2)). Si un bit est positionné dans  le  masque,  les
       projections  mémoire  du  type  correspondant  sont vidées ; autrement,
       elles ne le sont pas. Les bits dans ce fichier ont  les  significations
       suivantes :

           bit 0  Vider les projections privées anonymes.
           bit 1  Vider les projections partagées anonymes.
           bit 2  Vider les projections privées sauvegardées sur fichier
           bit 3  Vider les projections partagées sauvegardées sur fichier

       La  valeur  par  défaut  de  coredump_filter  est 0x3 ; cela reflète le
       comportement traditionnel de linux et signifie que seuls  les  segments
       de mémoire anonyme sont vidés.

       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  sont
       toujours vidées, quelle que soit la valeur de coredump_filter.

       Un   processus   fils   créé  avec  fork(2)  hérite  de  la  valeur  de
       coredump_filter  de  son  père ;  la  valeur  de  coredump_filter   est
       préservée au travers d’un execve(2).

       Il  peut  être  utile  de  définir coredump_filter dans le shell parent
       avant d’exécuter le programme, par exemple :

           $ echo 0x7 > /proc/self/coredump_filter
           $ ./un_programme

       Ce fichier n’existe que si le noyau a  été  compilé  avec  l’option  de
       configuration CONFIG_ELF_CORE.

NOTES

       La  commande  gdb(1)  gcore  peut  être utilisée pour obtenir une image
       mémoire d’un processus en cours d’exécution.

       Si une tâche multiprocessus (« multithreaded ») (ou, plus  précisément,
       un  processus qui partage son espace mémoire avec un autre processus en
       étant créé avec l’indicateur  CLONE_VM  de  clone(2))  crée  une  image
       mémoire,  alors l’identifiant du processus (PID) est toujours ajouté au
       nom du fichier image de  la  mémoire,  à  moins  que  l’identifiant  du
       processus fasse déjà partie du nom de fichier par l’intermédiaire d’une
       spécification    %p    de     /proc/sys/kernel/core_pattern.     (C’est
       principalement   utile   lors   de  l’utilisation  de  l’implémentation
       LinuxThreads, pour laquelle chaque thread a son propre PID.)

EXEMPLE

       Le programme ci-dessous montre l’utilisation  de  la  syntaxe  tube  du
       fichier /proc/sys/kernel/core_pattern. La session shell suivante montre
       l’utilisation de ce programme (compilé pour créé  un  exécutable  nommé
       core_pattern_pipe_test) :

           $ cc -o core_pattern_pipe_test core_pattern_pipe_test.c
           $ su
           Password:
           # echo '|$PWD/core_pattern_pipe_test %p UID=%u GID=%g sig=%s' > \
           /proc/sys/kernel/core_pattern
           # exit
           $ sleep 100
           ^\                     # type control-backslash
           Quit (core dumped)
           $ cat core.info
           argc=5
           argc[0]=</home/mtk/core_pattern_pipe_test>
           argc[1]=<20575>
           argc[2]=<UID=1000>
           argc[3]=<GID=100>
           argc[4]=<sig=3>
           Total bytes in core dump: 282624

   Source du programme

       /* core_pattern_pipe_test.c */

       #define _GNU_SOURCE
       #include <sys/stat.h>
       #include <fcntl.h>
       #include <limits.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>

       #define BUF_SIZE 1024

       int
       main(int argc, char *argv[])
       {
           int tot, j;
           ssize_t nread;
           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\n", argc);
           for (j = 0; j < argc; j++)
               fprintf(fp, "argc[%d]=<%s>\n", j, argv[j]);

           /* Count bytes in standard input (the core dump) */

           tot = 0;
           while ((nread = read(STDIN_FILENO, buf, BUF_SIZE)) > 0)
               tot += nread;
           fprintf(fp, "Total bytes in core dump: %d\n", tot);

           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       bash(1), gdb(1), getrlimit(2), mmap(2), prctl(2), sigaction(2), elf(5),
       proc(5), pthreads(7), signal(7)

COLOPHON

       Cette page fait partie de  la  publication  3.17  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette  page  de  manuel  a  été  traduite et est maintenue par Jean-Luc
       Coulon  (f5ibh)  <jean-luc.coulon  AT  wanadoo  DOT  fr>  et   l’équipe
       francophone de traduction de Debian.

       Veuillez   signaler   toute   erreur   de   traduction  en  écrivant  à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous  pouvez  toujours avoir accès à la version anglaise de ce document
       en utilisant la commande « man -L C <section> <page_de_man> ».