Provided by: manpages-fr_3.27fr1.4-1_all bug

NOM

       core - Fichier image de la memoire

DESCRIPTION

       L'action  par  defaut  de  certains  signaux et de faire se terminer un
       processus et  de  produire  un  fichier  image  m'emoire  (<< core  dump
       file >>).  C'est  un  fichier  disque  qui  contient l'image memoire du
       processus au moment ou il s'est termine. Cette image peut etre  utilise
       dans  un  debogueur  (par  exemple,  gdb(1))  pour  etudier  l'etat  du
       programme au moment  ou  il  a  ete  termine.  Une  liste  des  signaux
       provoquant la creation de cette image memoire se trouve dans signal(7).

       Un  processus  peut  definir  sa propre limite de ressource RLIMIT_CORE
       afin de fixer une limite  superieure  a  la  taille  du  fichier  image
       memoire qui sera cree s'il recoit un signal << core dump >> ; consultez
       getrlimit(2) pour davantage d'informations.

       Il y a diverses circonstances pour lesquelles un fichier image  memoire
       (<< core dump >>) n'est pas produit :

       *  Le  processus ne possede pas les droits pour ecrire le fichier image
          de la memoire. (Par defaut, le fichier image de la memoire s'appelle
          core,  il  est  cree  dans  le  repertoire de travail en cours. Voir
          ci-dessous pour davantage d'informations sur les regles de nommage).
          L'ecriture  du fichier image de la memoire echouera si le repertoire
          dans lequel il devrait etre ecrit n'est pas accessible  en  ecriture
          ou  n'est pas un fichier normal (par exemple, si c'est un repertoire
          ou un lien symbolique).

       *  Un fichier (regulier et dans lequel on peut ecrire) avec le meme nom
          que celui qui serait utilise pour l'image de la memoire existe deja,
          mais il y a plusieurs liens physiques vers ce fichier.

       *  Le systeme de fichiers dans lequel serait ecrit le fichier image  de
          la  memoire  est  plein  ou  il n'a plus d'inode, ou il est monte en
          lecture seule, ou l'utilisateur a atteint son quota pour le  systeme
          de fichiers.

       *  Le  repertoire  dans lequel le fichier image de la memoire doit etre
          cree 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'interpreteur  de  commande  (limit  dans
          csh(1)).

       *  Le binaire en cours d'execution par le processus n'a pas les  droits
          en ecriture actives.

       *  Le  processus  execute  un  programme  set-user-ID  (respectivement,
          set-group-ID) qui est detenu par un utilisateur (respectivement,  un
          groupe)  autre  que  l'identifiant d'utilisateur (respectivement, de
          groupe) reel du processus. (Consultez cependant  la  description  de
          l'operation  prctl(2)  PR_SET_DUMPABLE, et la description du fichier
          /proc/sys/fs/suid_dumpable dans proc(5)).

   Nommage des fichiers image m'emoire
       Par defaut, un fichier image de la  memoire  s'appelle  core,  mais  le
       fichier /proc/sys/kernel/core_pattern (depuis Linux 2.6 et 2.4.21) peut
       etre configure de maniere a definir un motif qui sera utilise  pour  le
       nommage  des  fichiers  image de la memoire. Le motif peut contenir des
       specificateurs  %  qui  sont  substitues  par  les  valeurs   suivantes
       lorsqu'une image de la memoire est creee :

           %%  Caractere % unique
           %p  PID du processus << dumpe >>
           %u  UID (numerique) reel du processus << dumpe >>
           %g  GID (numerique) reel du processus << dumpe >>
           %s  Numero du signal ayant provoque le << dump >>
           %t  Heure  du  << dump >>,  exprime  en  secondes  depuis l'epoque,
               1er janvier 1970 a 00:00:00 (UTC)
           %h  Nom d'hote (identique a nodename tel que le renvoie uname(2))
           %e  Nom du fichier executable (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  %  isole a la fin du motif est elimine du nom de fichier de l'image
       memoire, de meme un % suivi d'un caractere autre que ceux de  la  liste
       ci-dessus.  Tous  les autres caracteres du motif conservent leur valeur
       litterale dans le nom de fichier de  l'image  memoire.  Un  motif  peut
       contenir   des  caractere  << / >>,  ils  sont  interpretes  comme  des
       delimiteurs pour les noms de repertoires. La taille maximum du  nom  de
       fichier  de l'image memoire resultant est de 128 octets (64 octets dans
       les noyaux anterieurs au 2.6.19). La valeur par defaut  de  ce  nom  de
       fichier est << core >>. Afin d'assurer une compatibilite 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 ajoute au nom de fichier de l'image memoire.

       Depuis la version 2.4, Linux procure aussi une methode  plus  primitive
       pour  controler  le  nom  du fichier image de la memoire. Si le fichier
       /proc/sys/kernel/core_uses_pid contient la valeur 0, alors  le  fichier
       image  de  la  memoire  est  tout simplement appele core. Si ce fichier
       contient une valeur non nulle, alors, le fichier image  de  la  memoire
       integrera  dans son nom le numero d'identification du processus sous la
       forme core.PID.

   Tuber les vidages m'emoire vers un programme
       Depuis le noyau 2.6.19, Linux gere  une  syntaxe  alternative  pour  le
       fichier  /proc/sys/kernel/core_pattern.  Si  le premier caractere de ce
       fichier est le symbole du tube (|), le reste de la ligne est interprete
       comme etant un programme a executer. Le vidage memoire est alors fourni
       comme entree standard au programme plutot  que  d'etre  ecrit  dans  un
       fichier sur le disque. Veuillez noter les points suivants :

       *  Le  programme doit etre indique avec un chemin d'acces absolu (ou un
          chemin  relatif  par  rapport  au  repertoire  racine,  /)  et  doit
          immediatement suivre le caractere << | >>.

       *  Le  processus  cree  pour  executer  le programme s'execute avec les
          utilisateur et groupe root.

       *  Des parametre en ligne de commande peuvent etre fournis au programme
          (depuis  le  noyau  2.6.24),  separes  par  des espaces (jusqu'a une
          longueur de ligne de 128 octets).

       *  Les  parametres  de  la  ligne  de  commande  peuvent  inclure  tout
          specificateur  %  indique plus haut. Par exemple, pour passer le PID
          du processus a vider, indiquez %p dans un parametre.

   Contr^oler quelles projections seront 'ecrites dans le vidage m'emoire
       Depuis le noyau 2.6.23, le fichier /proc/PID/coredump_filter specifique
       a  Linux  peut  etre  utilise  pour controler quels segments de memoire
       seront ecrits dans le fichier d'image de memoire  dans  le  cas  ou  le
       vidage   memoire   est   effectue   pour   le  processus  avec  le  PID
       correspondant.

       La valeur dans ce fichier est un masque de bits des types de projection
       memoire  (consultez  mmap(2)). Si un bit est positionne dans le masque,
       les projections memoire du type correspondant sont videes ;  autrement,
       elles  ne  le sont pas. Les bits dans ce fichier ont les significations
       suivantes :

           bit 0  Vider les projections privees anonymes.
           bit 1  Vider les projections partagees anonymes.
           bit 2  Vider les projections privees sauvegardees sur fichier
           bit 3  Vider les projections partagees sauvegardees sur fichier
           bit 4 (depuis Linux 2.6.24)
                  Vider les en-tetes ELF.
           bit 5 (depuis Linux 2.6.28)
                  Vider les pages privees enormes.
           bit 6 (depuis Linux 2.6.28)
                  Vider les pages partagees enormes.

       Par defaut, les bits suivants sont positionnes : 0, 1, 4  (si  l'option
       de  configuration  du  noyau  CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS  est
       activee) et 5. La valeur de ce fichier est affichee en hexadecimal  (la
       valeur par defaut affichee est donc 33).

       Les pages d'entrees-sorties projetees en memoire telles que les tampons
       de trame ne sont jamais  videes,  et  les  pages  DSO  virtuelles  sont
       toujours videes, quelle que soit la valeur de coredump_filter.

       Un   processus   fils   cree  avec  fork(2)  herite  de  la  valeur  de
       coredump_filter  de  son  pere ;  la  valeur  de  coredump_filter   est
       preservee au travers d'un execve(2).

       Il  peut  etre  utile  de  definir coredump_filter dans le shell parent
       avant d'executer le programme, par exemple :

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

       Ce fichier n'existe que si le noyau a  ete  compile  avec  l'option  de
       configuration CONFIG_ELF_CORE.

NOTES

       La  commande  gdb(1)  gcore  peut  etre utilisee pour obtenir une image
       memoire d'un processus en cours d'execution.

       Si   une   tache   multiprocessus   (<< multithreaded >>)   (ou,   plus
       precisement,  un processus qui partage son espace memoire avec un autre
       processus en etant cree avec l'indicateur CLONE_VM  de  clone(2))  cree
       une  image memoire, alors l'identifiant du processus (PID) est toujours
       ajoute au nom du fichier image de la memoire, a moins que l'identifiant
       du  processus  fasse  deja partie du nom de fichier par l'intermediaire
       d'une  specification  %p   de   /proc/sys/kernel/core_pattern.   (C'est
       principalement   utile   lors   de  l'utilisation  de  l'implementation
       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 (compile pour cree  un  executable  nomme
       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.27  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      etre       trouvees       a       l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis  2010,  cette  traduction est maintenue a l'aide de l'outil po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   de   traduction
       francophone        au        sein        du       projet       perkamon
       <URL:http://perkamon.alioth.debian.org/>.

       Jean-Luc   Coulon   et   l'equipe   francophone   de   traduction    de
       Debian (2006-2009).

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

       Vous  pouvez  toujours avoir acces a la version anglaise de ce document
       en utilisant la commande << man -L C <section> <page_de_man> >>.

Linux                           27 fevrier 2010                        CORE(5)