pool/kexec-tools
SHA256
2
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

OBS-URL: https://build.opensuse.org/package/show/openSUSE:Factory/kexec-tools?expand=0&rev=33

Browse Source
This commit is contained in:
OBS User unknown 2007-10-11 19:26:22 +00:00 committed by Git OBS Bridge
parent 50c881c484
commit 13dbbcec32
7 changed files with 21 additions and 1467 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

640
README.SUSE
View File

@ -1,636 +1,8 @@
Kdump README for SLES 10
Update note
-----------
Prerequisites
=============
This file formerly documented Kdump. Started with SLES10 SP2 and openSUSE 11.0,
kdump scripts have been moved to an extra package, called "kdump". You now can
find the documentation in /usr/share/doc/packages/kdump/README.
Be sure that you have installed the kexec-tools rpm. For x86, x86-64
and ppc64, install kernel-kdump.rpm, too. The version of the
kernel-kdump rpm must match the version of the running system kernel.
Overview
========
Kdump uses kexec to quickly boot to a recovery kernel whenever a dump of
the system kernel's memory needs to be taken (for example, when the
system panics). The system memory image is preserved across the reboot
and is accessible to the debug kernel. You can use common Linux
commands, such as cp and scp, to copy the memory image to a dump file on
the local host, or across the network to a remote system.
Kdump and kexec are currently supported on the x86, x86_64, and PPC64
architectures.
The system kernel reserves a small section of memory for the capture
kernel at boot time of the system kernel. This ensures that ongoing
Direct Memory Access (DMA) from the system kernel does not corrupt the
capture kernel. The "kexec -p" command loads the capture kernel into
this reserved memory area.
On x86 machines, the first 640 KB of physical memory is needed to boot,
irrespective of where the kernel loads. Therefore, kexec preserves this
region immediately before rebooting into the recovery kernel.
All of the necessary information about the system kernel's core image is
encoded in the ELF format, and stored in a reserved area of memory
before a crash. The physical address of the start of the ELF header is
passed to the recovery kernel through the "elfcorehdr=" boot parameter.
In the capture kernel, you can access the memory image from the system
kernel in two ways:
1) Through a /dev/oldmem device interface. A capture utility can read the
device file and write out the memory in raw format. This is a raw dump
of memory. Analysis and capture tools must be intelligent enough to
determine where to look for the right information.
2) Through /proc/vmcore. This exports the memory dump as an ELF format
file that can be written out using any file copy command such as cp or
scp. Further, you can use analysis tools such as the GNU Debugger (GDB)
or Crash to debug the dump file. This method ensures that the dump pages
are ordered correctly.
Setup of Kdump on SLES 10
=========================
Be sure the prerequisite RPMs are installed.
To enable a crash dump, you need to add an option to the boot loader to
specify the size and offset of the recovery kernel memory area.
An example of this boot loader option is "crashkernel=64M@16M". The 64M
shows the reserved space for the Kdump recovery kernel, and the 16M is
the address of the reserved area. On ia64, the start offset is
calculated by the kernel, so @xxx offset is ignored.
You can add this option either with the YaST boot loader module, or by
manually editing the boot loader configuration file.
The recommended values by architecture for the "crashkernel" option are:
i386: crashkernel=64M@16M
x86_64: crashkernel=64M@16M
ia64: crashkernel=512M (on small machines use 256M)
PPC64: crashkernel=128M@32M
After setting the boot loader option, activate the Kdump init script,
which is not activated by default. To do this, use the YaST System
Services (Runlevel) module. Alternately, enable the service on the
command line with the following command: "/sbin/chkconfig kdump on".
***Warning*** You must activate kdump service permanently via
YaST or chkconfig like above. Starting kdump service temporarily
(e.g. "rckdump start") doesn't suffice. It's because the system
is once rebooted over kexec to another state, and the temporary
activation is abandoned at the kdump boot stage.
After enabling the Kdump init script, reboot the system so that the
Kdump kernel image is loaded properly.
Test your Kdump setup by issuing the following commands as the root
user:
***Warning*** This procedure will crash your system. Shut down all
applications and ensure that no users are logged on before performing
this test.
# sync
# echo u > /proc/sysrq-trigger (remount file systems read-only to
avoid recovery after reboot)
# echo c > /proc/sysrq-trigger
After the system recovers, verify that a vmcore file was generated in
the save dump directory. By default the vmcore file is located in
/var/log/dump/<date-string>.
When a crash occurs, the kernel crash handler starts the second recovery
kernel that the Kdump init script loaded earlier, and reboots the system
using the reserved memory up to the $KDUMP_RUNLEVEL runlevel.
During the boot of the recovery kernel, the Kdump init script loads
again, but this time it dumps the core image for later analysis.
When a crash happens in a graphical environment, you will likely have no
GUI in the second kernel boot. If you used a VGA console, you might
still have visual output from the secondary kernel. The default behavior
of the Kdump script is to save the old vmcore image, and then reboot the
system immediately. You can adjust the behavior of the Kdump script
through sysconfig variables described later in this document.
The Default Dumper
==================
By default, the Kdump script saves the vmcore file to a unique
sub-directory consisting of $KDUMP_SAVEDIR and the date string, such as
/var/log/dump/2006-02-21-13:20/vmcore. This directory can be on the
local machine or on FTP, SSH, NFS or CIFS (see $KDUMP_SAVEDIR below).
If a local directory is used, the default dumper does some system checks
before copying the vmcore file. First, it checks the number of old dump
directories and removes them if there are more than
$KDUMP_KEEP_OLD_DUMPS. Then, the dumper checks the free disk space in
the partition of the dump directory. If the free space is less than the
sum of the memory size and the value given in $KDUMP_FREE_DISK_SIZE,
then the dumper will not create a dump.
$KDUMP_RUNLEVEL specifies the runlevel of the Kdump (recovery) kernel
boot. When $KDUMP_IMMEDIATE_REBOOT is set to yes, then the init script
automatically reboots after saving the vmcore. By default, the dumper
uses KDUMP_RUNLEVEL=1 and KDUMP_IMMEDIATE_REBOOT=yes, in order to reduce
the possible risk of disk corruption in the recovery kernel environment.
If you want Kdump to run more complex jobs than set by the default
dumper configuration, set the name of the appropriate command or script
to be run via $KDUMP_TRANSFER, and change $KDUMP_RUNLEVEL and
$KDUMP_IMMEDIATE_REBOOT.
For example, setting $KDUMP_TRANSFER="scp /proc/vmcore remote:/dump" and
KDUMP_RUNLEVEL=3 will make Kdump act like a netdump. You can set
KDUMP_IMMEDIATE_REBOOT=no to prevent the immediate reboot. This could be
useful to check the system over the network, for example.
Note that the available memory size for the recovery kernel is limited.
Setting KDUMP_RUNLEVEL=5 (graphical login) is not recommended.
Initrd-based Dump Saving
========================
The problem with the procedure mentioned above is that your root file
system (or whatever partition your KDUMP_SAVEDIR is in) may be corrupted.
So the script may not be able to mount the device and is not able to
save your file to disk.
For this, you can configure KDUMP_DUMPDEV to point to an unused partition
that is large enough -- i.e. larger than the system's main memory -- to
hold the dump. Before mounting the root file system, the init script
writes the dump to that device. After rebooting, the normal boot script
saves the dump from that device to KDUMP_SAVEDIR. Because the data was
is saved to disk, you can safely turn off the computer and/or repair
the file system using some tool (for example, you may need to boot from
a CD which is no problem).
After you changed that value, you have to re-run mkinitrd on the kdump
kernel, or on all kernels.
Tuning parameters
=================
You can adjust the basic behavior of the Kdump script by editing the
/etc/sysconfig/kdump file. Edit the script values with the YaST runlevel
System Services editor, or manually edit the /etc/sysconfig/kdump file,
and then restart the kdump service.
Generic options
---------------
- KDUMP_KERNELVER
This is the kernel version string for the Kdump kernel; an example is
"2.6.16-5-kdump". The init script will use a kernel named
/boot/vmlinux-$KDUMP_KERNELVER. The kdump script is located in the
/etc/sysconfig file.
If you do not specify a version, then the init script will try to find a
Kdump kernel with the same version number as the running kernel. Using
the string "kdump" will default to the most recently installed Kdump
kernel (suitable for x86, x86-64 and ppc64). For ia64, keep this
string empty to point the same running kernel.
- KDUMP_COMMANDLINE
This sets the command string to be passed to the Kdump kernel. This will
usually match the contents of the grub kernel line. An example is
KDUMP_COMMANDLINE="ro root=LABEL=/".
If you do not give a command line, then the default will be taken from
/proc/cmdline.
- KDUMP_COMMANDLINE_APPEND
Set this variable if you only want to _append_ values to the default
command line string. The string gets also appended if KDUMP_COMMANDLINE
is set.
- KEXEC_OPTIONS
You can use this to pass additional arguments to kexec. For i386 and
x86-64, you likely need to pass "--args-linux" here.
- KDUMP-RUNLEVEL
This is the runlevel that the Kdump kernel boots to. The default is "1".
To enable network support in the Kdump recovery environment, set this to
"3".
- KDUMP_IMMEDIATE_REBOOT
This option specifies whether to reboot immediately after saving the
core in the Kdump kernel. This option is ignored when KDUMP_DUMPDEV is
set to a non-empty string. The default is "yes".
- KDUMP_TRANSFER
This is an option to execute a script or command to process or transfer
the dump image. It can read the dump image either through /proc/vmcore
or /dev/oldmem. An empty string will use the default dumper.
Options for the Default Dumper
------------------------------
- KDUMP_SAVEDIR
This option specifies the path to the directory where the dumps are
saved. This can be
- a local file, for example "file:///var/log/dump" (or, deprecated,
just "/var/log/dump")
- a FTP server, for example "ftp://user:password@host/var/log/dump"
- a SSH server, for example "ssh://user@host/var/log/dump"
please create a user that needs no password or set up public key
authorization for the root user of the system -- or you have to enter
the password on the serial console as the VGA console may not work!
- a NFS share, for example "nfs://server:/export:/var/log/dump"
- a CIFS (SMB) share, for example
"cifs://user:password@host:/share/var/log/dump"
For the exact URLs, see kdump-url_parser(8) manual page. Or use the
YaST2 kdump module to configure this if you're unsure.
The default is "/var/log/dump". See also KDUMP_DUMPDEV if you
don't want to save the dump at first on a raw device which helps if your
root file system is corrupted.
- KDUMP_DUMPLEVEL
Determines the dump level. If KDUMP_DUMPLEVEL != 0, then makedumpfile
is used to strip pages that may not be necessary for analysing. 0 means
no stripping, and 31 is the maximum dump level, i.e. 0 produces the
largest dump files and 31 the smallest.
The following table from makedumpfile(8) shows what each dump level
means:
dump | zero | cache|cache | user | free
level | page | page |private| data | page
-------+------+------+-------+------+------
0 | | | | |
1 | X | | | |
2 | | X | | |
3 | X | X | | |
4 | | X | X | |
5 | X | X | X | |
6 | | X | X | |
7 | X | X | X | |
8 | | | | X |
9 | X | | | X |
10 | | X | | X |
11 | X | X | | X |
12 | | X | X | X |
13 | X | X | X | X |
14 | | X | X | X |
15 | X | X | X | X |
16 | | | | | X
17 | X | | | | X
18 | | X | | | X
19 | X | X | | | X
20 | | X | X | | X
21 | X | X | X | | X
22 | | X | X | | X
23 | X | X | X | | X
24 | | | | X | X
25 | X | | | X | X
26 | | X | | X | X
27 | X | X | | X | X
28 | | X | X | X | X
29 | X | X | X | X | X
30 | | X | X | X | X
31 | X | X | X | X | X
- KDUMP_DUMPFORMAT
This variable specifies the dump format.
"ELF" has the advantage that it's a standard format and GDB can be used to
analyze the dumps. The disadvantage is that the dump files are larger.
"compressed" is the kdump compressed format (see makedumpfile(8)) that
produces small dumps. However, only "crash" can analyse the dumps and
you need makedumpfile to have installed (but you need it anyway if you
set KDUMP_DUMPLEVEL != 0 before).
- KDUMP_DUMPDEV
Specifies the dump device that is used for saving the dump with the kdump
kernel. The dump device normally is a disk partition. You don't need to
specify a dump device here. Then the dump is written to KDUMP_SAVEDIR when
booting from the kdump kernel.
If KDUMP_DUMPDEV points to a device file, the dump is written to that device
when running the kdump kernel. The advantage over writing the dump to
disk immediately is that you don't have to mount the root file system (which
may be corrupted!) just to write the dump. So if the root file system is
corrupted, you have the chance to fix the file system manually and reboot the
system without loosing the dump information. On the first normal boot which
is able to successfully mount the root file system, the dump is saved to
KDUMP_SAVEDIR as usual.
Important: The KDUMP_DUMPDEV is overwritten by kdump, so don't use it for
saving any data. Also don't use the currently used swap partition.
- KDUMP_KEEP_OLD_DUMPS
This option specifies how many previous dumps are kept. If the number of
saved dump files exceeds this number, the dumper removes older dumps.
You can prevent automatic removal by setting this to "0" (zero).
Set KDUMP_KEEP_OLD_DUMPS to "-2" is you want to delete all old dumps
before saving the new dump. The default value is "5".
- KDUMP_FREE_DISK_SIZE
This specifies the minimum free disk space in megabytes of the dump
partition. If the free disk space is less than the sum of this value and
the memory size, then the default dumper will not save the vmcore file
in order to prevent disk corruption. Setting this option to "0" (zero)
forces the dumper to dump without checking the size. The default value
is "64".
- KDUMP_VERBOSE
Determines if kdump uses verbose output. This value is a bitmask:
1: kdump command line is written to system log when executing
/etc/init.d/kdump
2: progress is written to stdout while dumping
4: kdump command line is written so standard output when executing
/etc/init.d/kdump
8: Debugging for kdump transfer script
Machine-specific Notes
======================
- IA64
o On SGI SN2 machines, the kdump doesn't work when the VGA console
is active. To disable the VGA console execute following commands
in the EFI shell
Shell> set NoVGA 1
Shell> reset
Dump Triggering Methods
=======================
This section talks about the various ways, other than a Kernel Panic,
in which Kdump can be triggered. These methods will enable the user
to invoke Kdump in cases where the system is experiencing a hard
hang.
1) AltSysRq C
On i386 and x86_64 machines, Kdump can be triggered with the
combination of the 'Alt','SysRq' and 'C' keyboard keys. This method
will work only on directly attached consoles, and not on remote
consoles. In cases where the machine is in a hung state with
interrupts disabled, AltSysRq C cannot be used. If any kind of
terminal access is still possible, the same result may be achieved
from the shell command line like so:
# echo c > /proc/sysrq-trigger
On PowerPC boxes also AltSysrq C can be used to initiate Kdump if a
directly attached console is available. In addition, Kdump can also
be triggered via Hardware Management Console(HMC) using 'Ctrl', 'O'
and 'C' keyboard keys. Inorder to use the Sysrq method for dump
triggering /proc/sys/kernel/sysrq needs to be enabled, which can be
done as follows:
# echo 1 > /proc/sys/kernel/sysrq
2) Kernel OOPs
If we want to generate a dump everytime the Kernel OOPses, we can
achieve this by setting the 'Panic On OOPs' option as follows:
# echo 1 > /proc/sys/kernel/panic_on_oops
3) NMI(Non maskable interrupt) button
In cases where the system is in a hung state, and is not accepting
keyboard interrupts, using NMI button for triggering Kdump can be very
useful. NMI button is present on most of the newer x86 and x86_64
machines. Please refer to the User guides/manuals to locate the
button, though in most occasions it is not very well documented. In
most cases it is hidden behind a small hole on the front or back panel
of the machine. You could use a toothpick or some other
non-conducting probe to press the button.
For example, on the IBM X series 366 machine, the NMI button is
located behind a small hole on the bottom center of the rear panel.
To enable this method of dump triggering using NMI button, you will
need to set the 'unknown_nmi_panic' option as follows:
# echo 1 > /proc/sys/kernel/unknown_nmi_panic
When enabling unknown_nmi_panic please be careful not to enable Nmi
Watchdog feature, else the system will panic.
4) NMI WATCHDOG
Nmi watchdog is a feature available in the x86 and x86_64 kernels
which uses NMI to monitor whether a CPU has locked up. On i386
machines, nmi watchdog can be enabled by passing nmi_watchdog=1 in the
commandline of the kernel. On x86_64 machines, this is enabled by
default. To verify if your system has been configured with nmi
watchdog, look at the NMI entry in /proc/interrupts. If the count is
greater than zero then nmi watchdog has been confgured, else it is
not.
Please refer to Documentation/nmi_watchdog.txt in the kernel source
for a more detailed description.
Once this feature has been enabled in the kernel, any lockups will
result in an OOPs message to be generated, followed by Kdump being
triggered. This also requires 'Panic On OOPs' to be enabled as
explained in method 2 above.
Please refrain from simultaneously enabling 'nmi_watchdog' and setting
/proc/sys/kernel/unknown_nmi_panic, as this would result in a Kernel
Panic from legitimate NMIs generated by the nmi_watchdog.
5) PowerPC specific methods:
On IBM PowerPC machines, the following methods to issue a soft reset
can be used to trigger Kdump. On SLES10 systems, XMON(debugger) is
turned off by default. If the user wishes to enable XMON, he can do
so by booting the kernel with 'xmon=on' option. With XMON enabled,
issuing a soft reset will drop the user to the XMON prompt, where
typing a 'X' will trigger Kdump. If XMON is not enabled then a soft
reset will directly trigger Kdump.
5.1) HMC
Hardware Management Console(HMC) available on Power4 and Power5
machines allow partitions to be reset remotely. This is specially
useful in hang situations where the system is not accepting any
keyboard inputs.
Once you have HMC configured, the following steps will enable you to
trigger Kdump via a soft reset:
On Power4
Using GUI
* In the right pane, right click on the partition you wish to
dump.
* Select "Operating System->Reset".
* Select "Soft Reset".
* Select "Yes".
Using HMC Commandline
# reset_partition -m <machine> -p <partition> -t soft
On Power5
Using GUI
* In the right pane, right click on the partition you wish to
dump.
* Select "Restart Partition".
* Select "Dump".
* Select "OK".
Using HMC Commandline
# chsysstate -m <managed system name> -n <lpar name> -o dumprestart -r lpar
5.2) Blade Management Console for Blade Center
To initiate a dump operation, go to Power/Restart option under "Blade
Tasks" in the Blade Management Console. Select the corresponding
blade for which you want to initate the dump and then click "Restart
blade with NMI". This will issue a soft reset.
5.3) Control Panel function for a standalone Power5 machine
A standalone machine is one which does not have any LPARs configured
and also does not have a HMC available. In such cases the Control
Panel, usually located on the front panel of the machine (please refer
to the User guide of the specific model for details) can be used for
dump triggering in case the system has a hard hang.
The control panel provides many functions for System Management
purposes; Function 22 is meant for invoking a Partition dump. This
function is available only in the Manual operating mode.
To check if the system is operating in manual mode,
* Select function 1 on the panel
* Press enter
* Read the Operating mode from the panel display
* If it is not 'M', then use function 2 to set it (see below)
To set manual mode:
* Select function 2 on the panel
* Press enter
* The current OS IPL type is displayed with a pointer
* Press enter to move to the Operating mode
* Use increment, decrement buttons to change the mode to M
* Press enter
To trigger the dump:
* Select function 22 on the panel
* Press enter
* Select function 22 on the panel
* Press enter
Invoking function 22 twice will issue a soft reset to the machine.
Dump Analysis
=============
Dump analysis can be performed using GDB or the Crash utility. The Crash
utility is included in the crash RPM package. You must install a
debug-info kernel matching the version of the system kernel (of the
system where the dump was collected) on the system where the analysis is
to be performed. The debug-info kernel provides symbol and type
information that Crash and GDB use. You can find kernel debug
information RPMs on the SUSE support Web site. Alternately, you can
build a debug-info kernel from source by specifying the
CONFIG_DEBUG_INFO kernel parameter.
Even if you install kernel-debuginfo, you need to uncompress the kernel
image first. This depends on the architecture on which your system is
running. If you don't know, just run "uname -i" to get the architecture.
On i586, i686 and x86_64, s390 and s390x, you have to unpack the kernel
image:
$ gunzip /boot/vmlinux-<version>.gz
On IA64, the default kernel image is already a gzip'ed vmlinux image.
Run
$ zcat /boot/vmlinuz-<version> > /boot/vmlinux-<version>
On PPC and PPC64, you don't have do to anything as there the bootloader
already loads the vmlinux image.
The symbol information in the debug-info kernel may differ from the
running kernel, therefor; when running crash against a vmcore you
should specify both the System.map file and the debug-info kernel.
For example, to run crash against a vmcore use the following command
line:
$ crash /boot/System.map-version /boot/vmlinux-version vmcore
Where:
/boot/System.map-<version> -- The map file matching the kernel
being analyzed.
/boot/vmlinux-<version> -- The matching kernel.
vmcore -- The crash dump.
GDB Helper Script
=================
The GDB-kdump script is provided to simplify use of GDB on dump images.
The usage is "gdb-kdump [vmcore]".
The argument is the vmcore dump image to analyze. If you do not give an
argument, then the latest dump image will be taken. The script starts
GDB with the vmlinux of the currently running kernel. The script assumes
that the vmlinux file is at /boot/vmlinux-$kernel. If the script finds
only a gzip-compressed file, the file is automatically uncompressed.
Note that you will need to supply kernel-versionnumber-debuginfo, with
debug symbols. GDB-kdump also reads some useful macros for the Kdump
image, originally provided in /usr/src/linux/Documentation/kdump, at
startup. The following macros then become available: bttnobp, btt,
btpid, trapinfo, and dmesg. See the help topic of each command in GDB
for details.
And remember to have a lot of fun ...

65
gdb-kdump
View File

@ -1,65 +0,0 @@
#!/bin/sh
#
# Start gdb for kdump crash analysis
#
# Usage: gdb-kdump [-v vmlinux] [vmcore [gdb options...]]
#
# The script starts gdb using the currently running kernel image
# and the appopriate crash dump file. If the kernel image is
# compressed, it's decompressed automatically.
#
# When no arugment is given, the latest crash dump file is probed.
#
# The script also passes the gdb macros useful for analysis of crash
# dump.
. /etc/sysconfig/kdump
bootdir="/boot"
if [ "$1" = "-v" ]; then
vmlinux="$2"
if [ ! -f "$vmlinux" ]; then
echo "Cannot find vmlinux file $vmlinux, aborting"
exit 1
fi
shift 2
else
vmlinux="$bootdir"/vmlinux-`uname -r`
if [ ! -f $vmlinux ]; then
if [ -f "$bootdir/vmlinux" ]; then
vmlinux="$bootdir/vmlinux"
elif [ -f $vmlinux.gz ]; then
if gunzip $vmlinux.gz; then
echo "Uncompressed $vmlinux.gz"
else
echo "Cannot uncompress $vmlinux.gz, aborting"
exit 1
fi
else
echo "No useful vmlinux is found in $bootdir"
exit 1
fi
fi
fi
echo "Using $vmlinux as vmlinux"
if [ -n "$1" ]; then
if [ -f "$1" ]; then
dumpfile="$1"
shift
else
echo "Dumpfile $1 cannot be found"
exit 1
fi
else
dumpfile=`ls $KDUMP_SAVEDIR/*-*-*-*:*/vmcore 2>/dev/null | sort -r | head -n 1`
if [ -n "$dumpfile" -a -f "$dumpfile" ]; then
echo "Using $dumpfile as dumpfile"
else
echo "Cannot find the latest dumpfile"
exit 1
fi
fi
exec /usr/bin/gdb --command=/usr/share/gdbinit.kdump $vmlinux $dumpfile $*

201
gdbinit.kdump
View File

@ -1,201 +0,0 @@
#
# This file contains a few gdb macros (user defined commands) to extract
# useful information from kernel crashdump (kdump) like stack traces of
# all the processes or a particular process and trapinfo.
#
# These macros can be used by copying this file in .gdbinit (put in home
# directory or current directory) or by invoking gdb command with
# --command=<command-file-name> option
#
# Credits:
# Alexander Nyberg <alexn@telia.com>
# V Srivatsa <vatsa@in.ibm.com>
# Maneesh Soni <maneesh@in.ibm.com>
#
define bttnobp
set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
set $pid_off=((size_t)&((struct task_struct *)0)->pids[1].pid_list.next)
set $init_t=&init_task
set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
while ($next_t != $init_t)
set $next_t=(struct task_struct *)$next_t
printf "\npid %d; comm %s:\n", $next_t.pid, $next_t.comm
printf "===================\n"
set var $stackp = $next_t.thread.esp
set var $stack_top = ($stackp & ~4095) + 4096
while ($stackp < $stack_top)
if (*($stackp) > _stext && *($stackp) < _sinittext)
info symbol *($stackp)
end
set $stackp += 4
end
set $next_th=(((char *)$next_t->pids[1].pid_list.next) - $pid_off)
while ($next_th != $next_t)
set $next_th=(struct task_struct *)$next_th
printf "\npid %d; comm %s:\n", $next_t.pid, $next_t.comm
printf "===================\n"
set var $stackp = $next_t.thread.esp
set var $stack_top = ($stackp & ~4095) + 4096
while ($stackp < $stack_top)
if (*($stackp) > _stext && *($stackp) < _sinittext)
info symbol *($stackp)
end
set $stackp += 4
end
set $next_th=(((char *)$next_th->pids[1].pid_list.next) - $pid_off)
end
set $next_t=(char *)($next_t->tasks.next) - $tasks_off
end
end
document bttnobp
dump all thread stack traces on a kernel compiled with !CONFIG_FRAME_POINTER
end
define btt
set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
set $pid_off=((size_t)&((struct task_struct *)0)->pids[1].pid_list.next)
set $init_t=&init_task
set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
while ($next_t != $init_t)
set $next_t=(struct task_struct *)$next_t
printf "\npid %d; comm %s:\n", $next_t.pid, $next_t.comm
printf "===================\n"
set var $stackp = $next_t.thread.esp
set var $stack_top = ($stackp & ~4095) + 4096
set var $stack_bot = ($stackp & ~4095)
set $stackp = *($stackp)
while (($stackp < $stack_top) && ($stackp > $stack_bot))
set var $addr = *($stackp + 4)
info symbol $addr
set $stackp = *($stackp)
end
set $next_th=(((char *)$next_t->pids[1].pid_list.next) - $pid_off)
while ($next_th != $next_t)
set $next_th=(struct task_struct *)$next_th
printf "\npid %d; comm %s:\n", $next_t.pid, $next_t.comm
printf "===================\n"
set var $stackp = $next_t.thread.esp
set var $stack_top = ($stackp & ~4095) + 4096
set var $stack_bot = ($stackp & ~4095)
set $stackp = *($stackp)
while (($stackp < $stack_top) && ($stackp > $stack_bot))
set var $addr = *($stackp + 4)
info symbol $addr
set $stackp = *($stackp)
end
set $next_th=(((char *)$next_th->pids[1].pid_list.next) - $pid_off)
end
set $next_t=(char *)($next_t->tasks.next) - $tasks_off
end
end
document btt
dump all thread stack traces on a kernel compiled with CONFIG_FRAME_POINTER
end
define btpid
set var $pid = $arg0
set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
set $pid_off=((size_t)&((struct task_struct *)0)->pids[1].pid_list.next)
set $init_t=&init_task
set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
set var $pid_task = 0
while ($next_t != $init_t)
set $next_t=(struct task_struct *)$next_t
if ($next_t.pid == $pid)
set $pid_task = $next_t
end
set $next_th=(((char *)$next_t->pids[1].pid_list.next) - $pid_off)
while ($next_th != $next_t)
set $next_th=(struct task_struct *)$next_th
if ($next_th.pid == $pid)
set $pid_task = $next_th
end
set $next_th=(((char *)$next_th->pids[1].pid_list.next) - $pid_off)
end
set $next_t=(char *)($next_t->tasks.next) - $tasks_off
end
printf "\npid %d; comm %s:\n", $pid_task.pid, $pid_task.comm
printf "===================\n"
set var $stackp = $pid_task.thread.esp
set var $stack_top = ($stackp & ~4095) + 4096
set var $stack_bot = ($stackp & ~4095)
set $stackp = *($stackp)
while (($stackp < $stack_top) && ($stackp > $stack_bot))
set var $addr = *($stackp + 4)
info symbol $addr
set $stackp = *($stackp)
end
end
document btpid
backtrace of pid
end
define trapinfo
set var $pid = $arg0
set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
set $pid_off=((size_t)&((struct task_struct *)0)->pids[1].pid_list.next)
set $init_t=&init_task
set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
set var $pid_task = 0
while ($next_t != $init_t)
set $next_t=(struct task_struct *)$next_t
if ($next_t.pid == $pid)
set $pid_task = $next_t
end
set $next_th=(((char *)$next_t->pids[1].pid_list.next) - $pid_off)
while ($next_th != $next_t)
set $next_th=(struct task_struct *)$next_th
if ($next_th.pid == $pid)
set $pid_task = $next_th
end
set $next_th=(((char *)$next_th->pids[1].pid_list.next) - $pid_off)
end
set $next_t=(char *)($next_t->tasks.next) - $tasks_off
end
printf "Trapno %ld, cr2 0x%lx, error_code %ld\n", $pid_task.thread.trap_no, \
$pid_task.thread.cr2, $pid_task.thread.error_code
end
document trapinfo
Run info threads and lookup pid of thread #1
'trapinfo <pid>' will tell you by which trap & possibly
addresthe kernel paniced.
end
define dmesg
set $i = 0
set $end_idx = (log_end - 1) & (log_buf_len - 1)
while ($i < logged_chars)
set $idx = (log_end - 1 - logged_chars + $i) & (log_buf_len - 1)
if ($idx + 100 <= $end_idx) || \
($end_idx <= $idx && $idx + 100 < log_buf_len)
printf "%.100s", &log_buf[$idx]
set $i = $i + 100
else
printf "%c", log_buf[$idx]
set $i = $i + 1
end
end
end
document dmesg
print the kernel ring buffer
end

285
kdump
View File

@ -1,285 +0,0 @@
#! /bin/sh
#
# Copyright 2005 Red Hat, Inc.
# Author: Jeff Moyer <jmoyer@redhat.com>
# Modifications for SUSE from Chris Mason <mason@suse.com>
# Takashi Iwai <tiwai@suse.de>
#
# kdump
#
# Description: The kdump init script provides the support necessary for
# loading a kdump kernel into memory at system bootup time,
# and for copying away a vmcore at system panic time.
#
#
# /etc/init.d/kexec
### BEGIN INIT INFO
# Provides: kdump
# Required-Start: boot.localfs $remote_fs
# Should-Start:
# Required-Stop:
# Default-Start: 1 2 3 5
# Default-Stop:
# Short-Description: kdump core saving and boot configuration
# Description: kdump core saving and boot configuration
### END INIT INFO
. /etc/sysconfig/kdump
. /etc/rc.status
KEXEC=/sbin/kexec
KDUMP_HELPER=/usr/sbin/kdump-helper
KDUMP_CLEANUP_DUMPS=/usr/sbin/kdump-cleanup_dumps
KDUMP_SAVE_DUMP=/usr/sbin/kdump-save_dump
KDUMP_IDENTIFY_KERNEL=/usr/sbin/kdump-identify_kernel
BOOTDIR="/boot"
# The default dumper
#
# Clean up old stuff if necessary, check the free size
# and save the vmcore
save_core()
{
$KDUMP_CLEANUP_DUMPS
if [ "$?" -ne 0 ] ; then
rc_status -v
return 1
fi
$KDUMP_SAVE_DUMP /proc/vmcore
rc_status -v
return 0
}
# print the available kdump kernel path
# empty if no matching file is found
check_boot_kernel ()
{
local kstr
# if the kernel is relocatable, try vmlinuz first because
# currently there are bugs with relocatable ELF-Images
# (ET_DYN => GDB doesn't work / ET_EXEC => kexec-tools doesn't
# detect)
case `uname -i` in
x86_64|i386)
kstr="${BOOTDIR}/vmlinuz-$1$2"
if [ -f $kstr ] ; then
if $KDUMP_IDENTIFY_KERNEL -r $kstr &>/dev/null ; then
echo $kstr
return
fi
fi
esac
kstr="${BOOTDIR}/vmlinux-$1$2"
if [ -f $kstr ]; then
echo $kstr
return
fi
kstr="$kstr.gz"
if [ -f $kstr ]; then
echo $kstr
return
fi
case `uname -i` in
ia64)
# ia64 uses vmlinuz as of vmlinux.gz
kstr="${BOOTDIR}/vmlinuz-$1$2"
if [ -f $kstr ]; then
echo $kstr
return
fi
;;
esac
}
# Load the kdump kerel specified in /etc/sysconfig/kdump
# If none is specified, try to load a kdump kernel with the same version
# as the currently running kernel.
load_kdump()
{
echo -n "Loading kdump "
if [ -z "$KDUMP_KERNELVER" ]; then
kdump_kver=`uname -r | sed -e's/-[^-]*$//g'`
kdump_kernel=`check_boot_kernel $kdump_kver -kdump`
if [ -n "$kdump_kernel" ]; then
kdump_kver="${kdump_kver}-kdump"
elif [ -z "$kdump_kernel" ]; then
kdump_kver=`uname -r`
kdump_kernel=`check_boot_kernel $kdump_kver`
fi
else
kdump_kver="$KDUMP_KERNELVER"
kdump_kernel=`check_boot_kernel $kdump_kver`
fi
if [ -z "$kdump_kernel" -o ! -f "$kdump_kernel" ]; then
echo -n ": No kdump kernel image found for kernel $kdump_kver."
rc_status -s
rc_failed 6
rc_exit
fi
kdump_initrd="${BOOTDIR}/initrd-${kdump_kver}"
if [ ! -f $kdump_initrd ]; then
echo -n ": No kdump initial ramdisk found."
echo "Tried to locate ${kdump_initrd}"
rc_status -s
rc_failed 6
rc_exit
fi
if [ -z "$KDUMP_COMMANDLINE" ]; then
KDUMP_COMMANDLINE=`cat /proc/cmdline | \
sed -e 's/crashkernel=[0-9]\+[mM]\(@[0-9]\+[Mm]\?\)\?//g' \
-e 's/ *splash=[^ ]*/ /g' \
-e 's/ *BOOT_IMAGE=[^ ]* / /g' \
-e 's/ *showopts/ /g'`
# Use deadline for saving the memory footprint
KDUMP_COMMANDLINE="$KDUMP_COMMANDLINE elevator=deadline sysrq=1 reset_devices"
case `uname -i` in
i?86|x86_64|ia64)
KDUMP_COMMANDLINE="$KDUMP_COMMANDLINE irqpoll"
;;
esac
fi
KDUMP_COMMANDLINE="CRASH=1 $KDUMP_COMMANDLINE"
if [ -n "$KDUMP_COMMANDLINE_APPEND" ] ; then
KDUMP_COMMANDLINE="$KDUMP_COMMANDLINE $KDUMP_COMMANDLINE_APPEND"
fi
if [ -n "$KDUMP_RUNLEVEL" ]; then
case "$KDUMP_RUNLEVEL" in
[1-5s])
KDUMP_COMMANDLINE="$KDUMP_COMMANDLINE $KDUMP_RUNLEVEL"
;;
*)
echo " : Invalid KDUMP_RUNLEVEL=$KDUMP_RUNLEVEL, ignored"
;;
esac
fi
# add the dump device
if [ -n "$KDUMP_DUMPDEV" ] ; then
KDUMP_COMMANDLINE="dumpdev=$KDUMP_DUMPDEV $KDUMP_COMMANDLINE"
fi
echo 1 > /proc/sys/kernel/panic_on_oops
# remove `--args-linux' for x86 type kernel files here
if [ "$($KDUMP_IDENTIFY_KERNEL -t $kdump_kernel)" = "x86" ] ; then
KEXEC_OPTIONS=$(echo $KEXEC_OPTIONS | sed -e 's/--args-linux//g')
fi
KEXEC_CALL="$KEXEC -p $kdump_kernel --append=\"$KDUMP_COMMANDLINE\""
KEXEC_CALL="$KEXEC_CALL --initrd=$kdump_initrd $KEXEC_OPTIONS"
if [ $(($KDUMP_VERBOSE & 1)) -gt 0 ] ; then
logger -i -t kdump "Loading kdump kernel: $KEXEC_CALL"
fi
if [ $(($KDUMP_VERBOSE & 4)) -gt 0 ] ; then
echo "Loading kdump kernel: $KEXEC_CALL"
fi
eval "$KEXEC_CALL"
rc_status -v
}
# return success if running in a crash environemnt
is_crash_kernel ()
{
test -f /proc/vmcore || return 1
# FIXME: any better way to detect crash environment?
test -n "$CRASH" && return 0
grep -q elfcorehdr= /proc/cmdline && return 0
return 1
}
# return success if we have a valid dump on the dump device
have_valid_dump_in_dumpdev ()
{
if [ ! -b "$KDUMP_DUMPDEV" ] ; then
return 1
fi
# return the return code from this command
$KDUMP_HELPER -c "$KDUMP_DUMPDEV" >> /dev/null
}
# invalidate the dump device so that it's not read on next boot
invalidate_dumpdev ()
{
dd if=/dev/zero of=$KDUMP_DUMPDEV bs=512 count=1 &>/dev/null
}
case "$1" in
start)
if is_crash_kernel; then
if [ -z "$KDUMP_DUMPDEV" ] ; then
if [ -n "$KDUMP_TRANSFER" ]; then
$KDUMP_TRANSFER
else
save_core
fi
fi
if test "$KDUMP_IMMEDIATE_REBOOT" = "yes"; then
/sbin/reboot
# sleep to avoid the conflict with script "single"
sleep 600
fi
else
if have_valid_dump_in_dumpdev ; then
$KDUMP_SAVE_DUMP $KDUMP_DUMPDEV
rc_status -v
if [ "$?" -eq 0 ] ; then
invalidate_dumpdev
rc_status
fi
fi
load_kdump
fi
;;
stop)
if ! is_crash_kernel ; then
if [ "$RUNLEVEL" != "" ]; then
echo -n "Not unloading kdump during runlevel changes"
rc_status -s
else
echo -n "Unloading kdump"
$KEXEC -p -u
rc_status -v
fi
fi
;;
status)
if [ -r /sys/kernel/kexec_crash_loaded ]; then
if [ "$(cat /sys/kernel/kexec_crash_loaded)" = "1" ]; then
echo "kdump kernel loaded"
else
echo "kdump kernel not loaded"
fi
else
echo "not implemented"
fi
;;
restart|reload)
$0 stop
$0 start
;;
condrestart)
;;
*)
echo $"Usage: $0 {start|stop|status|restart|reload}"
exit 1
esac
exit $?
# vim: set ts=8 sw=4 sts=4 noet:

6
kexec-tools.changes
View File

@ -1,3 +1,9 @@
-------------------------------------------------------------------
Thu Oct 11 16:48:58 CEST 2007 - bwalle@suse.de
- remove kdump stuff from this package, that's now in the "kexec"
package
-------------------------------------------------------------------
Wed Aug 29 15:23:58 CEST 2007 - bwalle@suse.de

66
kexec-tools.spec
View File

@ -19,22 +19,15 @@ BuildRequires: gcc42-64bit glibc-devel-64bit
License: GPL v2 or later
Group: System/Kernel
Requires: %insserv_prereq %fillup_prereq
Autoreqprov: on
AutoReqProv: on
Summary: Tools for fast kernel loading
Version: 1.101
Release: 134
Release: 141
Source: %{name}-%{package_version}.tar.bz2
Source1: kdump
Source2: sysconfig.kdump
Source3: gdbinit.kdump
Source4: gdb-kdump
Source5: README.SUSE
URL: http://www.vergenet.net/linux/kexec/kexec-tools/
Source1: README.SUSE
Url: http://www.vergenet.net/linux/kexec/kexec-tools/
BuildRoot: %{_tmppath}/%{name}-%{version}-build
BuildRequires: zlib-devel
%ifnarch s390 s390x
Requires: kdump-helpers
%endif
Patch1: kexec-longer-cmdline.diff
Patch2: kexec-tools.check_reuse_initrd-close.patch
Patch20: kexec-tools.ppc64-32bit-build.patch
@ -69,7 +62,7 @@ Authors:
%build
%{?suse_update_config -f}
cp %{SOURCE5} .
cp %{SOURCE1} .
autoreconf -fi
./configure \
--prefix=/ \
@ -87,63 +80,22 @@ make CPPFLAGS="$RPM_OPT_FLAGS"
make DESTDIR=$RPM_BUILD_ROOT install
mkdir -p $RPM_BUILD_ROOT%{_mandir}/man8
install -c -m 0644 kexec/kexec.8 $RPM_BUILD_ROOT%{_mandir}/man8
mkdir -p $RPM_BUILD_ROOT/etc/init.d
install -c -m 0755 %{SOURCE1} $RPM_BUILD_ROOT/etc/init.d
mkdir -p $RPM_BUILD_ROOT/sbin
ln -s /etc/init.d/kdump $RPM_BUILD_ROOT/sbin/rckdump
mkdir -p $RPM_BUILD_ROOT/var/adm/fillup-templates
install -c -m 0644 %{SOURCE2} $RPM_BUILD_ROOT/var/adm/fillup-templates/sysconfig.kdump
%ifarch %ix86 x86_64
# add --args-linux kexec command line option as default
sed -i 's@^\(KEXEC_OPTIONS="\)\(.*"[[:blank:]]*$\)@\1--args-linux \2@' $RPM_BUILD_ROOT/var/adm/fillup-templates/sysconfig.kdump
%endif
%ifarch x86_64 i386 ia64
# empty KDUMP_KERNELVER since we have no special kdump kernel on that archs
sed -i -e 's@^\(KDUMP_KERNELVER=\).*$@\1""@' \
-e 's@^\(KDUMP_COMMANDLINE_APPEND="\)\(.*"[[:blank:]]*$\)@\1maxcpus=1 \2@' \
$RPM_BUILD_ROOT/var/adm/fillup-templates/sysconfig.kdump
%endif
%ifarch ia64
# add --noio since kexec is broken without --noio on most machines
sed -i -e 's@^\(KEXEC_OPTIONS="\)\(.*"[[:blank:]]*$\)@\1--noio \2@' \
$RPM_BUILD_ROOT/var/adm/fillup-templates/sysconfig.kdump
%endif
# install gdb helpers
mkdir -p $RPM_BUILD_ROOT%{_datadir}
mkdir -p $RPM_BUILD_ROOT%{_bindir}
install -c -m 0644 %{SOURCE3} $RPM_BUILD_ROOT%{_datadir}
install -c -m 0755 %{SOURCE4} $RPM_BUILD_ROOT%{_bindir}
%post
%{fillup_and_insserv -n kdump kdump}
%preun
echo "Stopping kexec ..."
%stop_on_removal kdump
true # ignore errors
%postun
%restart_on_update kdump
%insserv_cleanup
%clean
[ "$RPM_BUILD_ROOT" != "/" ] && rm -rf $RPM_BUILD_ROOT
%files
%defattr(-, root, root)
%doc AUTHORS COPYING News TODO doc
%doc README.SUSE
%doc AUTHORS COPYING News TODO doc README.SUSE
%doc %{_mandir}/man*/*
/sbin/*
%{_bindir}/*
%{_datadir}/gdbinit.*
%ifarch %ix86 x86_64
/%_lib/kexec-tools*
%endif
/etc/init.d/kdump
/var/adm/fillup-templates/sysconfig.kdump
%changelog
* Thu Oct 11 2007 - bwalle@suse.de
- remove kdump stuff from this package, that's now in the "kexec"
package
* Wed Aug 29 2007 - bwalle@suse.de
- add reset_devices kernel parameter as default
* Sat Aug 25 2007 - olh@suse.de

225
sysconfig.kdump
View File

@ -1,225 +0,0 @@
## Path: System/Kernel/Kdump
## Description: Crash Dump Configuration
## Type: string
## Default: "kdump"
## ServiceRestart: kdump
#
# Kernel Version string for the -kdump kernel, such as 2.6.16-5-kdump
# If no version is specified, then the init script will try to find a
# kdump kernel with the same version number as the running kernel.
# The init script will use a kernel named:
# /boot/vmlinux-$KDUMP_KERNELVER
# Using "kdump" will default to the most recently installed kdump kernel.
#
KDUMP_KERNELVER="kdump"
## Type: string
## Default: ""
## ServiceRestart: kdump
#
# The kdump commandline is the command line that needs to be passed off to
# the kdump kernel. This will likely match the contents of the grub kernel
# line. For example:
# KDUMP_COMMANDLINE="ro root=LABEL=/"
# If a command line is not specified, the default will be taken from
# /proc/cmdline
#
KDUMP_COMMANDLINE=""
## Type: string
## Default: ""
## ServiceRestart: kdump
#
# Set this variable if you only want to _append_ values to the default
# command line string. The string gets also appended if KDUMP_COMMANDLINE
# is set.
#
KDUMP_COMMANDLINE_APPEND=""
## Type: string
## Default: ""
## ServiceRestart: kdump
#
# Additional arguments passed to kexec. For example, to generate
# ELF32 dump on x86-64 to allow i386 systems to read dump, set
# "--elf32-core-headers" here.
#
# Keep this empty in most cases.
#
KEXEC_OPTIONS=""
## Type: list(1,2,3,5,s)
## Default: 1
## ServiceRestart: kdump
#
# The run-level to boot the kdump kernel. The default is "1".
# If you need networks in the kdump environment, set "3".
#
KDUMP_RUNLEVEL="1"
## Type: yesno
## Default: yes
#
# Immediately reboot after saving the core in the kdump kernel?
# This option is ignored when KDUMP_DUMPDEV is set to a non-empty
# value. Use "yes" or "no". Default is "yes".
#
KDUMP_IMMEDIATE_REBOOT="yes"
## Type: string
## Default: ""
#
# A script or command executed to process and transfer the dump image.
# It can read the dump image either via /proc/vmcore or /dev/oldmem.
#
# Keeping this empty will use the default dumper, which copies the vmcore
# file to $KDUMP_SAVEDIR with some system checks.
#
KDUMP_TRANSFER=""
## Type: string
## Default: "file:///var/log/dump"
#
# Which directory should the dumps be saved in by the default dumper?
# This can be:
#
# - a local file, for example "file:///var/log/dump" (or, deprecated,
# just "/var/log/dump")
# - a FTP server, for example "ftp://user:password@host/var/log/dump"
# - a SSH server, for example "ssh://user@host/var/log/dump"
# please create a user that needs no password or set up public key
# authorization for the root user of the system -- or you have to enter
# the password on the serial console as the VGA console may not work!
# - a NFS share, for example "nfs://server:/export:/var/log/dump"
# - a CIFS (SMB) share, for example
# "cifs://user:password@host:/share/var/log/dump"
#
# For the exact URLs, see kdump-url_parser(8) manual page. Or use the
# YaST2 kdump module to configure this if you're unsure.
KDUMP_SAVEDIR="file:///var/log/dump"
## Type: integer
## Default: 5
#
# Specifies how many old dumps are kept. If the number of dump files
# exceeds this number, older dumps are removed.
#
# You can prevent the automatic removal by setting zero to this.
# Set KDUMP_KEEP_OLD_DUMPS to "-2" is you want to delete all old
# dumps before saving the new dump.
#
# The default value is 5.
#
KDUMP_KEEP_OLD_DUMPS=5
## Type: integer
## Default: 64
#
# Specifies the minimal free disk space (in MB unit) on the dump
# partition. If the free disk space is less than the sum of this
# value and memory size, the default dumper won't save vmcore file
# in order to keep the system sane.
#
# Setting zero forces to dump without check.
# The default value is 64MB.
#
KDUMP_FREE_DISK_SIZE=64
## Type: string
## Default: ""
#
#
# Specifies the dump device that is used for saving the dump with the kdump
# kernel. The dump device normally is a disk partition. You don't need to
# specify a dump device here. Then the dump is written to KDUMP_SAVEDIR when
# booting from the kdump kernel.
#
# If KDUMP_DUMPDEV points to a device file, the dump is written to that device
# when running the kdump kernel. The advantage over writing the dump to
# disk immediately is that you don't have to mount the root file system (which
# may be corrupted!) just to write the dump. So if the root file system is
# corrupted, you have the chance to fix the file system manually and reboot the
# system without loosing the dump information. On the first normal boot which
# is able to successfully mount the root file system, the dump is saved to
# KDUMP_SAVEDIR as usual.
#
# Important: The KDUMP_DUMPDEV is overwritten by kdump, so don't use it for
# saving any data. Also don't use the currently used swap partition.
#
KDUMP_DUMPDEV=""
## Type: integer
## Default: 3
#
# Determines if kdump uses verbose output. This value is a bitmask:
#
# 1: kdump command line is written to system log when executing
# /etc/init.d/kdump
# 2: progress is written to stdout while dumping
# 4: kdump command line is written so standard output when executing
# /etc/init.d/kdump
# 8: Debugging for kdump transfer script
KDUMP_VERBOSE=3
## Type: integer
## Default: 0
#
# Determines the dump level. If KDUMP_DUMPLEVEL != 0, then makedumpfile
# is used to strip pages that may not be necessary for analysing. 0 means
# no stripping, and 31 is the maximum dump level, i.e. 0 produces the
# largest dump files and 31 the smallest.
#
# The following table from makedumpfile(8) shows what each dump level
# means:
# dump | zero | cache|cache | user | free
# level | page | page |private| data | page
# -------+------+------+-------+------+------
# 0 | | | | |
# 1 | X | | | |
# 2 | | X | | |
# 3 | X | X | | |
# 4 | | X | X | |
# 5 | X | X | X | |
# 6 | | X | X | |
# 7 | X | X | X | |
# 8 | | | | X |
# 9 | X | | | X |
# 10 | | X | | X |
# 11 | X | X | | X |
# 12 | | X | X | X |
# 13 | X | X | X | X |
# 14 | | X | X | X |
# 15 | X | X | X | X |
# 16 | | | | | X
# 17 | X | | | | X
# 18 | | X | | | X
# 19 | X | X | | | X
# 20 | | X | X | | X
# 21 | X | X | X | | X
# 22 | | X | X | | X
# 23 | X | X | X | | X
# 24 | | | | X | X
# 25 | X | | | X | X
# 26 | | X | | X | X
# 27 | X | X | | X | X
# 28 | | X | X | X | X
# 29 | X | X | X | X | X
# 30 | | X | X | X | X
# 31 | X | X | X | X | X
KDUMP_DUMPLEVEL=0
## Type: string
## Default: "ELF"
#
# This variable specifies the dump format.
#
# "ELF" has the advantage that it's a standard format and GDB can be used to
# analyse the dumps. The disadvantage is that the dump files are larger.
#
# "compressed" is the kdump compressed format (see makedumpfile(8)) that
# produces small dumps. However, only "crash" can analyse the dumps and
# you need makedumpfile to have installed (but you need it anyway if you
# set KDUMP_DUMPLEVEL != 0 before).
KDUMP_DUMPFORMAT="ELF"