dumper

dumper [-bFfmnPStvw] [-D path] [-d path] [-N max_files]
       [-p pid] [-s size[G|M|K]]
       [-U user_name | uid[:gid[,sup_gid]*]]]
       [-z level] &

Runs on:

Neutrino

Options:

-b

Attempt to slog a backtrace (libbacktrace.so.1 must be available).

-D path

The same as -d, but without querying authman.

-d path

The directory in which to place dumps, if authman doesn't supply an application sandbox path. The default is the home directory of user that started the process, or /tmp if none.

-F

Run at a fixed priority.

-f

Follow soft links for the creation of the dump files. The use of this option has security implications.

-m

Don't dump memory.

-N max_files

Save sequential dumps, to a maximum of the given number of files. Each dump is saved in a file whose name is in the form:

executable.num.core

where num starts at 1 and increases until the filename doesn't already exist.

-n

Save sequential dumps. Each dump is saved in a file whose name is in the form:

executable.num.core

where num starts at 1 and increases until the filename doesn't already exist.

-S

Disable the dumping of shared memory mappings.

-P

Dump the physical memory mappings.

-p pid

Save a dump file for this process immediately, and then exit dumper.

-s size[G|M|K]

Set the maximum core size, in bytes.

-t

Dump the stack of the errant thread only, instead of for all threads.

-U user_name

-U uid[:gid[,sup_gid]*]]

Once running, run as the specified user, so that the program doesn't need to run as root:

• In the first form, the service sets itself to be the named user and uses that user's groups. This form depends on the /etc/passwd and /etc/group files.
• In the second form, the service sets its user ID, and optionally its group ID and supplementary groups, to the values provided.

-v

Be verbose.

-w

Make core files world-readable.

-z level

Use gzip to compress the core files. The compression level must be in the range from 1 (fastest) through 9 (best compressed).

Description:

The dumper utility runs in the background and provides a postmortem dump service for all processes. Whenever a program terminates abnormally, a dump of the current state of the program is written to disk. The dump filename is the same as the program name with a .core extension. For example, if the program name is experiment, the dump is written to experiment.core in your home directory.

The -p option lets you get a dump immediately for a particular process. If you specify -p, dumper doesn't run in the background, but exits right away.

You can use a debugger such as gdb to examine a dump file:

gdb program_binary program_core 

A program may terminate in one of two ways: it may exit cleanly under its own control, returning an exit status, or it may be forcibly terminated by the receipt of a signal that it isn't prepared to handle. In the latter case, dumper writes a dump file for the following set of signals:

You can force the dump of a running program by setting one of the preceding signals, assuming that the program isn't masking or handling the signal itself.

For example, to force a dump using the kill command and a process ID (pid):

kill -SIGABRT pid

To force a dump using the slay utility and the process name:

slay -s SIGABRT process_name

dumper &

dumper -d /home/dumps &

Files:

/proc/dumper

A special entry in the /proc filesystem (see procnto*) that receives notification when a process terminates abnormally.

Exit status:

The dumper utility normally doesn't terminate. However, it may terminate if it encounters an error on startup (for instance, if it wasn't run by root) or if it receives a signal.

0

A signal was received and dumper shut down successfully.

1

An error was encountered on startup (not run by root or bad command-line options).