Core dump

From Wikipedia, the free encyclopedia

Jump to: navigation, search
A core dump gets its name from an old memory technology using tiny magnetic cores, shown here greatly magnified.

In computing, a core dump consists of the recorded state of the working memory of a computer program at a specific time, generally when the program has terminated abnormally (crashed).[1] In practice, other key pieces of program state are usually dumped at the same time, including the processor registers, which may include the program counter and stack pointer, memory management information, and other processor and operating system flags and information. The name comes from the once-standard core memory technology. Core dumps are often used to diagnose or debug errors in computer programs.

On many operating systems, a fatal error in a program automatically triggers a core dump, and by extension the phrase "to dump core" has come to mean, in many cases, any fatal error, regardless of whether a record of the program memory results.

The term "core dump" has become jargon to indicate any deposition of a large amount of unedited data for further examination.


[edit] Background

Before the advent of disk operating systems and the ability to record large data files, core dumps came in the form of paper printouts of the contents of memory, typically arranged in columns of octal or hexadecimal numbers (the latter sometimes being called a "hex dump"), together with interpretations of various encodings such as machine language instructions, text strings, or decimal or floating-point numbers. In more recent operating systems, a "core dump" is a file containing the memory image of a particular process, or the memory images of parts of the address space of that process, along with other information such as the values of processor registers. These files can be viewed in a readable text format similar to the older paper printouts as well using the proper tools such as objdump.

[edit] Causes of core dumps

In high-level programming languages, compilers usually generate programs with correct underlying instructions, and errors more frequently arise from logically complex situations such as accesses to non-existent memory. In practice, these are often buffer overflows, where a programmer allocates too little memory for incoming or computed data, or access to null pointers, a common coding error when an unassigned memory reference variable is accessed. On UNIX-like systems manual dumps may be forced by kill -6 or gcore <pid>[2]. kill -6 <pid> dumps a thread dump.

[edit] Uses of core dumps

Core dumps can serve as useful debugging aids in several situations. On early standalone or batch-processing systems, core dumps allowed a user to debug a program without monopolizing the (very expensive) computing facility for debugging. Besides, a printout was more convenient than debugging using switches and lights. On shared computers, whether time-sharing, batch processing, or server systems, core dumps allow off-line debugging of the operating system, so that the system can be back in operation immediately. Core dumps allow a user to save a crash for later or off-site analysis, or comparison with other crashes. For embedded computers, it may be impractical to support debugging on the computer itself, so a dump can be taken for analysis on a different computer. Some operating systems (such as early versions of Unix) did not support attaching debuggers to running processes, so core dumps were necessary to run a debugger on a process's memory contents. Core dumps can be used to capture data freed during dynamic memory allocation and may thus be used to retrieve information from a program that has exited or been closed. In the absence of an interactive debugger, the core dump may be used by an assiduous programmer to determine the error from direct examination.

A core dump represents the complete contents of the dumped regions of the address space of the dumped process. Depending on the operating system, the dump may contain few or no data structures to aid interpretation of the memory regions. In these systems, successful interpretation requires that the program or user trying to interpret the dump understands the structure of the program's memory use.

A debugger can use a symbol table (if one exists) to help the programmer interpret dumps, identifying variables symbolically and displaying source code; if the symbol table is not available, less interpretation of the dump is possible, but there might still be enough possible to determine the cause of the problem. There are also special-purpose tools called dump analyzers to analyze dumps. One popular tool that is available on almost all operating systems is the GNU Binutils' objdump.

On modern Unix-like operating systems, administrators and programmers can read core dump files using the GNU Binutils Binary File Descriptor library (BFD), and the GNU Debugger (gdb) and objdump that use this library. This library will supply the raw data for a given address in a memory region from a core dump; it does not know anything about variables or data structures in that memory region, so the application using the library to read the core dump will have to determine the addresses of variables and determine the layout of data structures itself, for example by using the symbol table for the program it's debugging.

Core dumps can be used to save the context (state) of a process at a given state for returning to it later. One can make systems highly available systems by transferring core between processors, sometimes via coredump files themselves.

[edit] Core dump files

[edit] Format

In older and simpler operating systems, each process had a contiguous address-space, so a core dump file was simply a binary file with the sequence of bytes or words. In modern operating systems, a process address space may have gaps, and share pages with other processes or files, so more elaborate representations are used; they may also include other information about the state of the program at the time of the dump.

In Unix-like systems, core dumps generally use the standard executable image-format: a.out in older Unixes, ELF in modern Linux, System V, Solaris, and BSD systems, Mach-O in Mac OS X, etc.

[edit] Naming

Dumps of user-processes traditionally get created as core.

System-wide dumps on modern Unix-like systems often appear as vmcore or as vmcore.incomplete.

[edit] References

  1. ^ core(4): Process core file – Solaris 10 Reference Manual Collection, Sun Microsystems Documentation
  2. ^ gcore(1): Get core images of running processes – Solaris 10 Reference Manual Collection, Sun Microsystems Documentation

[edit] See also

[edit] External links

  • "Setting the core dump name schema" "[1]"

Descriptions for the file format:

Personal tools