Provided by: manpages_2.77-1_all bug


       core - core dump file


       The  default  action  of  certain  signals  is  to  cause  a process to
       terminate and produce a core dump file, a disk file containing an image
       of  the  process’s  memory  at  the time of termination.  A list of the
       signals which cause a process to dump core can be found in signal(7).

       A process can set its soft 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 getrlimit(2) for details.

       There are various circumstances in  which  a  core  dump  file  is  not

       *  The  process  does  not have permission to write the core file.  (By
          default the core file is called core, and is created in the  current
          working  directory.   See below for details on naming.)  Writing the
          core file will fail if the directory in which it is to be created is
          non-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).

       *  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.

       *  The  file  system 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 file system.

       *  The  directory in which the core dump file is to be created does not

       *  RLIMIT_CORE or RLIMIT_FSIZE resource limits for a process are set to
          zero (see getrlimit(2)).

       *  The  binary  being  executed  by  the  process  does  not  have read
          permission enabled.

       *  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.   (However,  see  the  description  of  the   prctl(2)
          PR_SET_DUMPABLE    operation,    and    the   description   of   the
          /proc/sys/fs/suid_dumpable file in proc(5).)

   Naming of core dump files
       By   default,   a   core   dump   file   is   named   core,   but   the
       /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:

         %%  A single % character
         %p  PID of dumped process
         %u  real UID of dumped process
         %g  real GID of dumped process
         %s  number of signal causing dump
         %t  time of dump (seconds since 0:00h, 1 Jan 1970)
         %h  hostname (same as ’nodename’ returned by uname(2))
         %e  executable filename

       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 ’/’
       characters, which are interpreted as delimiters  for  directory  names.
       The  maximum  size  of  the  resulting  core filename is 64 bytes.  The
       default value in this file is "core".  For backward  compatibility,  if
       /proc/sys/kernel/core_pattern     does    not    include    "%p"    and
       /proc/sys/kernel/core_uses_pid (see below) is nonzero, then  .PID  will
       be appended to the core filename.

       Since  version  2.4, Linux has also provided a more primitive method of
       controlling   the   name   of   the   core   dump   file.     If    the
       /proc/sys/kernel/core_uses_pid  file  contains the value 0, then a core
       dump file is simply named core.  If this file contains a nonzero value,
       then  the  core dump file includes the process ID in a name of the form


       The gdb(1) gcore command can be used to obtain a core dump of a running

       If  a  multithreaded process (or, more precisely, a process that shares
       its memory with another process by being created with the CLONE_VM flag
       of  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 %p specification in /proc/sys/kernel/core_pattern.
       (This   is   primarily   useful   when   employing   the   LinuxThreads
       implementation, where each thread of a process has a different PID.)


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


       This page is part of release 2.77 of the Linux  man-pages  project.   A
       description  of  the project, and information about reporting bugs, can
       be found at