Merge branch 'f37' into f36

Signed-off-by: Coiby Xu <coxu@redhat.com>

.editorconfig

@@ -22,7 +22,7 @@ space_redirects    = true
 shell_variant = bash
 
 # Use dracut code style for *-module-setup.sh
-[*-module-setup.sh,dracut-early-kdump.sh]
+[*-module-setup.sh]
 shell_variant = bash
 indent_style = space
 indent_size = 4

.packit.yaml

@@ -1,36 +0,0 @@
-# See the documentation for more information:
-# https://packit.dev/docs/configuration/
-
-upstream_project_url: https://github.com/horms/kexec-tools.git
-
-specfile_path: kexec-tools.spec
-
-# add or remove files that should be synced
-files_to_sync:
-    - kexec-tools.spec
-    - .packit.yaml
-
-# name in upstream package repository or registry (e.g. in PyPI)
-upstream_package_name: kexec-tools
-# downstream (Fedora) RPM package name
-downstream_package_name: kexec-tools
-
-upstream_tag_template: v{version}
-
-jobs:
-  - job: pull_from_upstream
-    trigger: release
-    dist_git_branches:
-      - fedora-all
-
-  - job: koji_build
-    trigger: commit
-    allowed_pr_authors: ["all_committers", "packit"]
-    dist_git_branches:
-      - fedora-all
-
-  - job: bodhi_update
-    trigger: commit
-    allowed_builders: ["all_committers", "packit"]
-    dist_git_branches:
-      - fedora-all

60-kdump.install

@@ -0,0 +1,36 @@
+#!/usr/bin/bash
+
+COMMAND="$1"
+KERNEL_VERSION="$2"
+KDUMP_INITRD_DIR_ABS="$3"
+KERNEL_IMAGE="$4"
+
+if ! [[ ${KERNEL_INSTALL_MACHINE_ID-x} ]]; then
+    exit 0
+fi
+
+if [[ -d "$KDUMP_INITRD_DIR_ABS" ]]; then
+    KDUMP_INITRD="initrdkdump"
+else
+    # If `KDUMP_BOOTDIR` is not writable, then the kdump
+    # initrd must have been placed at `/var/lib/kdump`
+    if [[ ! -w "/boot" ]]; then
+        KDUMP_INITRD_DIR_ABS="/var/lib/kdump"
+    else
+        KDUMP_INITRD_DIR_ABS="/boot"
+    fi
+    KDUMP_INITRD="initramfs-${KERNEL_VERSION}kdump.img"
+fi
+
+ret=0
+case "$COMMAND" in
+    add)
+        # Do nothing, kdump initramfs is strictly host only
+        # and managed by kdump service
+        ;;
+    remove)
+        rm -f -- "$KDUMP_INITRD_DIR_ABS/$KDUMP_INITRD"
+        ret=$?
+        ;;
+esac
+exit $ret

92-crashkernel.install

@@ -0,0 +1,13 @@
+#!/usr/bin/bash
+
+COMMAND="$1"
+KERNEL_VERSION="$2"
+KDUMP_INITRD_DIR_ABS="$3"
+KERNEL_IMAGE="$4"
+
+case "$COMMAND" in
+add)
+	kdumpctl reset-crashkernel-for-installed_kernel "$KERNEL_VERSION"
+	exit 0
+	;;
+esac

98-kexec.rules

@@ -0,0 +1,16 @@
+SUBSYSTEM=="cpu", ACTION=="add", GOTO="kdump_reload"
+SUBSYSTEM=="cpu", ACTION=="remove", GOTO="kdump_reload"
+SUBSYSTEM=="memory", ACTION=="online", GOTO="kdump_reload"
+SUBSYSTEM=="memory", ACTION=="offline", GOTO="kdump_reload"
+
+GOTO="kdump_reload_end"
+
+LABEL="kdump_reload"
+
+# If kdump is not loaded, calling kdump-udev-throttle will end up
+# doing nothing, but systemd-run will always generate extra logs for
+# each call, so trigger the kdump-udev-throttler only if kdump
+# service is active to avoid unnecessary logs
+RUN+="/bin/sh -c '/usr/bin/systemctl is-active kdump.service || exit 0; /usr/bin/systemd-run --quiet --no-block /usr/lib/udev/kdump-udev-throttler'"
+
+LABEL="kdump_reload_end"

98-kexec.rules.ppc64

@@ -0,0 +1,22 @@
+SUBSYSTEM=="cpu", ACTION=="online", GOTO="kdump_reload_cpu"
+SUBSYSTEM=="memory", ACTION=="online", GOTO="kdump_reload_mem"
+SUBSYSTEM=="memory", ACTION=="offline", GOTO="kdump_reload_mem"
+
+GOTO="kdump_reload_end"
+
+# If kdump is not loaded, calling kdump-udev-throttle will end up
+# doing nothing, but systemd-run will always generate extra logs for
+# each call, so trigger the kdump-udev-throttler only if kdump
+# service is active to avoid unnecessary logs
+
+LABEL="kdump_reload_mem"
+
+RUN+="/bin/sh -c '/usr/bin/systemctl is-active kdump.service || exit 0; /usr/bin/systemd-run --quiet --no-block /usr/lib/udev/kdump-udev-throttler'"
+
+GOTO="kdump_reload_end"
+
+LABEL="kdump_reload_cpu"
+
+RUN+="/bin/sh -c '/usr/bin/systemctl is-active kdump.service || exit 0; ! test -f /sys/kernel/fadump_enabled || cat /sys/kernel/fadump_enabled | grep 0  || exit 0; /usr/bin/systemd-run --quiet --no-block /usr/lib/udev/kdump-udev-throttler'"
+
+LABEL="kdump_reload_end"

README.packit

@@ -1,3 +0,0 @@
-This repository is maintained by packit.
-https://packit.dev/
-The file was generated using packit 1.11.0.post1.dev7+gfdcdf3a32.

crashkernel-howto.txt

@@ -0,0 +1,120 @@
+Introduction
+============
+
+This document describes features the kexec-tools package provides for setting
+and estimating the crashkernel value.
+
+Kdump lives in a pre-reserved chunk of memory, and the size of the reserved
+memory is specified by the `crashkernel=` kernel parameter. It's hard to
+estimate an accurate `crashkernel=` value, so it's always recommended to test
+kdump after you updated the `crashkernel=` value or changed the dump target.
+
+
+Default crashkernel value
+=========================
+
+Latest kexec-tools provides "kdumpctl get-default-crashkernel" to retrieve
+the default crashkernel value,
+
+	$ echo $(kdumpctl get-default-crashkernel)
+	1G-4G:192M,4G-64G:256M,64G-:512M
+
+It will be taken as the default value of 'crashkernel=', you can use
+this value as a reference for setting crashkernel value manually.
+
+
+New installed system
+====================
+
+Anaconda is the OS installer which sets all the kernel boot cmdline on a newly
+installed system. If kdump is enabled during Anaconda installation, Anaconda
+will use the default crashkernel value as the default `crashkernel=` value on
+the newly installed system.
+
+Users can override the value during Anaconda installation manually.
+
+
+Auto update of crashkernel boot parameter
+=========================================
+
+A new release of kexec-tools could update the default crashkernel value.  By
+default, kexec-tools would reset crashkernel to the new default value if it
+detects the old default crashkernel value is used by installed kernels. If you
+don't want kexec-tools to update the old default crashkernel to the new default
+crashkernel, you can change auto_reset_crashkernel to no in kdump.conf.
+
+Supported Bootloaders
+---------------------
+
+This auto update only works with GRUB2 and ZIPL, as kexec-tools heavily depends
+on `grubby`. If other boot loaders are used, the user will have to update the
+`crashkernel=` value manually.
+
+
+Reset crashkernel to default value
+==================================
+
+kexec-tools only perform the auto update of crashkernel value when it can
+confirm the boot kernel's crashkernel value is using its corresponding default
+value and auto_reset_crashkernel=yes in kdump.conf. In other cases, the user
+can reset the crashkernel value by themselves.
+
+Reset using kdumpctl
+--------------------
+
+To make it easier to reset the `crashkernel=` kernel cmdline to this default
+value properly, `kdumpctl` also provides a sub-command:
+
+	`kdumpctl reset-crashkernel [--kernel=path_to_kernel] [--reboot]`
+
+This command will reset the bootloader's kernel cmdline to the default value.
+It will also update bootloader config if the bootloader has a standalone config
+file. User will have to reboot the machine after this command to make it take
+effect if --reboot is not specified. For more details, please refer to the
+reset-crashkernel command in `man kdumpctl`.
+
+Reset manually
+--------------
+
+To reset the crashkernel value manually, it's recommended to use utils like
+`grubby`. A one liner script for resetting `crashkernel=` value of all installed
+kernels to the default value is:
+
+	grubby --update-kernel ALL --args "crashkernel=$(kdumpctl get-default-crashkernel)"
+
+NOTE: On s390x you also need to run zipl for the change to take effect.
+
+Estimate crashkernel
+====================
+
+The best way to estimate a usable crashkernel value is by testing kdump
+manually.  And you can set crashkernel to a large value, then adjust the
+crashkernel value to an acceptable value gradually.
+
+`kdumpctl` also provides a sub-command for doing rough estimating without
+triggering kdump:
+
+	`kdumpctl estimate`
+
+The output will be like this:
+
+```
+      Encrypted kdump target requires extra memory, assuming using the keyslot with minimum memory requirement
+
+      Reserved crashkernel:    256M
+      Recommended crashkernel: 655M
+
+      Kernel image size:   47M
+      Kernel modules size: 12M
+      Initramfs size:      19M
+      Runtime reservation: 64M
+      LUKS required size:  512M
+      Large modules:
+          xfs: 1892352
+          nouveau: 2318336
+      WARNING: Current crashkernel size is lower than recommended size 655M.
+```
+
+It will generate a summary report about the estimated memory consumption
+of each component of kdump. The value may not be accurate enough, but
+would be a good start for finding a suitable crashkernel value.

dracut-early-kdump-module-setup.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+. /etc/sysconfig/kdump
+
+KDUMP_KERNEL=""
+KDUMP_INITRD=""
+
+check() {
+    if [[ ! -f /etc/sysconfig/kdump ]] || [[ ! -f /lib/kdump/kdump-lib.sh ]] \
+        || [[ -n ${IN_KDUMP} ]]; then
+        return 1
+    fi
+    return 255
+}
+
+depends() {
+    echo "base shutdown"
+    return 0
+}
+
+prepare_kernel_initrd() {
+    . /lib/kdump/kdump-lib.sh
+
+    prepare_kdump_bootinfo
+
+    # $kernel is a variable from dracut
+    if [[ $KDUMP_KERNELVER != "$kernel" ]]; then
+        dwarn "Using kernel version '$KDUMP_KERNELVER' for early kdump," \
+            "but the initramfs is generated for kernel version '$kernel'"
+    fi
+}
+
+install() {
+    prepare_kernel_initrd
+    if [[ ! -f $KDUMP_KERNEL ]]; then
+        derror "Could not find required kernel for earlykdump," \
+            "earlykdump will not work!"
+        return 1
+    fi
+    if [[ ! -f $KDUMP_INITRD ]]; then
+        derror "Could not find required kdump initramfs for earlykdump," \
+            "please ensure kdump initramfs is generated first," \
+            "earlykdump will not work!"
+        return 1
+    fi
+
+    inst_multiple tail find cut dirname hexdump
+    inst_simple "/etc/sysconfig/kdump"
+    inst_binary "/usr/sbin/kexec"
+    inst_binary "/usr/bin/gawk" "/usr/bin/awk"
+    inst_binary "/usr/bin/logger" "/usr/bin/logger"
+    inst_binary "/usr/bin/printf" "/usr/bin/printf"
+    inst_binary "/usr/bin/xargs" "/usr/bin/xargs"
+    inst_script "/lib/kdump/kdump-lib.sh" "/lib/kdump-lib.sh"
+    inst_script "/lib/kdump/kdump-lib-initramfs.sh" "/lib/kdump/kdump-lib-initramfs.sh"
+    inst_script "/lib/kdump/kdump-logger.sh" "/lib/kdump-logger.sh"
+    inst_hook cmdline 00 "$moddir/early-kdump.sh"
+    inst_binary "$KDUMP_KERNEL"
+    inst_binary "$KDUMP_INITRD"
+
+    ln_r "$KDUMP_KERNEL" "/boot/kernel-earlykdump"
+    ln_r "$KDUMP_INITRD" "/boot/initramfs-earlykdump"
+
+    chmod -x "${initdir}/$KDUMP_KERNEL"
+}

dracut-early-kdump.sh

@@ -0,0 +1,84 @@
+#! /bin/sh
+
+KEXEC=/sbin/kexec
+standard_kexec_args="-p"
+
+EARLY_KDUMP_INITRD=""
+EARLY_KDUMP_KERNEL=""
+EARLY_KDUMP_CMDLINE=""
+EARLY_KDUMP_KERNELVER=""
+EARLY_KEXEC_ARGS=""
+
+. /etc/sysconfig/kdump
+. /lib/dracut-lib.sh
+. /lib/kdump-lib.sh
+. /lib/kdump-logger.sh
+
+# initiate the kdump logger
+if ! dlog_init; then
+        echo "failed to initiate the kdump logger."
+        exit 1
+fi
+
+prepare_parameters()
+{
+    EARLY_KDUMP_CMDLINE=$(prepare_cmdline "${KDUMP_COMMANDLINE}" "${KDUMP_COMMANDLINE_REMOVE}" "${KDUMP_COMMANDLINE_APPEND}")
+    EARLY_KDUMP_KERNEL="/boot/kernel-earlykdump"
+    EARLY_KDUMP_INITRD="/boot/initramfs-earlykdump"
+}
+
+early_kdump_load()
+{
+    if ! check_kdump_feasibility; then
+        return 1
+    fi
+
+    if is_fadump_capable; then
+        dwarn "WARNING: early kdump doesn't support fadump."
+        return 1
+    fi
+
+    if check_current_kdump_status; then
+        return 1
+    fi
+
+    prepare_parameters
+
+    EARLY_KEXEC_ARGS=$(prepare_kexec_args "${KEXEC_ARGS}")
+
+    if is_secure_boot_enforced; then
+        dinfo "Secure Boot is enabled. Using kexec file based syscall."
+        EARLY_KEXEC_ARGS="$EARLY_KEXEC_ARGS -s"
+    fi
+
+    # Here, only output the messages, but do not save these messages
+    # to a file because the target disk may not be mounted yet, the
+    # earlykdump is too early.
+    ddebug "earlykdump: $KEXEC ${EARLY_KEXEC_ARGS} $standard_kexec_args \
+	--command-line=$EARLY_KDUMP_CMDLINE --initrd=$EARLY_KDUMP_INITRD \
+	$EARLY_KDUMP_KERNEL"
+
+    if $KEXEC $EARLY_KEXEC_ARGS $standard_kexec_args \
+        --command-line="$EARLY_KDUMP_CMDLINE" \
+        --initrd=$EARLY_KDUMP_INITRD $EARLY_KDUMP_KERNEL; then
+        dinfo "kexec: loaded early-kdump kernel"
+        return 0
+    else
+        derror "kexec: failed to load early-kdump kernel"
+        return 1
+    fi
+}
+
+set_early_kdump()
+{
+    if getargbool 0 rd.earlykdump; then
+        dinfo "early-kdump is enabled."
+        early_kdump_load
+    else
+        dinfo "early-kdump is disabled."
+    fi
+
+    return 0
+}
+
+set_early_kdump

dracut-fadump-init-fadump.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+export PATH=/usr/bin:/usr/sbin
+export SYSTEMD_IN_INITRD=lenient
+
+[ -e /proc/mounts ] ||
+	(mkdir -p /proc && mount -t proc -o nosuid,noexec,nodev proc /proc)
+
+grep -q '^sysfs /sys sysfs' /proc/mounts ||
+	(mkdir -p /sys && mount -t sysfs -o nosuid,noexec,nodev sysfs /sys)
+
+grep -q '^none / ' /proc/mounts || grep -q '^rootfs / ' /proc/mounts && ROOTFS_IS_RAMFS=1
+
+if [ -f /proc/device-tree/rtas/ibm,kernel-dump ] || [ -f /proc/device-tree/ibm,opal/dump/mpipl-boot ]; then
+	mkdir /newroot
+	mount -t ramfs ramfs /newroot
+
+	if [ $ROOTFS_IS_RAMFS ]; then
+		for FILE in $(ls -A /fadumproot/); do
+			mv /fadumproot/$FILE /newroot/
+		done
+		exec switch_root /newroot /init
+	else
+		mkdir /newroot/sys /newroot/proc /newroot/dev /newroot/run /newroot/oldroot
+
+		grep -q '^devtmpfs /dev devtmpfs' /proc/mounts && mount --move /dev /newroot/dev
+		grep -q '^tmpfs /run tmpfs' /proc/mounts && mount --move /run /newroot/run
+		mount --move /sys /newroot/sys
+		mount --move /proc /newroot/proc
+
+		cp --reflink=auto --sparse=auto --preserve=mode,timestamps,links -dfr /fadumproot/. /newroot/
+		cd /newroot && pivot_root . oldroot
+
+		loop=1
+		while [ $loop ]; do
+			unset loop
+			while read -r _ mp _; do
+				case $mp in
+				/oldroot/*) umount -d "$mp" && loop=1 ;;
+				esac
+			done </proc/mounts
+		done
+		umount -d -l oldroot
+
+		exec /init
+	fi
+else
+	exec /init.dracut
+fi

dracut-fadump-module-setup.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+check() {
+    return 255
+}
+
+depends() {
+    return 0
+}
+
+install() {
+    mv -f "$initdir/init" "$initdir/init.dracut"
+    inst_script "$moddir/init-fadump.sh" /init
+    chmod a+x "$initdir/init"
+
+    # Install required binaries for the init script (init-fadump.sh)
+    inst_multiple sh modprobe grep mkdir mount
+    if dracut_module_included "squash"; then
+        inst_multiple cp pivot_root umount
+    else
+        inst_multiple ls mv switch_root
+    fi
+}

dracut-kdump-capture.service

@@ -0,0 +1,30 @@
+#  This file is part of systemd.
+#
+#  systemd is free software; you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 2.1 of the License, or
+#  (at your option) any later version.
+
+[Unit]
+Description=Kdump Vmcore Save Service
+After=initrd.target initrd-parse-etc.service sysroot.mount
+After=dracut-initqueue.service dracut-pre-mount.service dracut-mount.service dracut-pre-pivot.service
+Before=initrd-cleanup.service
+ConditionPathExists=/etc/initrd-release
+OnFailure=emergency.target
+OnFailureJobMode=isolate
+
+[Service]
+Environment=DRACUT_SYSTEMD=1
+Environment=NEWROOT=/sysroot
+Type=oneshot
+ExecStart=/bin/kdump.sh
+StandardInput=null
+StandardOutput=journal
+StandardError=journal+console
+KillMode=process
+RemainAfterExit=yes
+
+# Bash ignores SIGTERM, so we send SIGHUP instead, to ensure that bash
+# terminates cleanly.
+KillSignal=SIGHUP

dracut-kdump-emergency.service

@@ -0,0 +1,27 @@
+# This service will run the real kdump error handler code. Executing the
+# failure action configured in kdump.conf
+
+[Unit]
+Description=Kdump Error Handler
+DefaultDependencies=no
+After=systemd-vconsole-setup.service
+Wants=systemd-vconsole-setup.service
+
+[Service]
+Environment=HOME=/
+Environment=DRACUT_SYSTEMD=1
+Environment=NEWROOT=/sysroot
+WorkingDirectory=/
+ExecStart=/bin/kdump.sh --error-handler
+ExecStopPost=-/bin/rm -f -- /.console_lock
+Type=oneshot
+StandardInput=tty-force
+StandardOutput=inherit
+StandardError=inherit
+KillMode=process
+IgnoreSIGPIPE=no
+TasksMax=infinity
+
+# Bash ignores SIGTERM, so we send SIGHUP instead, to ensure that bash
+# terminates cleanly.
+KillSignal=SIGHUP

dracut-kdump-emergency.target

@@ -0,0 +1,14 @@
+#  This file is part of systemd.
+#
+#  systemd is free software; you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 2.1 of the License, or
+#  (at your option) any later version.
+
+[Unit]
+Description=Emergency Mode
+Documentation=man:systemd.special(7)
+Requires=emergency.service
+After=emergency.service
+AllowIsolate=yes
+IgnoreOnIsolate=yes

dracut-kdump.sh

@@ -0,0 +1,589 @@
+#!/bin/sh
+#
+# The main kdump routine in capture kernel, bash may not be the
+# default shell. Any code added must be POSIX compliant.
+
+. /lib/dracut-lib.sh
+. /lib/kdump-logger.sh
+. /lib/kdump-lib-initramfs.sh
+
+#initiate the kdump logger
+if ! dlog_init; then
+	echo "failed to initiate the kdump logger."
+	exit 1
+fi
+
+KDUMP_PATH="/var/crash"
+KDUMP_LOG_FILE="/run/initramfs/kexec-dmesg.log"
+KDUMP_LOG_DEST=""
+KDUMP_LOG_OP=""
+CORE_COLLECTOR=""
+DEFAULT_CORE_COLLECTOR="makedumpfile -l --message-level 7 -d 31"
+DMESG_COLLECTOR="/sbin/vmcore-dmesg"
+FAILURE_ACTION="systemctl reboot -f"
+DATEDIR=$(date +%Y-%m-%d-%T)
+HOST_IP='127.0.0.1'
+DUMP_INSTRUCTION=""
+SSH_KEY_LOCATION=$DEFAULT_SSHKEY
+DD_BLKSIZE=512
+FINAL_ACTION="systemctl reboot -f"
+KDUMP_PRE=""
+KDUMP_POST=""
+NEWROOT="/sysroot"
+OPALCORE="/sys/firmware/opal/mpipl/core"
+KDUMP_CONF_PARSED="/tmp/kdump.conf.$$"
+
+# POSIX doesn't have pipefail, only apply when using bash
+# shellcheck disable=SC3040
+[ -n "$BASH" ] && set -o pipefail
+
+DUMP_RETVAL=0
+
+kdump_read_conf > $KDUMP_CONF_PARSED
+
+get_kdump_confs()
+{
+	while read -r config_opt config_val; do
+		# remove inline comments after the end of a directive.
+		case "$config_opt" in
+		path)
+			KDUMP_PATH="$config_val"
+			;;
+		core_collector)
+			[ -n "$config_val" ] && CORE_COLLECTOR="$config_val"
+			;;
+		sshkey)
+			if [ -f "$config_val" ]; then
+				SSH_KEY_LOCATION=$config_val
+			fi
+			;;
+		kdump_pre)
+			KDUMP_PRE="$config_val"
+			;;
+		kdump_post)
+			KDUMP_POST="$config_val"
+			;;
+		fence_kdump_args)
+			FENCE_KDUMP_ARGS="$config_val"
+			;;
+		fence_kdump_nodes)
+			FENCE_KDUMP_NODES="$config_val"
+			;;
+		failure_action | default)
+			case $config_val in
+			shell)
+				FAILURE_ACTION="kdump_emergency_shell"
+				;;
+			reboot)
+				FAILURE_ACTION="systemctl reboot -f && exit"
+				;;
+			halt)
+				FAILURE_ACTION="halt && exit"
+				;;
+			poweroff)
+				FAILURE_ACTION="systemctl poweroff -f && exit"
+				;;
+			dump_to_rootfs)
+				FAILURE_ACTION="dump_to_rootfs"
+				;;
+			esac
+			;;
+		final_action)
+			case $config_val in
+			reboot)
+				FINAL_ACTION="systemctl reboot -f"
+				;;
+			halt)
+				FINAL_ACTION="halt"
+				;;
+			poweroff)
+				FINAL_ACTION="systemctl poweroff -f"
+				;;
+			esac
+			;;
+		esac
+	done < "$KDUMP_CONF_PARSED"
+
+	if [ -z "$CORE_COLLECTOR" ]; then
+		CORE_COLLECTOR="$DEFAULT_CORE_COLLECTOR"
+		if is_ssh_dump_target || is_raw_dump_target; then
+			CORE_COLLECTOR="$CORE_COLLECTOR -F"
+		fi
+	fi
+}
+
+# store the kexec kernel log to a file.
+save_log()
+{
+	# LOG_OP is empty when log can't be saved, eg. raw target
+	[ -n "$KDUMP_LOG_OP" ] || return
+
+	dmesg -T > $KDUMP_LOG_FILE
+
+	if command -v journalctl > /dev/null; then
+		journalctl -ab >> $KDUMP_LOG_FILE
+	fi
+	chmod 600 $KDUMP_LOG_FILE
+
+	dinfo "saving the $KDUMP_LOG_FILE to $KDUMP_LOG_DEST/"
+
+	eval "$KDUMP_LOG_OP"
+}
+
+# $1: dump path, must be a mount point
+dump_fs()
+{
+	ddebug "dump_fs _mp=$1"
+
+	if ! is_mounted "$1"; then
+		dinfo "dump path '$1' is not mounted, trying to mount..."
+		if ! mount --target "$1"; then
+			derror "failed to dump to '$1', it's not a mount point!"
+			return 1
+		fi
+	fi
+
+	# Remove -F in makedumpfile case. We don't want a flat format dump here.
+	case $CORE_COLLECTOR in
+	*makedumpfile*)
+		CORE_COLLECTOR=$(echo "$CORE_COLLECTOR" | sed -e "s/-F//g")
+		;;
+	esac
+
+	_dump_fs_path=$(echo "$1/$KDUMP_PATH/$HOST_IP-$DATEDIR/" | tr -s /)
+	dinfo "saving to $_dump_fs_path"
+
+	# Only remount to read-write mode if the dump target is mounted read-only.
+	_dump_mnt_op=$(get_mount_info OPTIONS target "$1" -f)
+	case $_dump_mnt_op in
+	ro*)
+		dinfo "Remounting the dump target in rw mode."
+		mount -o remount,rw "$1" || return 1
+		;;
+	esac
+
+	mkdir -p "$_dump_fs_path" || return 1
+
+	save_vmcore_dmesg_fs ${DMESG_COLLECTOR} "$_dump_fs_path"
+	save_opalcore_fs "$_dump_fs_path"
+
+	dinfo "saving vmcore"
+	KDUMP_LOG_DEST=$_dump_fs_path/
+	KDUMP_LOG_OP="mv '$KDUMP_LOG_FILE' '$KDUMP_LOG_DEST/'"
+
+	$CORE_COLLECTOR /proc/vmcore "$_dump_fs_path/vmcore-incomplete"
+	_dump_exitcode=$?
+	if [ $_dump_exitcode -eq 0 ]; then
+		mv "$_dump_fs_path/vmcore-incomplete" "$_dump_fs_path/vmcore"
+		sync
+		dinfo "saving vmcore complete"
+	else
+		derror "saving vmcore failed, exitcode:$_dump_exitcode"
+		return 1
+	fi
+
+	# improper kernel cmdline can cause the failure of echo, we can ignore this kind of failure
+	return 0
+}
+
+# $1: dmesg collector
+# $2: dump path
+save_vmcore_dmesg_fs()
+{
+	dinfo "saving vmcore-dmesg.txt to $2"
+	if $1 /proc/vmcore > "$2/vmcore-dmesg-incomplete.txt"; then
+		mv "$2/vmcore-dmesg-incomplete.txt" "$2/vmcore-dmesg.txt"
+		chmod 600 "$2/vmcore-dmesg.txt"
+
+		# Make sure file is on disk. There have been instances where later
+		# saving vmcore failed and system rebooted without sync and there
+		# was no vmcore-dmesg.txt available.
+		sync
+		dinfo "saving vmcore-dmesg.txt complete"
+	else
+		if [ -f "$2/vmcore-dmesg-incomplete.txt" ]; then
+			chmod 600 "$2/vmcore-dmesg-incomplete.txt"
+		fi
+		derror "saving vmcore-dmesg.txt failed"
+	fi
+}
+
+# $1: dump path
+save_opalcore_fs()
+{
+	if [ ! -f $OPALCORE ]; then
+		# Check if we are on an old kernel that uses a different path
+		if [ -f /sys/firmware/opal/core ]; then
+			OPALCORE="/sys/firmware/opal/core"
+		else
+			return 0
+		fi
+	fi
+
+	dinfo "saving opalcore:$OPALCORE to $1/opalcore"
+	if ! cp $OPALCORE "$1/opalcore"; then
+		derror "saving opalcore failed"
+		return 1
+	fi
+
+	sync
+	dinfo "saving opalcore complete"
+	return 0
+}
+
+dump_to_rootfs()
+{
+
+	if [ "$(systemctl status dracut-initqueue | sed -n "s/^\s*Active: \(\S*\)\s.*$/\1/p")" = "inactive" ]; then
+		dinfo "Trying to bring up initqueue for rootfs mount"
+		systemctl start dracut-initqueue
+	fi
+
+	dinfo "Clean up dead systemd services"
+	systemctl cancel
+	dinfo "Waiting for rootfs mount, will timeout after 90 seconds"
+	systemctl start --no-block sysroot.mount
+
+	_loop=0
+	while [ $_loop -lt 90 ] && ! is_mounted /sysroot; do
+		sleep 1
+		_loop=$((_loop + 1))
+	done
+
+	if ! is_mounted /sysroot; then
+		derror "Failed to mount rootfs"
+		return
+	fi
+
+	ddebug "NEWROOT=$NEWROOT"
+	dump_fs $NEWROOT
+}
+
+kdump_emergency_shell()
+{
+	ddebug "Switching to kdump emergency shell..."
+
+	[ -f /etc/profile ] && . /etc/profile
+	export PS1='kdump:${PWD}# '
+
+	. /lib/dracut-lib.sh
+	if [ -f /dracut-state.sh ]; then
+		. /dracut-state.sh 2> /dev/null
+	fi
+
+	source_conf /etc/conf.d
+
+	type plymouth > /dev/null 2>&1 && plymouth quit
+
+	source_hook "emergency"
+	while read -r _tty rest; do
+		(
+			echo
+			echo
+			echo 'Entering kdump emergency mode.'
+			echo 'Type "journalctl" to view system logs.'
+			echo 'Type "rdsosreport" to generate a sosreport, you can then'
+			echo 'save it elsewhere and attach it to a bug report.'
+			echo
+			echo
+		) > "/dev/$_tty"
+	done < /proc/consoles
+	sh -i -l
+	/bin/rm -f -- /.console_lock
+}
+
+do_failure_action()
+{
+	dinfo "Executing failure action $FAILURE_ACTION"
+	eval $FAILURE_ACTION
+}
+
+do_final_action()
+{
+	dinfo "Executing final action $FINAL_ACTION"
+	eval $FINAL_ACTION
+}
+
+do_dump()
+{
+	eval $DUMP_INSTRUCTION
+	_ret=$?
+
+	if [ $_ret -ne 0 ]; then
+		derror "saving vmcore failed"
+	fi
+
+	return $_ret
+}
+
+do_kdump_pre()
+{
+	if [ -n "$KDUMP_PRE" ]; then
+		"$KDUMP_PRE"
+		_ret=$?
+		if [ $_ret -ne 0 ]; then
+			derror "$KDUMP_PRE exited with $_ret status"
+			return $_ret
+		fi
+	fi
+
+	# if any script fails, it just raises warning and continues
+	if [ -d /etc/kdump/pre.d ]; then
+		for file in /etc/kdump/pre.d/*; do
+			"$file"
+			_ret=$?
+			if [ $_ret -ne 0 ]; then
+				derror "$file exited with $_ret status"
+			fi
+		done
+	fi
+	return 0
+}
+
+do_kdump_post()
+{
+	if [ -d /etc/kdump/post.d ]; then
+		for file in /etc/kdump/post.d/*; do
+			"$file" "$1"
+			_ret=$?
+			if [ $_ret -ne 0 ]; then
+				derror "$file exited with $_ret status"
+			fi
+		done
+	fi
+
+	if [ -n "$KDUMP_POST" ]; then
+		"$KDUMP_POST" "$1"
+		_ret=$?
+		if [ $_ret -ne 0 ]; then
+			derror "$KDUMP_POST exited with $_ret status"
+		fi
+	fi
+}
+
+# $1: block target, eg. /dev/sda
+dump_raw()
+{
+	[ -b "$1" ] || return 1
+
+	dinfo "saving to raw disk $1"
+
+	if ! echo "$CORE_COLLECTOR" | grep -q makedumpfile; then
+		_src_size=$(stat --format %s /proc/vmcore)
+		_src_size_mb=$((_src_size / 1048576))
+		/kdumpscripts/monitor_dd_progress $_src_size_mb &
+	fi
+
+	dinfo "saving vmcore"
+	$CORE_COLLECTOR /proc/vmcore | dd of="$1" bs=$DD_BLKSIZE >> /tmp/dd_progress_file 2>&1 || return 1
+	sync
+
+	dinfo "saving vmcore complete"
+	return 0
+}
+
+# $1: ssh key file
+# $2: ssh address in <user>@<host> format
+dump_ssh()
+{
+	_ret=0
+	_ssh_opt="-i $1 -o BatchMode=yes -o StrictHostKeyChecking=yes"
+	_ssh_dir="$KDUMP_PATH/$HOST_IP-$DATEDIR"
+	if is_ipv6_address "$2"; then
+		_scp_address=${2%@*}@"[${2#*@}]"
+	else
+		_scp_address=$2
+	fi
+
+	dinfo "saving to $2:$_ssh_dir"
+
+	cat /var/lib/random-seed > /dev/urandom
+	ssh -q $_ssh_opt "$2" mkdir -p "$_ssh_dir" || return 1
+
+	save_vmcore_dmesg_ssh "$DMESG_COLLECTOR" "$_ssh_dir" "$_ssh_opt" "$2"
+
+	dinfo "saving vmcore"
+
+	KDUMP_LOG_DEST=$2:$_ssh_dir/
+	KDUMP_LOG_OP="scp -q $_ssh_opt '$KDUMP_LOG_FILE' '$_scp_address:$_ssh_dir/'"
+
+	save_opalcore_ssh "$_ssh_dir" "$_ssh_opt" "$2" "$_scp_address"
+
+	if [ "${CORE_COLLECTOR%%[[:blank:]]*}" = "scp" ]; then
+		scp -q $_ssh_opt /proc/vmcore "$_scp_address:$_ssh_dir/vmcore-incomplete"
+		_ret=$?
+		_vmcore="vmcore"
+	else
+		$CORE_COLLECTOR /proc/vmcore | ssh $_ssh_opt "$2" "umask 0077 && dd bs=512 of='$_ssh_dir/vmcore-incomplete'"
+		_ret=$?
+		_vmcore="vmcore.flat"
+	fi
+
+	if [ $_ret -eq 0 ]; then
+		ssh $_ssh_opt "$2" "mv '$_ssh_dir/vmcore-incomplete' '$_ssh_dir/$_vmcore'"
+		_ret=$?
+		if [ $_ret -ne 0 ]; then
+			derror "moving vmcore failed, exitcode:$_ret"
+		else
+			dinfo "saving vmcore complete"
+		fi
+	else
+		derror "saving vmcore failed, exitcode:$_ret"
+	fi
+
+	return $_ret
+}
+
+# $1: dump path
+# $2: ssh opts
+# $3: ssh address in <user>@<host> format
+# $4: scp address, similar with ssh address but IPv6 addresses are quoted
+save_opalcore_ssh()
+{
+	if [ ! -f $OPALCORE ]; then
+		# Check if we are on an old kernel that uses a different path
+		if [ -f /sys/firmware/opal/core ]; then
+			OPALCORE="/sys/firmware/opal/core"
+		else
+			return 0
+		fi
+	fi
+
+	dinfo "saving opalcore:$OPALCORE to $3:$1"
+
+	if ! scp $2 $OPALCORE "$4:$1/opalcore-incomplete"; then
+		derror "saving opalcore failed"
+		return 1
+	fi
+
+	ssh $2 "$3" mv "$1/opalcore-incomplete" "$1/opalcore"
+	dinfo "saving opalcore complete"
+	return 0
+}
+
+# $1: dmesg collector
+# $2: dump path
+# $3: ssh opts
+# $4: ssh address in <user>@<host> format
+save_vmcore_dmesg_ssh()
+{
+	dinfo "saving vmcore-dmesg.txt to $4:$2"
+	if $1 /proc/vmcore | ssh $3 "$4" "umask 0077 && dd of='$2/vmcore-dmesg-incomplete.txt'"; then
+		ssh -q $3 "$4" mv "$2/vmcore-dmesg-incomplete.txt" "$2/vmcore-dmesg.txt"
+		dinfo "saving vmcore-dmesg.txt complete"
+	else
+		derror "saving vmcore-dmesg.txt failed"
+	fi
+}
+
+get_host_ip()
+{
+	if is_nfs_dump_target || is_ssh_dump_target; then
+		kdumpnic=$(getarg kdumpnic=)
+		if [ -z "$kdumpnic" ]; then
+			derror "failed to get kdumpnic!"
+			return 1
+		fi
+		if ! kdumphost=$(ip addr show dev "$kdumpnic" | grep '[ ]*inet'); then
+			derror "wrong kdumpnic: $kdumpnic"
+			return 1
+		fi
+		kdumphost=$(echo "$kdumphost" | head -n 1 | awk '{print $2}')
+		kdumphost="${kdumphost%%/*}"
+		if [ -z "$kdumphost" ]; then
+			derror "wrong kdumpnic: $kdumpnic"
+			return 1
+		fi
+		HOST_IP=$kdumphost
+	fi
+	return 0
+}
+
+read_kdump_confs()
+{
+	if [ ! -f "$KDUMP_CONFIG_FILE" ]; then
+		derror "$KDUMP_CONFIG_FILE not found"
+		return
+	fi
+
+	get_kdump_confs
+
+	# rescan for add code for dump target
+	while read -r config_opt config_val; do
+		# remove inline comments after the end of a directive.
+		case "$config_opt" in
+		dracut_args)
+			config_val=$(get_dracut_args_target "$config_val")
+			if [ -n "$config_val" ]; then
+				config_val=$(get_mntpoint_from_target "$config_val")
+				DUMP_INSTRUCTION="dump_fs $config_val"
+			fi
+			;;
+		ext[234] | xfs | btrfs | minix | nfs)
+			config_val=$(get_mntpoint_from_target "$config_val")
+			DUMP_INSTRUCTION="dump_fs $config_val"
+			;;
+		raw)
+			DUMP_INSTRUCTION="dump_raw $config_val"
+			;;
+		ssh)
+			DUMP_INSTRUCTION="dump_ssh $SSH_KEY_LOCATION $config_val"
+			;;
+		esac
+	done < "$KDUMP_CONF_PARSED"
+}
+
+fence_kdump_notify()
+{
+	if [ -n "$FENCE_KDUMP_NODES" ]; then
+		# shellcheck disable=SC2086
+		$FENCE_KDUMP_SEND $FENCE_KDUMP_ARGS $FENCE_KDUMP_NODES &
+	fi
+}
+
+if [ "$1" = "--error-handler" ]; then
+	get_kdump_confs
+	do_failure_action
+	do_final_action
+
+	exit $?
+fi
+
+# continue here only if we have to save dump.
+if [ -f /etc/fadump.initramfs ] && [ ! -f /proc/device-tree/rtas/ibm,kernel-dump ] && [ ! -f /proc/device-tree/ibm,opal/dump/mpipl-boot ]; then
+	exit 0
+fi
+
+read_kdump_confs
+fence_kdump_notify
+
+if ! get_host_ip; then
+	derror "get_host_ip exited with non-zero status!"
+	exit 1
+fi
+
+if [ -z "$DUMP_INSTRUCTION" ]; then
+	DUMP_INSTRUCTION="dump_fs $NEWROOT"
+fi
+
+if ! do_kdump_pre; then
+	derror "kdump_pre script exited with non-zero status!"
+	do_final_action
+	# During systemd service to reboot the machine, stop this shell script running
+	exit 1
+fi
+make_trace_mem "kdump saving vmcore" '1:shortmem' '2+:mem' '3+:slab'
+do_dump
+DUMP_RETVAL=$?
+
+if ! do_kdump_post $DUMP_RETVAL; then
+	derror "kdump_post script exited with non-zero status!"
+fi
+
+save_log
+
+if [ $DUMP_RETVAL -ne 0 ]; then
+	exit 1
+fi
+
+do_final_action

dracut-monitor_dd_progress

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+SRC_FILE_MB=$1
+
+while true
+do
+    DD_PID=`pidof dd`
+    if [ -n "$DD_PID" ]; then
+        break
+    fi
+done
+
+while true
+do
+    sleep 5
+    if [ ! -d /proc/$DD_PID ]; then
+        break
+    fi
+
+    kill -s USR1 $DD_PID
+    CURRENT_SIZE=`tail -n 1 /tmp/dd_progress_file | sed "s/[^0-9].*//g"`
+    [ -n "$CURRENT_SIZE" ] && {
+        CURRENT_MB=$(($CURRENT_SIZE / 1048576))
+        echo -e "Copied $CURRENT_MB MB / $SRC_FILE_MB MB\r"
+    }
+done
+
+rm -f /tmp/dd_progress_file

early-kdump-howto.txt

@@ -0,0 +1,95 @@
+Early Kdump HOWTO
+
+Introduction
+------------
+
+Early kdump is a mechanism to make kdump operational earlier than normal kdump
+service.  The kdump service starts early enough for general crash cases, but
+there are some cases where it has no chance to make kdump operational in boot
+sequence, such as detecting devices and starting early services.  If you hit
+such a case, early kdump may allow you to get more information of it.
+
+Early kdump is implemented as a dracut module.  It adds a kernel (vmlinuz) and
+initramfs for kdump to your system's initramfs in order to load them as early
+as possible.  After that, if you provide "rd.earlykdump" in kernel command line,
+then in the initramfs, early kdump will load those files like the normal kdump
+service.  This is disabled by default.
+
+For the normal kdump service, it can check whether the early kdump has loaded
+the crash kernel and initramfs. It has no conflict with the early kdump.
+
+How to configure early kdump
+----------------------------
+
+We assume if you're reading this document, you should already have kexec-tools
+installed.
+
+You can rebuild the initramfs with earlykdump support with below steps:
+
+1. start kdump service to make sure kdump initramfs is created.
+
+    # systemctl start kdump
+
+    NOTE: If a crash occurs during boot process, early kdump captures a vmcore
+    and reboot the system by default, so the system might go into crash loop.
+    You can avoid such a crash loop by adding the following settings, which
+    power off the system after dump capturing, to kdump.conf in advance:
+
+        final_action poweroff
+        failure_action poweroff
+
+    For the failure_action, you can choose anything other than "reboot".
+
+2. rebuild system initramfs with earlykdump support.
+
+    # dracut --force --add earlykdump
+
+    NOTE: Recommend to backup the original system initramfs before performing
+    this step to put it back if something happens during boot-up.
+
+3. add rd.earlykdump in grub kernel command line.
+
+After making said changes, reboot your system to take effect. Of course, if you
+want to disable early kdump, you can simply remove "rd.earlykdump" from kernel
+boot parameters in grub, and reboot system like above.
+
+Once the boot is completed, you can check the status of the early kdump support
+on the command prompt:
+
+    # journalctl -b | grep early-kdump
+
+Then, you will see some useful logs, for example:
+
+- if early kdump is successful.
+
+Mar 09 09:57:56 localhost dracut-cmdline[190]: early-kdump is enabled.
+Mar 09 09:57:56 localhost dracut-cmdline[190]: kexec: loaded early-kdump kernel
+
+- if early kdump is disabled.
+
+Mar 09 10:02:47 localhost dracut-cmdline[189]: early-kdump is disabled.
+
+Notes
+-----
+
+- The size of early kdump initramfs will be large because it includes vmlinuz
+  and kdump initramfs.
+
+- Early kdump inherits the settings of normal kdump, so any changes that
+  caused normal kdump rebuilding also require rebuilding the system initramfs
+  to make sure that the changes take effect for early kdump. Therefore, after
+  the rebuilding of kdump initramfs is completed, provide a prompt message to
+  tell the fact.
+
+- If you install an updated kernel and reboot the system with it, the early
+  kdump will be disabled by default.  To enable it with the new kernel, you
+  need to take the above steps again.
+
+Limitation
+----------
+
+- At present, early kdump doesn't support fadump.
+
+- Early kdump loads a crash kernel and initramfs at the beginning of the
+  process in system's initramfs, so a crash at earlier than that (e.g. in
+  kernel initialization) cannot be captured even with the early kdump.

fadump-howto.txt

@@ -0,0 +1,359 @@
+Firmware assisted dump (fadump) HOWTO
+
+Introduction
+
+Firmware assisted dump is a new feature in the 3.4 mainline kernel supported
+only on powerpc architecture. The goal of firmware-assisted dump is to enable
+the dump of a crashed system, and to do so from a fully-reset system, and to
+minimize the total elapsed time until the system is back in production use. A
+complete documentation on implementation can be found at
+Documentation/powerpc/firmware-assisted-dump.txt in upstream linux kernel tree
+from 3.4 version and above.
+
+Please note that the firmware-assisted dump feature is only available on Power6
+and above systems with recent firmware versions.
+
+Overview
+
+Fadump
+
+Fadump is a robust kernel crash dumping mechanism to get reliable kernel crash
+dump with assistance from firmware. This approach does not use kexec, instead
+firmware assists in booting the kdump kernel while preserving memory contents.
+Unlike kdump, the system is fully reset, and loaded with a fresh copy of the
+kernel. In particular, PCI and I/O devices are reinitialized and are in a
+clean, consistent state.  This second kernel, often called a capture kernel,
+boots with very little memory and captures the dump image.
+
+The first kernel registers the sections of memory with the Power firmware for
+dump preservation during OS initialization. These registered sections of memory
+are reserved by the first kernel during early boot. When a system crashes, the
+Power firmware fully resets the system, preserves all the system memory
+contents, save the low memory (boot memory of size larger of 5% of system
+RAM or 256MB) of RAM to the previous registered region. It will also save
+system registers, and hardware PTE's.
+
+Fadump is supported only on ppc64 platform. The standard kernel and capture
+kernel are one and the same on ppc64.
+
+If you're reading this document, you should already have kexec-tools
+installed. If not, you install it via the following command:
+
+    # dnf install kexec-tools
+
+Fadump Operational Flow:
+
+Like kdump, fadump also exports the ELF formatted kernel crash dump through
+/proc/vmcore. Hence existing kdump infrastructure can be used to capture fadump
+vmcore. The idea is to keep the functionality transparent to end user. From
+user perspective there is no change in the way kdump init script works.
+
+However, unlike kdump, fadump does not pre-load kdump kernel and initrd into
+reserved memory, instead it always uses default OS initrd during second boot
+after crash. Hence, for fadump, we rebuild the new kdump initrd and replace it
+with default initrd. Before replacing existing default initrd we take a backup
+of original default initrd for user's reference. The dracut package has been
+enhanced to rebuild the default initrd with vmcore capture steps. The initrd
+image is rebuilt as per the configuration in /etc/kdump.conf file.
+
+The control flow of fadump works as follows:
+01. System panics.
+02. At the crash, kernel informs power firmware that kernel has crashed.
+03. Firmware takes the control and reboots the entire system preserving
+    only the memory (resets all other devices).
+04. The reboot follows the normal booting process (non-kexec).
+05. The boot loader loads the default kernel and initrd from /boot
+06. The default initrd loads and runs /init
+07. dracut-kdump.sh script present in fadump aware default initrd checks if
+    '/proc/device-tree/rtas/ibm,kernel-dump'  file exists  before executing
+    steps to capture vmcore.
+    (This check will help to bypass the vmcore capture steps during normal boot
+     process.)
+09. Captures dump according to /etc/kdump.conf
+10. Is dump capture successful (yes goto 12, no goto 11)
+11. Perform the failure action specified in /etc/kdump.conf
+    (The default failure action is reboot, if unspecified)
+12. Perform the final action specified in /etc/kdump.conf
+    (The default final action is reboot, if unspecified)
+
+
+How to configure fadump:
+
+Again, we assume if you're reading this document, you should already have
+kexec-tools installed. If not, you install it via the following command:
+
+    # dnf install kexec-tools
+
+Make the kernel to be configured with FADump as the default boot entry, if
+it isn't already:
+
+   # grubby --set-default=/boot/vmlinuz-<kver>
+
+Boot into the kernel to be configured for FADump. To be able to do much of
+anything interesting in the way of debug analysis, you'll also need to install
+the kernel-debuginfo package, of the same arch as your running kernel, and the
+crash utility:
+
+    # dnf --enablerepo=\*debuginfo install kernel-debuginfo.$(uname -m) crash
+
+Next up, we can enable firmware assisted dump and reserve the memory for boot
+memory preservation as specified in in the table of 'FADump Memory Requirements'
+section:
+
+   # kdumpctl reset-crashkernel --fadump=on
+
+Alternatively, you can use grubby to reserve custom amount of memory:
+
+   # grubby --args="fadump=on crashkernel=6G" --update-kernel=/boot/vmlinuz-`uname -r`
+
+By default, FADump reserved memory will be initialized as CMA area to make the
+memory available through CMA allocator on the production kernel. We can opt out
+of this, making reserved memory unavailable to production kernel, by booting the
+linux kernel with 'fadump=nocma' instead of 'fadump=on':
+
+   # kdumpctl reset-crashkernel --fadump=nocma
+
+The term 'boot memory' means size of the low memory chunk that is required for
+a kernel to boot successfully when booted with restricted memory.  By default,
+the boot memory size will be the larger of 5% of system RAM or 256MB.
+Alternatively, user can also specify boot memory size through boot parameter
+'fadump_reserve_mem=' which will override the default calculated size. Use this
+option if default boot memory size is not sufficient for second kernel to boot
+successfully.
+
+After making said changes, reboot your system, so that the specified memory is
+reserved and left untouched by the normal system. Take note that the output of
+'free -m' will show X MB less memory than without this parameter, which is
+expected. If you see OOM (Out Of Memory) error messages while loading capture
+kernel, then you should bump up the memory reservation size.
+
+Now that you've got that reserved memory region set up, you want to turn on
+the kdump init script:
+
+    # systemctl enable kdump.service
+
+Then, start up kdump as well:
+
+    # systemctl start kdump.service
+
+This should turn on the firmware assisted functionality in kernel by
+echo'ing 1 to /sys/kernel/fadump_registered, leaving the system ready
+to capture a vmcore upon crashing. For journaling filesystems like XFS an
+additional step is required to ensure bootloader does not pick the
+older initrd (without vmcore capture scripts):
+
+  * If /boot is a separate partition, run the below commands as the root user,
+    or as a user with CAP_SYS_ADMIN rights:
+
+        # fsfreeze -f
+        # fsfreeze -u
+
+  * If /boot is not a separate partition, reboot the system.
+
+After reboot check if the kdump service is up and running with:
+
+  # systemctl status kdump.service
+
+To test out whether FADump is configured properly, you can force-crash your
+system by echo'ing a 'c' into /proc/sysrq-trigger:
+
+    # echo c > /proc/sysrq-trigger
+
+You should see some panic output, followed by the system reset and booting into
+fresh copy of kernel. When default initrd loads and runs /init, vmcore should
+be copied out to disk (by default, in /var/crash/<YYYY.MM.DD-HH:MM:SS>/vmcore),
+then the system rebooted back into your normal kernel.
+
+Once back to your normal kernel, you can use the previously installed crash
+kernel in conjunction with the previously installed kernel-debuginfo to
+perform postmortem analysis:
+
+    # crash /usr/lib/debug/lib/modules/2.6.17-1.2621.el5/vmlinux
+    /var/crash/2006-08-23-15:34/vmcore
+
+    crash> bt
+
+and so on...
+
+Saving vmcore-dmesg.txt
+-----------------------
+Kernel log bufferes are one of the most important information available
+in vmcore. Now before saving vmcore, kernel log bufferes are extracted
+from /proc/vmcore and saved into a file vmcore-dmesg.txt. After
+vmcore-dmesg.txt, vmcore is saved. Destination disk and directory for
+vmcore-dmesg.txt is same as vmcore. Note that kernel log buffers will
+not be available if dump target is raw device.
+
+FADump Memory Requirements:
+
+  System Memory          Recommended memory
+--------------------- ----------------------
+    4 GB - 16 GB     :        768 MB
+   16 GB - 64 GB     :       1024 MB
+   64 GB - 128 GB    :          2 GB
+  128 GB - 1 TB      :          4 GB
+    1 TB - 2 TB      :          6 GB
+    2 TB - 4 TB      :         12 GB
+    4 TB - 8 TB      :         20 GB
+    8 TB - 16 TB     :         36 GB
+   16 TB - 32 TB     :         64 GB
+   32 TB - 64 TB     :        128 GB
+   64 TB & above     :        180 GB
+
+Things to remember:
+
+1) The memory required to boot capture Kernel is a moving target that depends
+   on many factors like hardware attached to the system, kernel and modules in
+   use, packages installed and services enabled, there is no one-size-fits-all.
+   But the above recommendations are based on system memory. So, the above
+   recommendations for FADump come with a few assumptions, based on available
+   system memory, about the resources the system could have. So, please take
+   the recommendations with a pinch of salt and remember to try capturing dump
+   a few times to confirm that the system is configured successfully with dump
+   capturing support.
+
+2) Though the memory requirements for FADump seem high, this memory is not
+   completely set aside but made available for userspace applications to use,
+   through the CMA allocator.
+
+3) As the same initrd is used for booting production kernel as well as capture
+   kernel and with dump being captured in a restricted memory environment, few
+   optimizations (like not inclding network dracut module, disabling multipath
+   and such) are applied while building the initrd. In case, the production
+   environment needs these optimizations to be avoided, dracut_args option in
+   /etc/kdump.conf file could be leveraged. For example, if a user wishes for
+   network module to be included in the initrd, adding the below entry in
+   /etc/kdump.conf file and restarting kdump service would take care of it.
+
+   dracut_args --add "network"
+
+4) If FADump is configured to capture vmcore to a remote dump target using SSH
+   or NFS protocol, the corresponding network interface '<interface-name>' is
+   renamed to 'kdump-<interface-name>', if it is generic (like *eth# or net#).
+   It happens because vmcore capture scripts in the initial RAM disk (initrd)
+   add the 'kdump-' prefix to the network interface name to secure persistent
+   naming. And as capture kernel and production kernel use the same initrd in
+   case of FADump, the interface name is changed for the production kernel too.
+   This is likely to impact network configuration setup for production kernel.
+   So, it is recommended to use a non-generic name for a network interface,
+   before setting up FADump to capture vmcore to a remote dump target based on
+   that network interface, to avoid running into network configuration issues.
+
+Dump Triggering methods:
+
+This section talks about the various ways, other than a Kernel Panic, in which
+fadump can be triggered. The following methods assume that fadump is configured
+on your system, with the scripts enabled as described in the section above.
+
+1) AltSysRq C
+
+FAdump can be triggered with the combination of the 'Alt','SysRq' and 'C'
+keyboard keys. Please refer to the following link for more details:
+
+https://fedoraproject.org/wiki/QA/Sysrq
+
+In addition, on PowerPC boxes, fadump can also be triggered via Hardware
+Management Console(HMC) using 'Ctrl', 'O' and 'C' keyboard keys.
+
+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) PowerPC specific methods:
+
+On IBM PowerPC machines, issuing a soft reset invokes the XMON debugger(if
+XMON is configured). To configure XMON one needs to compile the kernel with
+the CONFIG_XMON and CONFIG_XMON_DEFAULT options, or by compiling with
+CONFIG_XMON and booting the kernel with xmon=on option.
+
+Following are the ways to remotely issue a soft reset on PowerPC boxes, which
+would drop you to XMON. Pressing a 'X' (capital alphabet X) followed by an
+'Enter' here will trigger the dump.
+
+3.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
+fadump 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
+
+3.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 issues a
+system reset and invokes xmon debugger.
+
+
+Advanced Setups & Failure action:
+
+Kdump and fadump exhibit similar behavior in terms of setup & failure action.
+For fadump advanced setup related information see section "Advanced Setups" in
+"kexec-kdump-howto.txt" document. Refer to "Failure action" section in "kexec-
+kdump-howto.txt" document for fadump failure action related information.
+
+Compression and filtering
+
+Refer "Compression and filtering" section in "kexec-kdump-howto.txt" document.
+Compression and filtering are same for kdump & fadump.
+
+
+Notes on rootfs mount:
+Dracut is designed to mount rootfs by default. If rootfs mounting fails it
+will refuse to go on. So fadump leaves rootfs mounting to dracut currently.
+We make the assumtion that proper root= cmdline is being passed to dracut
+initramfs for the time being. If you need modify "KDUMP_COMMANDLINE=" in
+/etc/sysconfig/kdump, you will need to make sure that appropriate root=
+options are copied from /proc/cmdline. In general it is best to append
+command line options using "KDUMP_COMMANDLINE_APPEND=" instead of replacing
+the original command line completely.
+
+How to disable FADump:
+
+Remove "fadump=on"/"fadump=nocma" from kernel cmdline parameters OR replace
+it with "fadump=off" kernel cmdline parameter:
+
+   # grubby --update-kernel=/boot/vmlinuz-`uname -r` --remove-args="fadump=on"
+or
+   # grubby --update-kernel=/boot/vmlinuz-`uname -r` --remove-args="fadump=nocma"
+OR
+   # grubby --update-kernel=/boot/vmlinuz-`uname -r` --args="fadump=off"
+
+Remove "crashkernel=" from kernel cmdline parameters:
+
+   # grubby --update-kernel=/boot/vmlinuz-`uname -r` --remove-args="crashkernel"
+
+If KDump is to be used as the dump capturing mechanism, reset the crashkernel parameter:
+
+   # kdumpctl reset-crashkernel --fadump=off
+
+Reboot the system for the settings to take effect.

kdump-dep-generator.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+# More details about systemd generator:
+# http://www.freedesktop.org/wiki/Software/systemd/Generators/
+
+. /usr/lib/kdump/kdump-lib.sh
+. /usr/lib/kdump/kdump-logger.sh
+
+# If invokded with no arguments for testing purpose, output to /tmp to
+# avoid overriding the existing.
+dest_dir="/tmp"
+
+if [ -n "$1" ]; then
+    dest_dir=$1
+fi
+
+systemd_dir=/usr/lib/systemd/system
+kdump_wants=$dest_dir/kdump.service.wants
+
+if is_ssh_dump_target; then
+    mkdir -p $kdump_wants
+    ln -sf $systemd_dir/network-online.target $kdump_wants/
+fi

kdump-in-cluster-environment.txt

@@ -0,0 +1,91 @@
+Kdump-in-cluster-environment HOWTO
+
+Introduction
+
+Kdump is a kexec based crash dumping mechansim for Linux. This docuement 
+illustrate how to configure kdump in cluster environment to allow the kdump 
+crash recovery service complete without being preempted by traditional power
+fencing methods. 
+
+Overview
+
+Kexec/Kdump
+
+Details about Kexec/Kdump are available in Kexec-Kdump-howto file and will not
+be described here.
+
+fence_kdump
+
+fence_kdump is an I/O fencing agent to be used with the kdump crash recovery 
+service. When the fence_kdump agent is invoked, it will listen for a message 
+from the failed node that acknowledges that the failed node is executing the 
+kdump crash kernel. Note that fence_kdump is not a replacement for traditional
+fencing methods. The fence_kdump agent can only detect that a node has entered
+the kdump crash recovery service. This allows the kdump crash recovery service
+complete without being preempted by traditional power fencing methods. 
+
+fence_kdump_send
+
+fence_kdump_send is a utility used to send messages that acknowledge that the 
+node itself has entered the kdump crash recovery service. The fence_kdump_send
+utility is typically run in the kdump kernel after a cluster node has 
+encountered a kernel panic. Once the cluster node has entered the kdump crash 
+recovery service, fence_kdump_send will periodically send messages to all 
+cluster nodes. When the fence_kdump agent receives a valid message from the 
+failed nodes, fencing is complete.
+
+How to configure Pacemaker cluster environment:
+
+If we want to use kdump in Pacemaker cluster environment, fence-agents-kdump
+should be installed in every nodes in the cluster. You can achieve this via
+the following command:
+
+  # yum install -y fence-agents-kdump
+
+Next is to add kdump_fence to the cluster. Assuming that the cluster consists 
+of three nodes, they are node1, node2 and node3, and use Pacemaker to perform
+resource management and pcs as cli configuration tool. 
+
+With pcs it is easy to add a stonith resource to the cluster. For example, add
+a stonith resource named mykdumpfence with fence type of fence_kdump via the 
+following commands:
+  
+   # pcs stonith create mykdumpfence fence_kdump \
+     pcmk_host_check=static-list pcmk_host_list="node1 node2 node3"
+   # pcs stonith update mykdumpfence pcmk_monitor_action=metadata --force
+   # pcs stonith update mykdumpfence pcmk_status_action=metadata --force
+   # pcs stonith update mykdumpfence pcmk_reboot_action=off --force
+   
+Then enable stonith
+   # pcs property set stonith-enabled=true
+
+How to configure kdump:
+
+Actually there are two ways how to configure fence_kdump support:
+
+1) Pacemaker based clusters
+     If you have successfully configured fence_kdump in Pacemaker, there is
+     no need to add some special configuration in kdump. So please refer to
+     Kexec-Kdump-howto file for more information.
+
+2) Generic clusters
+     For other types of clusters there are two configuration options in
+     kdump.conf which enables fence_kdump support:
+
+       fence_kdump_nodes <node(s)>
+            Contains list of cluster node(s) separated by space to send
+            fence_kdump notification to (this option is mandatory to enable
+            fence_kdump)
+
+       fence_kdump_args <arg(s)>
+            Command line arguments for fence_kdump_send (it can contain
+            all valid arguments except hosts to send notification to)
+
+     These options will most probably be configured by your cluster software,
+     so please refer to your cluster documentation how to enable fence_kdump
+     support.
+
+Please be aware that these two ways cannot be combined and 2) has precedence
+over 1). It means that if fence_kdump is configured using fence_kdump_nodes
+and fence_kdump_args options in kdump.conf, Pacemaker configuration is not
+used even if it exists.

kdump-lib-initramfs.sh

@@ -0,0 +1,133 @@
+#!/bin/sh
+#
+# The code in this file will be used in initramfs environment, bash may
+# not be the default shell. Any code added must be POSIX compliant.
+
+DEFAULT_PATH="/var/crash/"
+DEFAULT_SSHKEY="/root/.ssh/kdump_id_rsa"
+KDUMP_CONFIG_FILE="/etc/kdump.conf"
+FENCE_KDUMP_CONFIG_FILE="/etc/sysconfig/fence_kdump"
+FENCE_KDUMP_SEND="/usr/libexec/fence_kdump_send"
+
+# Read kdump config in well formated style
+kdump_read_conf()
+{
+	# Following steps are applied in order: strip trailing comment, strip trailing space,
+	# strip heading space, match non-empty line, remove duplicated spaces between conf name and value
+	[ -f "$KDUMP_CONFIG_FILE" ] && sed -n -e "s/#.*//;s/\s*$//;s/^\s*//;s/\(\S\+\)\s*\(.*\)/\1 \2/p" $KDUMP_CONFIG_FILE
+}
+
+# Retrieves config value defined in kdump.conf
+# $1: config name, sed regexp compatible
+kdump_get_conf_val()
+{
+	# For lines matching "^\s*$1\s+", remove matched part (config name including space),
+	# remove tailing comment, space, then store in hold space. Print out the hold buffer on last line.
+	[ -f "$KDUMP_CONFIG_FILE" ] &&
+		sed -n -e "/^\s*\($1\)\s\+/{s/^\s*\($1\)\s\+//;s/#.*//;s/\s*$//;h};\${x;p}" $KDUMP_CONFIG_FILE
+}
+
+is_mounted()
+{
+	findmnt -k -n "$1" > /dev/null 2>&1
+}
+
+# $1: info type
+# $2: mount source type
+# $3: mount source
+# $4: extra args
+get_mount_info()
+{
+	__kdump_mnt=$(findmnt -k -n -r -o "$1" "--$2" "$3" $4)
+
+	[ -z "$__kdump_mnt" ] && [ -e "/etc/fstab" ] && __kdump_mnt=$(findmnt -s -n -r -o "$1" "--$2" "$3" $4)
+
+	echo "$__kdump_mnt"
+}
+
+is_ipv6_address()
+{
+	echo "$1" | grep -q ":"
+}
+
+is_fs_type_nfs()
+{
+	[ "$1" = "nfs" ] || [ "$1" = "nfs4" ]
+}
+
+# If $1 contains dracut_args "--mount", return <filesystem type>
+get_dracut_args_fstype()
+{
+	echo $1 | grep "\-\-mount" | sed "s/.*--mount .\(.*\)/\1/" | cut -d' ' -f3
+}
+
+# If $1 contains dracut_args "--mount", return <device>
+get_dracut_args_target()
+{
+	echo $1 | grep "\-\-mount" | sed "s/.*--mount .\(.*\)/\1/" | cut -d' ' -f1
+}
+
+get_save_path()
+{
+	__kdump_path=$(kdump_get_conf_val path)
+	[ -z "$__kdump_path" ] && __kdump_path=$DEFAULT_PATH
+
+	# strip the duplicated "/"
+	echo "$__kdump_path" | tr -s /
+}
+
+get_root_fs_device()
+{
+	findmnt -k -f -n -o SOURCE /
+}
+
+# Return the current underlying device of a path, ignore bind mounts
+get_target_from_path()
+{
+	__kdump_target=$(df "$1" 2> /dev/null | tail -1 | awk '{print $1}')
+	[ "$__kdump_target" = "/dev/root" ] && [ ! -e /dev/root ] && __kdump_target=$(get_root_fs_device)
+	echo "$__kdump_target"
+}
+
+get_fs_type_from_target()
+{
+	get_mount_info FSTYPE source "$1" -f
+}
+
+get_mntpoint_from_target()
+{
+	# --source is applied to ensure non-bind mount is returned
+	get_mount_info TARGET source "$1" -f
+}
+
+is_ssh_dump_target()
+{
+	kdump_get_conf_val ssh | grep -q @
+}
+
+is_raw_dump_target()
+{
+	[ -n "$(kdump_get_conf_val raw)" ]
+}
+
+is_nfs_dump_target()
+{
+	if [ -n "$(kdump_get_conf_val nfs)" ]; then
+		return 0
+	fi
+
+	if is_fs_type_nfs "$(get_dracut_args_fstype "$(kdump_get_conf_val dracut_args)")"; then
+		return 0
+	fi
+
+	if is_fs_type_nfs "$(get_fs_type_from_target "$(get_target_from_path "$(get_save_path)")")"; then
+		return 0
+	fi
+
+	return 1
+}
+
+is_fs_dump_target()
+{
+	[ -n "$(kdump_get_conf_val "ext[234]\|xfs\|btrfs\|minix")" ]
+}

kdump-logger.sh

@@ -0,0 +1,355 @@
+#!/bin/sh
+#
+# This comes from the dracut-logger.sh
+#
+# The logger defined 4 logging levels:
+#   - ddebug (4)
+#     The DEBUG Level designates fine-grained informational events that are most
+#     useful to debug an application.
+#   - dinfo (3)
+#     The INFO level designates informational messages that highlight the
+#     progress of the application at coarse-grained level.
+#   - dwarn (2)
+#     The WARN level designates potentially harmful situations.
+#   - derror (1)
+#     The ERROR level designates error events that might still allow the
+#     application to continue running.
+#
+# Logging is controlled by following global variables:
+#   - @var kdump_stdloglvl - logging level to standard error (console output)
+#   - @var kdump_sysloglvl - logging level to syslog (by logger command)
+#   - @var kdump_kmsgloglvl - logging level to /dev/kmsg (only for boot-time)
+#
+# If any of the variables is not set, the function dlog_init() sets it to default:
+#   - In the first kernel:
+#     - @var kdump_stdloglvl = 3 (info)
+#     - @var kdump_sysloglvl = 0 (no logging)
+#     - @var kdump_kmsgloglvl = 0 (no logging)
+#
+#   -In the second kernel:
+#    - @var kdump_stdloglvl = 0 (no logging)
+#    - @var kdump_sysloglvl = 3 (info)
+#    - @var kdump_kmsgloglvl = 0 (no logging)
+#
+# First of all you have to start with dlog_init() function which initializes
+# required variables. Don't call any other logging function before that one!
+#
+# The code in this file might be run in an environment without bash.
+# Any code added must be POSIX compliant.
+
+# Define vairables for the log levels in this module.
+kdump_stdloglvl=""
+kdump_sysloglvl=""
+kdump_kmsgloglvl=""
+
+# The dracut-lib.sh is only available in the second kernel, and it won't
+# be used in the first kernel because the dracut-lib.sh is invisible in
+# the first kernel.
+if [ -f /lib/dracut-lib.sh ]; then
+    . /lib/dracut-lib.sh
+fi
+
+# @brief Get the log level from kernel command line.
+# @retval 1 if something has gone wrong
+# @retval 0 on success.
+#
+get_kdump_loglvl()
+{
+    [ -f /lib/dracut-lib.sh ] && kdump_sysloglvl=$(getarg rd.kdumploglvl)
+    [ -z "$kdump_sysloglvl" ] && return 1;
+
+    if [ -f /lib/dracut-lib.sh ] && ! isdigit "$kdump_sysloglvl"; then
+        return 1
+    fi
+
+    return 0
+}
+
+# @brief Check the log level.
+# @retval 1 if something has gone wrong
+# @retval 0 on success.
+#
+check_loglvl()
+{
+    case "$1" in
+        0|1|2|3|4)
+            return 0
+           ;;
+        *)
+            return 1
+            ;;
+        esac
+}
+
+# @brief Initializes Logger.
+# @retval 1 if something has gone wrong
+# @retval 0 on success.
+#
+dlog_init() {
+    ret=0
+
+    if [ -s /proc/vmcore ];then
+        if ! get_kdump_loglvl; then
+            logger -t "kdump[$$]" -p warn -- "Kdump is using the default log level(3)."
+            kdump_sysloglvl=3
+        fi
+        kdump_stdloglvl=0
+        kdump_kmsgloglvl=0
+    else
+        kdump_stdloglvl=$KDUMP_STDLOGLVL
+        kdump_sysloglvl=$KDUMP_SYSLOGLVL
+        kdump_kmsgloglvl=$KDUMP_KMSGLOGLVL
+    fi
+
+    [ -z "$kdump_stdloglvl" ] && kdump_stdloglvl=3
+    [ -z "$kdump_sysloglvl" ] && kdump_sysloglvl=0
+    [ -z "$kdump_kmsgloglvl" ] && kdump_kmsgloglvl=0
+
+    for loglvl in "$kdump_stdloglvl" "$kdump_kmsgloglvl" "$kdump_sysloglvl"; do
+        if ! check_loglvl "$loglvl"; then
+            echo "Illegal log level: $kdump_stdloglvl $kdump_kmsgloglvl $kdump_sysloglvl"
+            return 1
+        fi
+    done
+
+    # Skip initialization if it's already done.
+    [ -n "$kdump_maxloglvl" ] && return 0
+
+    if [ "$UID" -ne 0 ]; then
+        kdump_kmsgloglvl=0
+        kdump_sysloglvl=0
+    fi
+
+    if [ "$kdump_sysloglvl" -gt 0 ]; then
+        if [ -d /run/systemd/journal ] \
+            && systemd-cat --version 1>/dev/null 2>&1 \
+            && systemctl --quiet is-active systemd-journald.socket 1>/dev/null 2>&1; then
+            readonly _systemdcatfile="/var/tmp/systemd-cat"
+            mkfifo "$_systemdcatfile" 1>/dev/null 2>&1
+            readonly _dlogfd=15
+            systemd-cat -t 'kdump' --level-prefix=true <"$_systemdcatfile" &
+            exec 15>"$_systemdcatfile"
+        elif ! [ -S /dev/log ] && [ -w /dev/log ] || ! command -v logger >/dev/null; then
+            # We cannot log to syslog, so turn this facility off.
+            kdump_kmsgloglvl=$kdump_sysloglvl
+            kdump_sysloglvl=0
+            ret=1
+            errmsg="No '/dev/log' or 'logger' included for syslog logging"
+        fi
+    fi
+
+    kdump_maxloglvl=0
+    for _dlog_lvl in $kdump_stdloglvl $kdump_sysloglvl $kdump_kmsgloglvl; do
+        [ $_dlog_lvl -gt $kdump_maxloglvl ] && kdump_maxloglvl=$_dlog_lvl
+    done
+    readonly kdump_maxloglvl
+    export kdump_maxloglvl
+
+    if [ $kdump_stdloglvl -lt 4 ] && [ $kdump_kmsgloglvl -lt 4 ] && [ $kdump_sysloglvl -lt 4 ]; then
+        unset ddebug
+        ddebug() { :; };
+    fi
+
+    if [ $kdump_stdloglvl -lt 3 ] && [ $kdump_kmsgloglvl -lt 3 ] && [ $kdump_sysloglvl -lt 3 ]; then
+        unset dinfo
+        dinfo() { :; };
+    fi
+
+    if [ $kdump_stdloglvl -lt 2 ] && [ $kdump_kmsgloglvl -lt 2 ] && [ $kdump_sysloglvl -lt 2 ]; then
+        unset dwarn
+        dwarn() { :; };
+        unset dwarning
+        dwarning() { :; };
+    fi
+
+    if [ $kdump_stdloglvl -lt 1 ] && [ $kdump_kmsgloglvl -lt 1 ] && [ $kdump_sysloglvl -lt 1 ]; then
+        unset derror
+        derror() { :; };
+    fi
+
+    [ -n "$errmsg" ] && derror "$errmsg"
+
+    return $ret
+}
+
+## @brief Converts numeric level to logger priority defined by POSIX.2.
+#
+# @param $1: Numeric logging level in range from 1 to 4.
+# @retval 1 if @a lvl is out of range.
+# @retval 0 if @a lvl is correct.
+# @result Echoes logger priority.
+_lvl2syspri() {
+    case "$1" in
+        1) echo error;;
+        2) echo warning;;
+        3) echo info;;
+        4) echo debug;;
+        *) return 1;;
+    esac
+}
+
+## @brief Converts logger numeric level to syslog log level
+#
+# @param $1: Numeric logging level in range from 1 to 4.
+# @retval 1 if @a lvl is out of range.
+# @retval 0 if @a lvl is correct.
+# @result Echoes kernel console numeric log level
+#
+# Conversion is done as follows:
+#
+# <tt>
+#   none     -> LOG_EMERG (0)
+#   none     -> LOG_ALERT (1)
+#   none     -> LOG_CRIT (2)
+#   ERROR(1) -> LOG_ERR (3)
+#   WARN(2)  -> LOG_WARNING (4)
+#   none     -> LOG_NOTICE (5)
+#   INFO(3)  -> LOG_INFO (6)
+#   DEBUG(4) -> LOG_DEBUG (7)
+# </tt>
+#
+# @see /usr/include/sys/syslog.h
+_dlvl2syslvl() {
+    case "$1" in
+        1) set -- 3;;
+        2) set -- 4;;
+        3) set -- 6;;
+        4) set -- 7;;
+        *) return 1;;
+    esac
+
+    # The number is constructed by multiplying the facility by 8 and then
+    # adding the level.
+    # About The Syslog Protocol, please refer to the RFC5424 for more details.
+    echo $((24 + $1))
+}
+
+## @brief Prints to stderr, to syslog and/or /dev/kmsg given message with
+#  given level (priority).
+#
+# @param $1: Numeric logging level.
+# @param $2: Message.
+# @retval 0 It's always returned, even if logging failed.
+#
+# @note This function is not supposed to be called manually. Please use
+# dinfo(), ddebug(), or others instead which wrap this one.
+#
+# This is core logging function which logs given message to standard error
+# and/or syslog (with POSIX shell command <tt>logger</tt>) and/or to /dev/kmsg.
+# The format is following:
+#
+# <tt>X: some message</tt>
+#
+# where @c X is the first letter of logging level. See module description for
+# details on that.
+#
+# Message to syslog is sent with tag @c kdump. Priorities are mapped as
+# following:
+#   - @c ERROR to @c error
+#   - @c WARN to @c warning
+#   - @c INFO to @c info
+#   - @c DEBUG to @c debug
+_do_dlog() {
+    [ "$1" -le $kdump_stdloglvl ] && printf -- 'kdump: %s\n' "$2" >&2
+
+    if [ "$1" -le $kdump_sysloglvl ]; then
+        if [ "$_dlogfd" ]; then
+            printf -- "<%s>%s\n" "$(($(_dlvl2syslvl "$1") & 7))" "$2" 1>&$_dlogfd
+        else
+            logger -t "kdump[$$]" -p "$(_lvl2syspri "$1")" -- "$2"
+        fi
+    fi
+
+    [ "$1" -le $kdump_kmsgloglvl ] && \
+        echo "<$(_dlvl2syslvl "$1")>kdump[$$] $2" >/dev/kmsg
+}
+
+## @brief Internal helper function for _do_dlog()
+#
+# @param $1: Numeric logging level.
+# @param $2 [...]: Message.
+# @retval 0 It's always returned, even if logging failed.
+#
+# @note This function is not supposed to be called manually. Please use
+# dinfo(), ddebug(), or others instead which wrap this one.
+#
+# This function calls _do_dlog() either with parameter msg, or if
+# none is given, it will read standard input and will use every line as
+# a message.
+#
+# This enables:
+# dwarn "This is a warning"
+# echo "This is a warning" | dwarn
+dlog() {
+    [ -z "$kdump_maxloglvl" ] && return 0
+    [ "$1" -le "$kdump_maxloglvl" ] || return 0
+
+    if [ $# -gt 1 ]; then
+        _dlog_lvl=$1; shift
+        _do_dlog "$_dlog_lvl" "$*"
+    else
+        while read -r line || [ -n "$line" ]; do
+            _do_dlog "$1" "$line"
+        done
+    fi
+}
+
+## @brief Logs message at DEBUG level (4)
+#
+# @param msg Message.
+# @retval 0 It's always returned, even if logging failed.
+ddebug() {
+    set +x
+    dlog 4 "$@"
+    if [ -n "$debug" ]; then
+        set -x
+    fi
+}
+
+## @brief Logs message at INFO level (3)
+#
+# @param msg Message.
+# @retval 0 It's always returned, even if logging failed.
+dinfo() {
+    set +x
+    dlog 3 "$@"
+    if [ -n "$debug" ]; then
+        set -x
+    fi
+}
+
+## @brief Logs message at WARN level (2)
+#
+# @param msg Message.
+# @retval 0 It's always returned, even if logging failed.
+dwarn() {
+    set +x
+    dlog 2 "$@"
+    if [ -n "$debug" ]; then
+        set -x
+    fi
+}
+
+## @brief It's an alias to dwarn() function.
+#
+# @param msg Message.
+# @retval 0 It's always returned, even if logging failed.
+dwarning() {
+    set +x
+    dwarn "$@"
+    if [ -n "$debug" ]; then
+        set -x
+    fi
+}
+
+## @brief Logs message at ERROR level (1)
+#
+# @param msg Message.
+# @retval 0 It's always returned, even if logging failed.
+derror() {
+    set +x
+    dlog 1 "$@"
+    if [ -n "$debug" ]; then
+        set -x
+    fi
+}

kdump-migrate-action.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+systemctl is-active kdump
+if [ $? -ne 0 ]; then
+        exit 0
+fi
+
+/usr/lib/kdump/kdump-restart.sh

kdump-restart.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+export PATH="$PATH:/usr/bin:/usr/sbin"
+
+exec >>/var/log/kdump-migration.log 2>&1
+
+echo "kdump: Partition Migration detected. Rebuilding initramfs image to reload."
+/usr/bin/kdumpctl rebuild
+/usr/bin/kdumpctl reload

kdump-udev-throttler

@@ -0,0 +1,42 @@
+#!/bin/bash
+# This util helps to reduce the workload of kdump service restarting
+# on udev event. When hotplugging memory / CPU, multiple udev
+# events may be triggered concurrently, and obviously, we don't want
+# to restart kdump service for each event.
+
+# This script will be called by udev, and make sure kdump service is
+# restart after all events we are watching are settled.
+
+# On each call, this script will update try to aquire the $throttle_lock
+# The first instance acquired the file lock will keep waiting for events
+# to settle and then reload kdump. Other instances will just exit
+# In this way, we can make sure kdump service is restarted immediately
+# and for exactly once after udev events are settled.
+
+throttle_lock="/var/lock/kdump-udev-throttle"
+
+exec 9>$throttle_lock
+if [ $? -ne 0 ]; then
+        echo "Failed to create the lock file! Fallback to non-throttled kdump service restart"
+        /bin/kdumpctl reload
+        exit 1
+fi
+
+flock -n 9
+if [ $? -ne 0 ]; then
+        echo "Throttling kdump restart for concurrent udev event"
+        exit 0
+fi
+
+# Wait for at least 1 second, at most 4 seconds for udev to settle
+# Idealy we will have a less than 1 second lag between udev events settle
+# and kdump reload
+sleep 1 && udevadm settle --timeout 3
+
+# Release the lock, /bin/kdumpctl will block and make the process
+# holding two locks at the same time and we might miss some events
+exec 9>&-
+
+/bin/kdumpctl reload
+
+exit 0

kdump.conf

@@ -0,0 +1,192 @@
+# This file contains a series of commands to perform (in order) in the kdump
+# kernel after a kernel crash in the crash kernel(1st kernel) has happened.
+#
+# Directives in this file are only applicable to the kdump initramfs, and have
+# no effect once the root filesystem is mounted and the normal init scripts are
+# processed.
+#
+# Currently, only one dump target and path can be specified.  If the dumping to
+# the configured target fails, the failure action which can be configured via
+# the "failure_action" directive will be performed.
+#
+# Supported options:
+#
+# auto_reset_crashkernel <yes|no>
+#           - whether to reset kernel crashkernel to new default value
+#             or not when kexec-tools updates the default crashkernel value and
+#             existing kernels using the old default kernel crashkernel value.
+#             The default value is yes.
+#
+# raw <partition>
+#           - Will dd /proc/vmcore into <partition>.
+#             Use persistent device names for partition devices,
+#             such as /dev/vg/<devname>.
+#
+# nfs <nfs mount>
+#           - Will mount nfs to <mnt>, and copy /proc/vmcore to
+#             <mnt>/<path>/%HOST-%DATE/, supports DNS.
+#
+# ssh <user@server>
+#           - Will save /proc/vmcore to <user@server>:<path>/%HOST-%DATE/,
+#             supports DNS.
+#             NOTE: make sure the user has write permissions on the server.
+#
+# sshkey <path>
+#           - Will use the sshkey to do ssh dump.
+#             Specify the path of the ssh key to use when dumping
+#             via ssh. The default value is /root/.ssh/kdump_id_rsa.
+#
+# <fs type> <partition>
+#           - Will mount -t <fs type> <partition> <mnt>, and copy
+#             /proc/vmcore to <mnt>/<path>/%HOST_IP-%DATE/.
+#             NOTE: <partition> can be a device node, label or uuid.
+#             It's recommended to use persistent device names
+#             such as /dev/vg/<devname>.
+#             Otherwise it's suggested to use label or uuid.
+#
+# path <path>
+#           - "path" represents the file system path in which vmcore
+#             will be saved.  If a dump target is specified in
+#             kdump.conf, then "path" is relative to the specified
+#             dump target.
+#
+#             Interpretation of "path" changes a bit if the user didn't
+#             specify any dump target explicitly in kdump.conf.  In this
+#             case, "path" represents the absolute path from root. The
+#             dump target and adjusted path are arrived at automatically
+#             depending on what's mounted in the current system.
+#
+#             Ignored for raw device dumps.  If unset, will use the default
+#             "/var/crash".
+#
+# core_collector <command> <options>
+#           - This allows you to specify the command to copy
+#             the vmcore.  The default is makedumpfile, which on
+#             some architectures can drastically reduce vmcore size.
+#             See /sbin/makedumpfile --help for a list of options.
+#             Note that the -i and -g options are not needed here,
+#             as the initrd will automatically be populated with a
+#             config file appropriate for the running kernel.
+#             The default core_collector for raw/ssh dump is:
+#             "makedumpfile -F -l --message-level 7 -d 31".
+#             The default core_collector for other targets is:
+#             "makedumpfile -l --message-level 7 -d 31".
+#
+#             "makedumpfile -F" will create a flattened vmcore.
+#             You need to use "makedumpfile -R" to rearrange the dump data to
+#             a normal dumpfile readable with analysis tools.  For example:
+#             "makedumpfile -R vmcore < vmcore.flat".
+#
+#             For core_collector format details, you can refer to
+#             kexec-kdump-howto.txt or kdump.conf manpage.
+#
+# kdump_post <binary | script>
+#           - This directive allows you to run a executable binary
+#             or script after the vmcore dump process terminates.
+#             The exit status of the current dump process is fed to
+#             the executable binary or script as its first argument.
+#             All files under /etc/kdump/post.d are collectively sorted
+#             and executed in lexical order, before binary or script
+#             specified kdump_post parameter is executed.
+#
+# kdump_pre <binary | script>
+#           - Works like the "kdump_post" directive, but instead of running
+#             after the dump process, runs immediately before it.
+#             Exit status of this binary is interpreted as follows:
+#               0 - continue with dump process as usual
+#               non 0 - run the final action (reboot/poweroff/halt)
+#             All files under /etc/kdump/pre.d are collectively sorted and
+#             executed in lexical order, after binary or script specified
+#             kdump_pre parameter is executed.
+#             Even if the binary or script in /etc/kdump/pre.d directory
+#             returns non 0 exit status, the processing is continued.
+#
+# extra_bins <binaries | shell scripts>
+#           - This directive allows you to specify additional binaries or
+#             shell scripts to be included in the kdump initrd.
+#             Generally they are useful in conjunction with a kdump_post
+#             or kdump_pre binary or script which depends on these extra_bins.
+#
+# extra_modules <module(s)>
+#           - This directive allows you to specify extra kernel modules
+#             that you want to be loaded in the kdump initrd.
+#             Multiple modules can be listed, separated by spaces, and any
+#             dependent modules will automatically be included.
+#
+# failure_action <reboot | halt | poweroff | shell | dump_to_rootfs>
+#           - Action to perform in case dumping fails.
+#             reboot:   Reboot the system.
+#             halt:     Halt the system.
+#             poweroff: Power down the system.
+#             shell:    Drop to a bash shell.
+#                       Exiting the shell reboots the system by default,
+#                       or perform "final_action".
+#             dump_to_rootfs:  Dump vmcore to rootfs from initramfs context and
+#                       reboot by default or perform "final_action".
+#                       Useful when non-root dump target is specified.
+#             The default option is "reboot".
+#
+# default <reboot | halt | poweroff | shell | dump_to_rootfs>
+#           - Same as the "failure_action" directive above, but this directive
+#             is obsolete and will be removed in the future.
+#
+# final_action <reboot | halt | poweroff>
+#           - Action to perform in case dumping succeeds. Also performed
+#             when "shell" or "dump_to_rootfs" failure action finishes.
+#             Each action is same as the "failure_action" directive above.
+#             The default is "reboot".
+#
+# force_rebuild <0 | 1>
+#           - By default, kdump initrd will only be rebuilt when necessary.
+#             Specify 1 to force rebuilding kdump initrd every time when kdump
+#             service starts.
+#
+# force_no_rebuild <0 | 1>
+#           - By default, kdump initrd will be rebuilt when necessary.
+#             Specify 1 to bypass rebuilding of kdump initrd.
+#
+#             force_no_rebuild and force_rebuild options are mutually
+#             exclusive and they should not be set to 1 simultaneously.
+#
+# override_resettable <0 | 1>
+#           - Usually an unresettable block device can't be a dump target.
+#             Specifying 1 when you want to dump even though the block
+#             target is unresettable
+#             By default, it is 0, which will not try dumping destined to fail.
+#
+# dracut_args <arg(s)>
+#           - Pass extra dracut options when rebuilding kdump initrd.
+#
+# fence_kdump_args <arg(s)>
+#           - Command line arguments for fence_kdump_send (it can contain
+#             all valid arguments except hosts to send notification to).
+#
+# fence_kdump_nodes <node(s)>
+#           - List of cluster node(s) except localhost, separated by spaces,
+#             to send fence_kdump notifications to.
+#             (this option is mandatory to enable fence_kdump).
+#
+
+#raw /dev/vg/lv_kdump
+#ext4 /dev/vg/lv_kdump
+#ext4 LABEL=/boot
+#ext4 UUID=03138356-5e61-4ab3-b58e-27507ac41937
+#nfs my.server.com:/export/tmp
+#nfs [2001:db8::1:2:3:4]:/export/tmp
+#ssh user@my.server.com
+#ssh user@2001:db8::1:2:3:4
+#sshkey /root/.ssh/kdump_id_rsa
+auto_reset_crashkernel yes
+path /var/crash
+core_collector makedumpfile -l --message-level 7 -d 31
+#core_collector scp
+#kdump_post /var/crash/scripts/kdump-post.sh
+#kdump_pre /var/crash/scripts/kdump-pre.sh
+#extra_bins /usr/bin/lftp
+#extra_modules gfs2
+#failure_action shell
+#force_rebuild 1
+#force_no_rebuild 1
+#dracut_args --omit-drivers "cfg80211 snd" --add-drivers "ext2 ext3"
+#fence_kdump_args -p 7410 -f auto -c 0 -i 10
+#fence_kdump_nodes node1 node2

kdump.conf.5

@@ -0,0 +1,387 @@
+.TH KDUMP.CONF 5 "07/23/2008" "kexec-tools"
+
+.SH NAME
+kdump.conf \- configuration file for kdump kernel.
+
+.SH DESCRIPTION 
+
+kdump.conf is a configuration file for the kdump kernel crash
+collection service.
+
+kdump.conf provides post-kexec instructions to the kdump kernel. It is
+stored in the initrd file managed by the kdump service. If you change
+this file and do not want to reboot in order for the changes to take
+effect, restart the kdump service to rebuild the initrd.
+
+For most configurations, you can simply review the examples provided
+in the stock /etc/kdump.conf.
+
+.B NOTE: 
+For filesystem dumps the dump target must be mounted before building
+kdump initramfs.
+
+kdump.conf only affects the behavior of the initramfs.  Please read the
+kdump operational flow section of kexec-kdump-howto.txt in the docs to better
+understand how this configuration file affects the behavior of kdump.
+
+.SH OPTIONS
+
+.B auto_reset_crashkernel <yes|no>
+.RS
+determine whether to reset kernel crashkernel to new default value
+or not when kexec-tools updates the default crashkernel value and
+existing kernels using the old default kernel crashkernel value
+
+.B raw <partition>
+.RS
+Will dd /proc/vmcore into <partition>.  Use persistent device names for
+partition devices, such as /dev/vg/<devname>.
+.RE
+
+.B nfs <nfs mount>
+.RS
+Will mount nfs to <mnt>, and copy /proc/vmcore to <mnt>/<path>/%HOST-%DATE/,
+supports DNS. Note that a fqdn should be used as the server name in the 
+mount point.
+.RE
+
+.B ssh <user@server>
+.RS
+Will save /proc/vmcore through ssh pipe to <user@server>:<path>/%HOST-%DATE/,
+supports DNS. NOTE: make sure user has necessary write permissions on
+server and that a fqdn is used as the server name.
+.RE
+
+.B sshkey <path>
+.RS
+Specify the path of the ssh key to use when dumping via ssh.
+The default value is /root/.ssh/kdump_id_rsa.
+.RE
+
+.B <fs type> <partition>
+.RS
+Will mount -t <fs type> <partition> <mnt>, and copy /proc/vmcore to
+<mnt>/<path>/%HOST_IP-%DATE/.  NOTE: <partition> can be a device node, label
+or uuid.  It's recommended to use persistent device names such as
+/dev/vg/<devname>.  Otherwise it's suggested to use label or uuid.
+.RE
+
+.B path <path>
+.RS
+"path" represents the file system path in which vmcore will be saved.
+If a dump target is specified in kdump.conf, then "path" is relative to the
+specified dump target.
+.PP
+Interpretation of "path" changes a bit if the user didn't specify any dump
+target explicitly in kdump.conf. In this case, "path" represents the
+absolute path from root.  The dump target and adjusted path are arrived
+at automatically depending on what's mounted in the current system.
+.PP
+Ignored for raw device dumps.  If unset, will use the default "/var/crash".
+.RE
+
+.B core_collector <command> <options>
+.RS
+This allows you to specify the command to copy the vmcore.
+The default is makedumpfile, which on some architectures can drastically reduce
+core file size. See /sbin/makedumpfile --help for a list of options.
+Note that the -i and -g options are not needed here, as the initrd
+will automatically be populated with a config file appropriate
+for the running kernel.
+.PP
+Note 1: About default core collector:
+The default core_collector for raw/ssh dump is:
+"makedumpfile -F -l --message-level 7 -d 31".
+The default core_collector for other targets is:
+"makedumpfile -l --message-level 7 -d 31".
+Even if core_collector option is commented out in kdump.conf, makedumpfile
+is the default core collector and kdump uses it internally.
+If one does not want makedumpfile as default core_collector, then they
+need to specify one using core_collector option to change the behavior.
+.PP
+Note 2: If "makedumpfile -F" is used then you will get a flattened format
+vmcore.flat, you will need to use "makedumpfile -R" to rearrange the
+dump data from standard input to a normal dumpfile (readable with analysis
+tools).
+ie. "makedumpfile -R vmcore < vmcore.flat"
+.PP
+Note 3: If specified core_collector simply copy the vmcore file to the
+dump target (eg: cp, scp), the vmcore could be significantly large.
+Please make sure the dump target has enough space, at leaset larger
+than the system's RAM.
+
+.RE
+
+.B kdump_post <binary | script>
+.RS
+This directive allows you to run a specified executable
+just after the vmcore dump process terminates.  The exit
+status of the current dump process is fed to the kdump_post
+executable as its first argument($1).  Executable can modify
+it to indicate the new exit status of succeeding dump process,
+.PP
+All files under /etc/kdump/post.d are collectively sorted
+and executed in lexical order, before binary or script
+specified kdump_post parameter is executed.
+.PP
+Note that scripts written for use with this directive must use the /bin/bash
+interpreter. And since these scripts run in kdump enviroment, the reference to
+the storage or network device in the scripts should adhere to the section
+'Supported dump target types and requirements' in kexec-kdump-howto.txt.
+
+.RE
+
+.B kdump_pre <binary | script>
+.RS
+Works just like the "kdump_post" directive, but instead
+of running after the dump process, runs immediately
+before.  Exit status of this binary is interpreted
+as follows:
+.PP
+0 - continue with dump process as usual
+.PP
+non 0 - run the final action (reboot/poweroff/halt)
+.PP
+All files under /etc/kdump/pre.d are collectively sorted and
+executed in lexical order, after binary or script specified
+kdump_pre parameter is executed.
+Even if the binary or script in /etc/kdump/pre.d directory
+returns non 0 exit status, the processing is continued.
+.PP
+Note that scripts written for use with this directive must use the /bin/bash
+interpreter. And since these scripts run in kdump enviroment, the reference to
+the storage or network device in the scripts should adhere to the section
+'Supported dump target types and requirements' in kexec-kdump-howto.txt.
+
+.RE
+
+.B extra_bins <binaries | shell scripts>
+.RS
+This directive allows you to specify additional
+binaries or shell scripts you'd like to include in
+your kdump initrd. Generally only useful in
+conjunction with a kdump_post binary or script that
+relies on other binaries or scripts.
+.RE
+
+.B extra_modules <module(s)>
+.RS
+This directive allows you to specify extra kernel
+modules that you want to be loaded in the kdump
+initrd, typically used to set up access to
+non-boot-path dump targets that might otherwise
+not be accessible in the kdump environment. Multiple
+modules can be listed, separated by spaces, and any
+dependent modules will automatically be included.
+.RE
+
+.B failure_action <reboot | halt | poweroff | shell | dump_to_rootfs>
+.RS
+Action to perform in case dumping to the intended target fails. The default is "reboot".
+reboot: Reboot the system (this is what most people will want, as it returns the system
+to a normal state).  halt: Halt the system and lose the vmcore.  poweroff: The system
+will be powered down.  shell: Drop to a shell session inside the initramfs, from which
+you can manually perform additional recovery actions.  Exiting this shell reboots the
+system by default or performs "final_action".
+Note: kdump uses bash as the default shell.  dump_to_rootfs: If non-root dump
+target is specified, the failure action can be set as dump_to_rootfs.  That means when
+dumping to target fails, dump vmcore to rootfs from initramfs context and reboot
+by default or perform "final_action".
+.RE
+
+.B default <reboot | halt | poweroff | shell | dump_to_rootfs>
+.RS
+Same as the "failure_action" directive above, but this directive is obsolete
+and will be removed in the future.
+.RE
+
+.B final_action <reboot | halt | poweroff>
+.RS
+Action to perform in case dumping to the intended target succeeds.
+Also performed when "shell" or "dump_to_rootfs" failure action finishes.
+Each action is same as the "failure_action" directive above.
+The default is "reboot".
+.RE
+
+.B force_rebuild <0 | 1>
+.RS
+By default, kdump initrd will only be rebuilt when necessary.
+Specify 1 to force rebuilding kdump initrd every time when kdump service starts.
+.RE
+
+.B force_no_rebuild <0 | 1>
+.RS
+By default, kdump initrd will be rebuilt when necessary.
+Specify 1 to bypass rebuilding of kdump initrd.
+
+.PP
+force_no_rebuild and force_rebuild options are mutually exclusive and
+they should not be set to 1 simultaneously.
+.RE
+
+.B override_resettable <0 | 1>
+.RS
+Usually an unresettable block device can't be a dump target. Specifying 1 means
+that even though the block target is unresettable, the user wants to try dumping anyway.
+By default, it's set to 0, which will not try something destined to fail.
+.RE
+
+
+.B dracut_args <arg(s)>
+.RS
+Kdump uses dracut to generate initramfs for second kernel. This option
+allows a user to pass arguments to dracut directly.
+.RE
+
+
+.B fence_kdump_args <arg(s)>
+.RS
+Command line arguments for fence_kdump_send (it can contain all valid
+arguments except hosts to send notification to).
+.RE
+
+
+.B fence_kdump_nodes <node(s)>
+.RS
+List of cluster node(s) except localhost, separated by spaces, to send fence_kdump notification
+to (this option is mandatory to enable fence_kdump).
+.RE
+
+
+.SH DEPRECATED OPTIONS
+
+.B net <nfs mount>|<user@server>
+.RS
+net option is replaced by nfs and ssh options. Use nfs or ssh options
+directly.
+.RE
+
+.B options <module> <option list>
+.RS
+Use KDUMP_COMMANDLINE_APPEND in /etc/sysconfig/kdump to add module options as
+kernel command line parameters. For example, specify 'loop.max_loop=1' to limit
+maximum loop devices to 1.
+.RE
+
+.B link_delay <seconds>
+.RS
+link_delay was used to wait for a network device to initialize before using it.
+Now dracut network module takes care of this issue automatically.
+.RE
+
+.B disk_timeout <seconds>
+.RS
+Similar to link_delay, dracut ensures disks are ready before kdump uses them.
+.RE
+
+.B debug_mem_level <0-3>
+.RS
+Turn on verbose debug output of kdump scripts regarding free/used memory at
+various points of execution.  This feature has been
+moved to dracut now.
+Use KDUMP_COMMANDLINE_APPEND in /etc/sysconfig/kdump and
+append dracut cmdline param rd.memdebug=[0-3] to enable the debug output.
+
+Higher level means more debugging output.
+.PP
+0 - no output
+.PP
+1 - partial /proc/meminfo
+.PP
+2 - /proc/meminfo
+.PP
+3 - /proc/meminfo + /proc/slabinfo
+.RE
+
+.B blacklist <list of kernel modules>
+.RS
+blacklist option was recently being used to prevent loading modules in
+initramfs. General terminology for blacklist has been that module is
+present in initramfs but it is not actually loaded in kernel. Hence
+retaining blacklist option creates more confusing behavior. It has been
+deprecated.
+.PP
+Instead, use rd.driver.blacklist option on second kernel to blacklist
+a certain module. One can edit /etc/sysconfig/kdump.conf and edit
+KDUMP_COMMANDLINE_APPEND to pass kernel command line options. Refer
+to dracut.cmdline man page for more details on module blacklist option.
+.RE
+
+.RE
+
+.SH EXAMPLES
+Here are some examples for core_collector option:
+.PP
+Core collector command format depends on dump target type. Typically for
+filesystem (local/remote), core_collector should accept two arguments.
+First one is source file and second one is target file. For ex.
+.TP
+ex1.
+core_collector "cp --sparse=always"
+
+Above will effectively be translated to:
+
+cp --sparse=always /proc/vmcore <dest-path>/vmcore
+.TP
+ex2.
+core_collector "makedumpfile -l --message-level 7 -d 31"
+
+Above will effectively be translated to:
+
+makedumpfile -l --message-level 7 -d 31 /proc/vmcore <dest-path>/vmcore
+.PP
+For dump targets like raw and ssh, in general, core collector should expect
+one argument (source file) and should output the processed core on standard
+output (There is one exception of "scp", discussed later). This standard
+output will be saved to destination using appropriate commands.
+
+raw dumps examples:
+.TP
+ex3.
+core_collector "cat"
+
+Above will effectively be translated to.
+
+cat /proc/vmcore | dd of=<target-device>
+.TP
+ex4.
+core_collector "makedumpfile -F -l --message-level 7 -d 31"
+
+Above will effectively be translated to.
+
+makedumpfile -F -l --message-level 7 -d 31 | dd of=<target-device>
+.PP
+ssh dumps examples
+.TP
+ex5.
+core_collector "cat"
+
+Above will effectively be translated to.
+
+cat /proc/vmcore | ssh <options> <remote-location> "dd of=path/vmcore"
+.TP
+ex6.
+core_collector "makedumpfile -F -l --message-level 7 -d 31"
+
+Above will effectively be translated to.
+
+makedumpfile -F -l --message-level 7 -d 31 | ssh <options> <remote-location> "dd of=path/vmcore"
+
+There is one exception to standard output rule for ssh dumps. And that is
+scp. As scp can handle ssh destinations for file transfers, one can
+specify "scp" as core collector for ssh targets (no output on stdout).
+.TP
+ex7.
+core_collector "scp"
+
+Above will effectively be translated to.
+
+scp /proc/vmcore <user@host>:path/vmcore
+
+.PP
+examples for other options please see
+.I /etc/kdump.conf
+
+.SH SEE ALSO
+
+kexec(8) mkdumprd(8) dracut.cmdline(7)

kdump.service

@@ -0,0 +1,16 @@
+[Unit]
+Description=Crash recovery kernel arming
+After=network.target network-online.target remote-fs.target basic.target
+DefaultDependencies=no
+ConditionKernelCommandLine=crashkernel
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/kdumpctl start
+ExecStop=/usr/bin/kdumpctl stop
+ExecReload=/usr/bin/kdumpctl reload
+RemainAfterExit=yes
+StartLimitInterval=0
+
+[Install]
+WantedBy=multi-user.target

kdump.sysconfig

@@ -0,0 +1,53 @@
+# Kernel Version string for the -kdump kernel, such as 2.6.13-1544.FC5kdump
+# 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.
+KDUMP_KERNELVER=""
+
+# 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=/"
+# Dracut depends on proper root= options, so please make sure that appropriate
+# root= options are copied from /proc/cmdline. In general it is best to append
+# command line options using "KDUMP_COMMANDLINE_APPEND=".
+# If a command line is not specified, the default will be taken from
+# /proc/cmdline
+KDUMP_COMMANDLINE=""
+
+# This variable lets us remove arguments from the current kdump commandline
+# as taken from either KDUMP_COMMANDLINE above, or from /proc/cmdline
+# NOTE: some arguments such as crashkernel will always be removed
+KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet log_buf_len swiotlb cma hugetlb_cma ignition.firstboot"
+
+# This variable lets us append arguments to the current kdump commandline
+# after processed by KDUMP_COMMANDLINE_REMOVE
+KDUMP_COMMANDLINE_APPEND="irqpoll maxcpus=1 reset_devices novmcoredd cma=0 hugetlb_cma=0"
+
+# Any additional kexec arguments required.  In most situations, this should
+# be left empty
+#
+# Example:
+#   KEXEC_ARGS="--elf32-core-headers"
+KEXEC_ARGS=""
+
+#Where to find the boot image
+#KDUMP_BOOTDIR="/boot"
+
+#What is the image type used for kdump
+KDUMP_IMG="vmlinuz"
+
+# Logging is controlled by following variables in the first kernel:
+#   - @var KDUMP_STDLOGLVL - logging level to standard error (console output)
+#   - @var KDUMP_SYSLOGLVL - logging level to syslog (by logger command)
+#   - @var KDUMP_KMSGLOGLVL - logging level to /dev/kmsg (only for boot-time)
+#
+# In the second kernel, kdump will use the rd.kdumploglvl option to set the
+# log level in the above KDUMP_COMMANDLINE_APPEND.
+#   - @var rd.kdumploglvl - logging level to syslog (by logger command)
+#   - for example: add the rd.kdumploglvl=3 option to KDUMP_COMMANDLINE_APPEND
+#
+# Logging levels: no logging(0), error(1),warn(2),info(3),debug(4)
+#
+# KDUMP_STDLOGLVL=3
+# KDUMP_SYSLOGLVL=0
+# KDUMP_KMSGLOGLVL=0

kdump.sysconfig.aarch64

@@ -0,0 +1,53 @@
+# Kernel Version string for the -kdump kernel, such as 2.6.13-1544.FC5kdump
+# 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.
+KDUMP_KERNELVER=""
+
+# 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=/"
+# Dracut depends on proper root= options, so please make sure that appropriate
+# root= options are copied from /proc/cmdline. In general it is best to append
+# command line options using "KDUMP_COMMANDLINE_APPEND=".
+# If a command line is not specified, the default will be taken from
+# /proc/cmdline
+KDUMP_COMMANDLINE=""
+
+# This variable lets us remove arguments from the current kdump commandline
+# as taken from either KDUMP_COMMANDLINE above, or from /proc/cmdline
+# NOTE: some arguments such as crashkernel will always be removed
+KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet log_buf_len swiotlb cma hugetlb_cma ignition.firstboot"
+
+# This variable lets us append arguments to the current kdump commandline
+# after processed by KDUMP_COMMANDLINE_REMOVE
+KDUMP_COMMANDLINE_APPEND="irqpoll nr_cpus=1 reset_devices cgroup_disable=memory udev.children-max=2 panic=10 swiotlb=noforce novmcoredd cma=0 hugetlb_cma=0"
+
+# Any additional kexec arguments required.  In most situations, this should
+# be left empty
+#
+# Example:
+#   KEXEC_ARGS="--elf32-core-headers"
+KEXEC_ARGS="-s"
+
+#Where to find the boot image
+#KDUMP_BOOTDIR="/boot"
+
+#What is the image type used for kdump
+KDUMP_IMG="vmlinuz"
+
+# Logging is controlled by following variables in the first kernel:
+#   - @var KDUMP_STDLOGLVL - logging level to standard error (console output)
+#   - @var KDUMP_SYSLOGLVL - logging level to syslog (by logger command)
+#   - @var KDUMP_KMSGLOGLVL - logging level to /dev/kmsg (only for boot-time)
+#
+# In the second kernel, kdump will use the rd.kdumploglvl option to set the
+# log level in the above KDUMP_COMMANDLINE_APPEND.
+#   - @var rd.kdumploglvl - logging level to syslog (by logger command)
+#   - for example: add the rd.kdumploglvl=3 option to KDUMP_COMMANDLINE_APPEND
+#
+# Logging levels: no logging(0), error(1),warn(2),info(3),debug(4)
+#
+# KDUMP_STDLOGLVL=3
+# KDUMP_SYSLOGLVL=0
+# KDUMP_KMSGLOGLVL=0

kdump.sysconfig.i386

@@ -0,0 +1,56 @@
+# Kernel Version string for the -kdump kernel, such as 2.6.13-1544.FC5kdump
+# 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.
+KDUMP_KERNELVER=""
+
+# 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=/"
+# Dracut depends on proper root= options, so please make sure that appropriate
+# root= options are copied from /proc/cmdline. In general it is best to append
+# command line options using "KDUMP_COMMANDLINE_APPEND=".
+# If a command line is not specified, the default will be taken from
+# /proc/cmdline
+KDUMP_COMMANDLINE=""
+
+# This variable lets us remove arguments from the current kdump commandline
+# as taken from either KDUMP_COMMANDLINE above, or from /proc/cmdline
+# NOTE: some arguments such as crashkernel will always be removed
+KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet log_buf_len swiotlb cma hugetlb_cma ignition.firstboot"
+
+# This variable lets us append arguments to the current kdump commandline
+# after processed by KDUMP_COMMANDLINE_REMOVE
+KDUMP_COMMANDLINE_APPEND="irqpoll nr_cpus=1 reset_devices numa=off udev.children-max=2 panic=10 transparent_hugepage=never novmcoredd cma=0 hugetlb_cma=0"
+
+# Any additional kexec arguments required.  In most situations, this should
+# be left empty
+#
+# Example:
+#   KEXEC_ARGS="--elf32-core-headers"
+KEXEC_ARGS=""
+
+#Where to find the boot image
+#KDUMP_BOOTDIR="/boot"
+
+#What is the image type used for kdump
+KDUMP_IMG="vmlinuz"
+
+#What is the images extension.  Relocatable kernels don't have one
+KDUMP_IMG_EXT=""
+
+# Logging is controlled by following variables in the first kernel:
+#   - @var KDUMP_STDLOGLVL - logging level to standard error (console output)
+#   - @var KDUMP_SYSLOGLVL - logging level to syslog (by logger command)
+#   - @var KDUMP_KMSGLOGLVL - logging level to /dev/kmsg (only for boot-time)
+#
+# In the second kernel, kdump will use the rd.kdumploglvl option to set the
+# log level in the above KDUMP_COMMANDLINE_APPEND.
+#   - @var rd.kdumploglvl - logging level to syslog (by logger command)
+#   - for example: add the rd.kdumploglvl=3 option to KDUMP_COMMANDLINE_APPEND
+#
+# Logging levels: no logging(0), error(1),warn(2),info(3),debug(4)
+#
+# KDUMP_STDLOGLVL=3
+# KDUMP_SYSLOGLVL=0
+# KDUMP_KMSGLOGLVL=0

kdump.sysconfig.ppc64

@@ -0,0 +1,58 @@
+# Kernel Version string for the -kdump kernel, such as 2.6.13-1544.FC5kdump
+# 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.
+KDUMP_KERNELVER=""
+
+# 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=/"
+# Dracut depends on proper root= options, so please make sure that appropriate
+# root= options are copied from /proc/cmdline. In general it is best to append
+# command line options using "KDUMP_COMMANDLINE_APPEND=".
+# If a command line is not specified, the default will be taken from
+# /proc/cmdline
+KDUMP_COMMANDLINE=""
+
+# This variable lets us remove arguments from the current kdump commandline
+# as taken from either KDUMP_COMMANDLINE above, or from /proc/cmdline
+# NOTE: some arguments such as crashkernel will always be removed
+KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet log_buf_len swiotlb hugetlb_cma ignition.firstboot"
+
+# This variable lets us append arguments to the current kdump commandline
+# after processed by KDUMP_COMMANDLINE_REMOVE
+KDUMP_COMMANDLINE_APPEND="irqpoll maxcpus=1 noirqdistrib reset_devices cgroup_disable=memory numa=off udev.children-max=2 ehea.use_mcs=0 panic=10 kvm_cma_resv_ratio=0 transparent_hugepage=never novmcoredd hugetlb_cma=0"
+
+# Any additional kexec arguments required.  In most situations, this should
+# be left empty
+#
+# Example:
+#   KEXEC_ARGS="--elf32-core-headers"
+KEXEC_ARGS="--dt-no-old-root"
+
+#Where to find the boot image
+#KDUMP_BOOTDIR="/boot"
+
+#What is the image type used for kdump
+KDUMP_IMG="vmlinuz"
+
+#What is the images extension.  Relocatable kernels don't have one
+KDUMP_IMG_EXT=""
+
+#Specify the action after failure
+
+# Logging is controlled by following variables in the first kernel:
+#   - @var KDUMP_STDLOGLVL - logging level to standard error (console output)
+#   - @var KDUMP_SYSLOGLVL - logging level to syslog (by logger command)
+#   - @var KDUMP_KMSGLOGLVL - logging level to /dev/kmsg (only for boot-time)
+#
+# In the second kernel, kdump will use the rd.kdumploglvl option to set the
+# log level in the above KDUMP_COMMANDLINE_APPEND.
+#   - @var rd.kdumploglvl - logging level to syslog (by logger command)
+#   - for example: add the rd.kdumploglvl=3 option to KDUMP_COMMANDLINE_APPEND
+#
+# Logging levels: no logging(0), error(1),warn(2),info(3),debug(4)
+#
+# KDUMP_STDLOGLVL=3
+# KDUMP_SYSLOGLVL=0
+# KDUMP_KMSGLOGLVL=0

kdump.sysconfig.ppc64le

@@ -0,0 +1,58 @@
+# Kernel Version string for the -kdump kernel, such as 2.6.13-1544.FC5kdump
+# 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.
+KDUMP_KERNELVER=""
+
+# 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=/"
+# Dracut depends on proper root= options, so please make sure that appropriate
+# root= options are copied from /proc/cmdline. In general it is best to append
+# command line options using "KDUMP_COMMANDLINE_APPEND=".
+# If a command line is not specified, the default will be taken from
+# /proc/cmdline
+KDUMP_COMMANDLINE=""
+
+# This variable lets us remove arguments from the current kdump commandline
+# as taken from either KDUMP_COMMANDLINE above, or from /proc/cmdline
+# NOTE: some arguments such as crashkernel will always be removed
+KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet log_buf_len swiotlb hugetlb_cma ignition.firstboot"
+
+# This variable lets us append arguments to the current kdump commandline
+# after processed by KDUMP_COMMANDLINE_REMOVE
+KDUMP_COMMANDLINE_APPEND="irqpoll maxcpus=1 noirqdistrib reset_devices cgroup_disable=memory numa=off udev.children-max=2 ehea.use_mcs=0 panic=10 kvm_cma_resv_ratio=0 transparent_hugepage=never novmcoredd hugetlb_cma=0"
+
+# Any additional kexec arguments required.  In most situations, this should
+# be left empty
+#
+# Example:
+#   KEXEC_ARGS="--elf32-core-headers"
+KEXEC_ARGS="--dt-no-old-root -s"
+
+#Where to find the boot image
+#KDUMP_BOOTDIR="/boot"
+
+#What is the image type used for kdump
+KDUMP_IMG="vmlinuz"
+
+#What is the images extension.  Relocatable kernels don't have one
+KDUMP_IMG_EXT=""
+
+#Specify the action after failure
+
+# Logging is controlled by following variables in the first kernel:
+#   - @var KDUMP_STDLOGLVL - logging level to standard error (console output)
+#   - @var KDUMP_SYSLOGLVL - logging level to syslog (by logger command)
+#   - @var KDUMP_KMSGLOGLVL - logging level to /dev/kmsg (only for boot-time)
+#
+# In the second kernel, kdump will use the rd.kdumploglvl option to set the
+# log level in the above KDUMP_COMMANDLINE_APPEND.
+#   - @var rd.kdumploglvl - logging level to syslog (by logger command)
+#   - for example: add the rd.kdumploglvl=3 option to KDUMP_COMMANDLINE_APPEND
+#
+# Logging levels: no logging(0), error(1),warn(2),info(3),debug(4)
+#
+# KDUMP_STDLOGLVL=3
+# KDUMP_SYSLOGLVL=0
+# KDUMP_KMSGLOGLVL=0

kdump.sysconfig.s390x

@@ -0,0 +1,59 @@
+# Kernel Version string for the -kdump kernel, such as 2.6.13-1544.FC5kdump
+# 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.
+KDUMP_KERNELVER=""
+
+# 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=/"
+# Dracut depends on proper root= options, so please make sure that appropriate
+# root= options are copied from /proc/cmdline. In general it is best to append
+# command line options using "KDUMP_COMMANDLINE_APPEND=".
+# If a command line is not specified, the default will be taken from
+# /proc/cmdline
+KDUMP_COMMANDLINE=""
+
+# This variable lets us remove arguments from the current kdump commandline
+# as taken from either KDUMP_COMMANDLINE above, or from /proc/cmdline
+# NOTE: some arguments such as crashkernel will always be removed
+KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet log_buf_len swiotlb vmcp_cma cma hugetlb_cma prot_virt ignition.firstboot"
+
+# This variable lets us append arguments to the current kdump commandline
+# after processed by KDUMP_COMMANDLINE_REMOVE
+KDUMP_COMMANDLINE_APPEND="nr_cpus=1 cgroup_disable=memory numa=off udev.children-max=2 panic=10 transparent_hugepage=never novmcoredd vmcp_cma=0 cma=0 hugetlb_cma=0"
+
+# Any additional /sbin/mkdumprd arguments required.
+MKDUMPRD_ARGS=""
+
+# Any additional kexec arguments required.  In most situations, this should
+# be left empty
+#
+# Example:
+#   KEXEC_ARGS="--elf32-core-headers"
+KEXEC_ARGS="-s"
+
+#Where to find the boot image
+#KDUMP_BOOTDIR="/boot"
+
+#What is the image type used for kdump
+KDUMP_IMG="vmlinuz"
+
+#What is the images extension.  Relocatable kernels don't have one
+KDUMP_IMG_EXT=""
+
+# Logging is controlled by following variables in the first kernel:
+#   - @var KDUMP_STDLOGLVL - logging level to standard error (console output)
+#   - @var KDUMP_SYSLOGLVL - logging level to syslog (by logger command)
+#   - @var KDUMP_KMSGLOGLVL - logging level to /dev/kmsg (only for boot-time)
+#
+# In the second kernel, kdump will use the rd.kdumploglvl option to set the
+# log level in the above KDUMP_COMMANDLINE_APPEND.
+#   - @var rd.kdumploglvl - logging level to syslog (by logger command)
+#   - for example: add the rd.kdumploglvl=3 option to KDUMP_COMMANDLINE_APPEND
+#
+# Logging levels: no logging(0), error(1),warn(2),info(3),debug(4)
+#
+# KDUMP_STDLOGLVL=3
+# KDUMP_SYSLOGLVL=0
+# KDUMP_KMSGLOGLVL=0

kdump.sysconfig.x86_64

@@ -0,0 +1,56 @@
+# Kernel Version string for the -kdump kernel, such as 2.6.13-1544.FC5kdump
+# 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.
+KDUMP_KERNELVER=""
+
+# 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=/"
+# Dracut depends on proper root= options, so please make sure that appropriate
+# root= options are copied from /proc/cmdline. In general it is best to append
+# command line options using "KDUMP_COMMANDLINE_APPEND=".
+# If a command line is not specified, the default will be taken from
+# /proc/cmdline
+KDUMP_COMMANDLINE=""
+
+# This variable lets us remove arguments from the current kdump commandline
+# as taken from either KDUMP_COMMANDLINE above, or from /proc/cmdline
+# NOTE: some arguments such as crashkernel will always be removed
+KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet log_buf_len swiotlb cma hugetlb_cma ignition.firstboot"
+
+# This variable lets us append arguments to the current kdump commandline
+# after processed by KDUMP_COMMANDLINE_REMOVE
+KDUMP_COMMANDLINE_APPEND="irqpoll nr_cpus=1 reset_devices cgroup_disable=memory mce=off numa=off udev.children-max=2 panic=10 acpi_no_memhotplug transparent_hugepage=never nokaslr hest_disable novmcoredd cma=0 hugetlb_cma=0"
+
+# Any additional kexec arguments required.  In most situations, this should
+# be left empty
+#
+# Example:
+#   KEXEC_ARGS="--elf32-core-headers"
+KEXEC_ARGS="-s"
+
+#Where to find the boot image
+#KDUMP_BOOTDIR="/boot"
+
+#What is the image type used for kdump
+KDUMP_IMG="vmlinuz"
+
+#What is the images extension.  Relocatable kernels don't have one
+KDUMP_IMG_EXT=""
+
+# Logging is controlled by following variables in the first kernel:
+#   - @var KDUMP_STDLOGLVL - logging level to standard error (console output)
+#   - @var KDUMP_SYSLOGLVL - logging level to syslog (by logger command)
+#   - @var KDUMP_KMSGLOGLVL - logging level to /dev/kmsg (only for boot-time)
+#
+# In the second kernel, kdump will use the rd.kdumploglvl option to set the
+# log level in the above KDUMP_COMMANDLINE_APPEND.
+#   - @var rd.kdumploglvl - logging level to syslog (by logger command)
+#   - for example: add the rd.kdumploglvl=3 option to KDUMP_COMMANDLINE_APPEND
+#
+# Logging levels: no logging(0), error(1),warn(2),info(3),debug(4)
+#
+# KDUMP_STDLOGLVL=3
+# KDUMP_SYSLOGLVL=0
+# KDUMP_KMSGLOGLVL=0

kdumpctl.8

@@ -0,0 +1,72 @@
+.TH KDUMPCTL 8 2015-07-13 kexec-tools
+
+.SH NAME
+kdumpctl \- control interface for kdump
+
+.SH SYNOPSIS
+.B kdumpctl
+.I COMMAND
+
+.SH DESCRIPTION
+.B kdumpctl
+is used to check or control the kdump service.
+In most cases, you should use
+.B systemctl
+to start / stop / enable kdump service instead. However,
+.B kdumpctl
+provides more details for debugging and a helper to set up ssh key authentication.
+
+.SH COMMANDS
+.TP
+.I start
+Start the service.
+.TP
+.I stop
+Stop the service.
+.TP
+.I status
+Prints the current status of kdump service.
+It returns a non-zero value if kdump is not operational.
+.TP
+.I restart
+Is equal to
+.I start; stop
+.TP
+.I reload
+reload the crash kernel image and initramfs without triggering a rebuild.
+.TP
+.I rebuild
+rebuild the crash kernel initramfs.
+.TP
+.I propagate
+Helps to setup key authentication for ssh storage since it's
+impossible to use password authentication during kdump.
+.TP
+.I showmem
+Prints the size of reserved memory for the crash kernel in megabytes.
+.TP
+.I estimate
+Estimate a suitable crashkernel value for the current machine. This is a
+best-effort estimate. It will print a recommended crashkernel value
+based on the current kdump setup, and list some details of memory usage.
+.TP
+.I get-default-crashkernel
+Return the default crashkernel value provided by kexec-tools.
+.TP
+.I reset-crashkernel [--kernel=path_to_kernel] [--reboot]
+Reset crashkernel to default value recommended by kexec-tools. If no kernel
+is specified, will reset KDUMP_KERNELVER if it's defined in /etc/sysconfig/kdump
+or the current running kernel's crashkernel value if KDUMP_KERNELVER is empty. You can
+also specify --kernel=ALL and --kernel=DEFAULT which have the same meaning as
+grubby's kernel-path=ALL and kernel-path=DEFAULT. ppc64le supports FADump and
+supports an additional [--fadump=[on|off|nocma]] parameter to toggle FADump
+on/off.
+
+Note: The memory requirements for kdump varies heavily depending on the
+used hardware and system configuration. Thus the recommended
+crashkernel might not work for your specific setup. Please test if
+kdump works after resetting the crashkernel value.
+
+.SH "SEE ALSO"
+.BR kdump.conf (5),
+.BR mkdumprd (8)

kexec-tools.spec

@@ -1,20 +1,90 @@
+%global eppic_ver e8844d3793471163ae4a56d8f95897be9e5bd554
+%global eppic_shortver %(c=%{eppic_ver}; echo ${c:0:7})
+%global mkdf_ver 1.7.1
+%global mkdf_shortver %(c=%{mkdf_ver}; echo ${c:0:7})
+
 Name: kexec-tools
-Version: 2.0.32
+Version: 2.0.25
 Release: 1%{?dist}
-URL: https://kernel.org/pub/linux/utils/kernel/kexec
-License: GPL-2.0-only
+License: GPLv2
 Summary: The kexec/kdump userspace component
 
-Source0: https://kernel.org/pub/linux/utils/kernel/kexec/%{name}-%{version}.tar.xz
-Recommends: kdump-utils
+Source0: http://kernel.org/pub/linux/utils/kernel/kexec/%{name}-%{version}.tar.xz
+Source1: kdumpctl
+Source2: kdump.sysconfig
+Source3: kdump.sysconfig.x86_64
+Source4: kdump.sysconfig.i386
+Source5: kdump.sysconfig.ppc64
+Source7: mkdumprd
+Source8: kdump.conf
+Source9: https://github.com/makedumpfile/makedumpfile/archive/%{mkdf_ver}/makedumpfile-%{mkdf_shortver}.tar.gz
+Source10: kexec-kdump-howto.txt
+Source11: fadump-howto.txt
+Source12: mkdumprd.8
+Source13: 98-kexec.rules
+Source14: 98-kexec.rules.ppc64
+Source15: kdump.conf.5
+Source16: kdump.service
+Source18: kdump.sysconfig.s390x
+Source19: https://github.com/lucchouina/eppic/archive/%{eppic_ver}/eppic-%{eppic_shortver}.tar.gz
+Source20: kdump-lib.sh
+Source21: kdump-in-cluster-environment.txt
+Source22: kdump-dep-generator.sh
+Source23: kdump-lib-initramfs.sh
+Source24: kdump.sysconfig.ppc64le
+Source25: kdumpctl.8
+Source26: live-image-kdump-howto.txt
+Source27: early-kdump-howto.txt
+Source28: kdump-udev-throttler
+Source29: kdump.sysconfig.aarch64
+Source30: 60-kdump.install
+Source31: kdump-logger.sh
+Source32: mkfadumprd
+Source33: 92-crashkernel.install
+Source34: crashkernel-howto.txt
+Source35: kdump-migrate-action.sh
+Source36: kdump-restart.sh
 
-BuildRequires: automake
-BuildRequires: autoconf
-BuildRequires: libtool
-BuildRequires: gcc
-BuildRequires: xz-devel
-BuildRequires: zlib-devel
-BuildRequires: libzstd-devel
+#######################################
+# These are sources for mkdumpramfs
+# Which is currently in development
+#######################################
+Source100: dracut-kdump.sh
+Source101: dracut-module-setup.sh
+Source102: dracut-monitor_dd_progress
+Source104: dracut-kdump-emergency.service
+Source106: dracut-kdump-capture.service
+Source107: dracut-kdump-emergency.target
+Source108: dracut-early-kdump.sh
+Source109: dracut-early-kdump-module-setup.sh
+
+Source200: dracut-fadump-init-fadump.sh
+Source201: dracut-fadump-module-setup.sh
+
+%ifarch ppc64 ppc64le
+Requires(post): servicelog
+Recommends: keyutils
+%endif
+Requires(pre): coreutils sed zlib
+Requires: dracut >= 050
+Requires: dracut-network >= 050
+Requires: dracut-squash >= 050
+Requires: ethtool
+Recommends: zstd
+Recommends: grubby
+Recommends: hostname
+BuildRequires: make
+BuildRequires: zlib-devel elfutils-devel glib2-devel bzip2-devel ncurses-devel bison flex lzo-devel snappy-devel libzstd-devel
+BuildRequires: pkgconfig intltool gettext
+BuildRequires: systemd-rpm-macros
+BuildRequires: automake autoconf libtool
+%ifarch %{ix86} x86_64 ppc64 ppc s390x ppc64le
+Obsoletes: diskdumputils netdump kexec-tools-eppic
+%endif
+
+%ifnarch s390x
+Requires:       systemd-udev%{?_isa}
+%endif
 
 #START INSERT
 
@@ -40,7 +110,7 @@ BuildRequires: libzstd-devel
 
 #
 # Patches 601 onward are generic patches
-
+#
 
 %description
 kexec-tools provides /sbin/kexec binary that facilitates a new
@@ -50,7 +120,16 @@ binary and ancillary utilities that together form the userspace
 component of the kernel's kexec feature.
 
 %prep
-%autosetup -p1
+%setup -q
+
+mkdir -p -m755 kcp
+tar -z -x -v -f %{SOURCE9}
+tar -z -x -v -f %{SOURCE19}
+
+
+%ifarch ppc
+%define archdef ARCH=ppc
+%endif
 
 %build
 autoreconf
@@ -63,232 +142,280 @@ autoreconf
     --host=powerpc64le-redhat-linux-gnu \
     --build=powerpc64le-redhat-linux-gnu \
 %endif
-    --sbindir=%{_sbindir}
+    --sbindir=/usr/sbin
+rm -f kexec-tools.spec.in
+# setup the docs
+cp %{SOURCE10} .
+cp %{SOURCE11} .
+cp %{SOURCE21} .
+cp %{SOURCE26} .
+cp %{SOURCE27} .
+cp %{SOURCE34} .
 
-%make_build
+make
+%ifarch %{ix86} x86_64 ppc64 s390x ppc64le aarch64
+make -C eppic-%{eppic_ver}/libeppic
+make -C makedumpfile-%{mkdf_ver} LINKTYPE=dynamic USELZO=on USESNAPPY=on USEZSTD=on
+make -C makedumpfile-%{mkdf_ver} LDFLAGS="$LDFLAGS -I../eppic-%{eppic_ver}/libeppic -L../eppic-%{eppic_ver}/libeppic" eppic_makedumpfile.so
+%endif
 
 %install
-%make_install
-rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
+mkdir -p -m755 $RPM_BUILD_ROOT/usr/sbin
+mkdir -p -m755 $RPM_BUILD_ROOT%{_sysconfdir}/sysconfig
+mkdir -p -m755 $RPM_BUILD_ROOT%{_sysconfdir}/kdump
+mkdir -p -m755 $RPM_BUILD_ROOT%{_sysconfdir}/kdump/pre.d
+mkdir -p -m755 $RPM_BUILD_ROOT%{_sysconfdir}/kdump/post.d
+mkdir -p -m755 $RPM_BUILD_ROOT%{_localstatedir}/crash
+mkdir -p -m755 $RPM_BUILD_ROOT%{_mandir}/man8/
+mkdir -p -m755 $RPM_BUILD_ROOT%{_mandir}/man5/
+mkdir -p -m755 $RPM_BUILD_ROOT%{_docdir}
+mkdir -p -m755 $RPM_BUILD_ROOT%{_datadir}/kdump
+mkdir -p -m755 $RPM_BUILD_ROOT%{_udevrulesdir}
+mkdir -p $RPM_BUILD_ROOT%{_unitdir}
+mkdir -p -m755 $RPM_BUILD_ROOT%{_bindir}
+mkdir -p -m755 $RPM_BUILD_ROOT%{_libdir}
+mkdir -p -m755 $RPM_BUILD_ROOT%{_prefix}/lib/kdump
+mkdir -p -m755 $RPM_BUILD_ROOT%{_sharedstatedir}/kdump
+install -m 755 %{SOURCE1} $RPM_BUILD_ROOT%{_bindir}/kdumpctl
+
+install -m 755 build/sbin/kexec $RPM_BUILD_ROOT/usr/sbin/kexec
+install -m 755 build/sbin/vmcore-dmesg $RPM_BUILD_ROOT/usr/sbin/vmcore-dmesg
+install -m 644 build/man/man8/kexec.8  $RPM_BUILD_ROOT%{_mandir}/man8/
+install -m 644 build/man/man8/vmcore-dmesg.8  $RPM_BUILD_ROOT%{_mandir}/man8/
+
+SYSCONFIG=$RPM_SOURCE_DIR/kdump.sysconfig.%{_target_cpu}
+[ -f $SYSCONFIG ] || SYSCONFIG=$RPM_SOURCE_DIR/kdump.sysconfig.%{_arch}
+[ -f $SYSCONFIG ] || SYSCONFIG=$RPM_SOURCE_DIR/kdump.sysconfig
+install -m 644 $SYSCONFIG $RPM_BUILD_ROOT%{_sysconfdir}/sysconfig/kdump
+
+install -m 755 %{SOURCE7} $RPM_BUILD_ROOT/usr/sbin/mkdumprd
+install -m 644 %{SOURCE8} $RPM_BUILD_ROOT%{_sysconfdir}/kdump.conf
+install -m 644 kexec/kexec.8 $RPM_BUILD_ROOT%{_mandir}/man8/kexec.8
+install -m 644 %{SOURCE12} $RPM_BUILD_ROOT%{_mandir}/man8/mkdumprd.8
+install -m 644 %{SOURCE25} $RPM_BUILD_ROOT%{_mandir}/man8/kdumpctl.8
+install -m 755 %{SOURCE20} $RPM_BUILD_ROOT%{_prefix}/lib/kdump/kdump-lib.sh
+install -m 755 %{SOURCE23} $RPM_BUILD_ROOT%{_prefix}/lib/kdump/kdump-lib-initramfs.sh
+install -m 755 %{SOURCE31} $RPM_BUILD_ROOT%{_prefix}/lib/kdump/kdump-logger.sh
+%ifarch ppc64 ppc64le
+install -m 755 %{SOURCE32} $RPM_BUILD_ROOT/usr/sbin/mkfadumprd
+install -m 755 %{SOURCE35} $RPM_BUILD_ROOT%{_prefix}/lib/kdump/kdump-migrate-action.sh
+install -m 755 %{SOURCE36} $RPM_BUILD_ROOT%{_prefix}/lib/kdump/kdump-restart.sh
+%endif
+%ifnarch s390x
+install -m 755 %{SOURCE28} $RPM_BUILD_ROOT%{_udevrulesdir}/../kdump-udev-throttler
+%endif
+%ifnarch s390x ppc64 ppc64le
+# For s390x the ELF header is created in the kdump kernel and therefore kexec
+# udev rules are not required
+install -m 644 %{SOURCE13} $RPM_BUILD_ROOT%{_udevrulesdir}/98-kexec.rules
+%endif
+%ifarch ppc64 ppc64le
+install -m 644 %{SOURCE14} $RPM_BUILD_ROOT%{_udevrulesdir}/98-kexec.rules
+%endif
+install -m 644 %{SOURCE15} $RPM_BUILD_ROOT%{_mandir}/man5/kdump.conf.5
+install -m 644 %{SOURCE16} $RPM_BUILD_ROOT%{_unitdir}/kdump.service
+install -m 755 -D %{SOURCE22} $RPM_BUILD_ROOT%{_prefix}/lib/systemd/system-generators/kdump-dep-generator.sh
+install -m 755 -D %{SOURCE30} $RPM_BUILD_ROOT%{_prefix}/lib/kernel/install.d/60-kdump.install
+install -m 755 -D %{SOURCE33} $RPM_BUILD_ROOT%{_prefix}/lib/kernel/install.d/92-crashkernel.install
+
+%ifarch %{ix86} x86_64 ppc64 s390x ppc64le aarch64
+install -m 755 makedumpfile-%{mkdf_ver}/makedumpfile $RPM_BUILD_ROOT/usr/sbin/makedumpfile
+install -m 644 makedumpfile-%{mkdf_ver}/makedumpfile.8 $RPM_BUILD_ROOT/%{_mandir}/man8/makedumpfile.8
+install -m 644 makedumpfile-%{mkdf_ver}/makedumpfile.conf.5 $RPM_BUILD_ROOT/%{_mandir}/man5/makedumpfile.conf.5
+install -m 644 makedumpfile-%{mkdf_ver}/makedumpfile.conf $RPM_BUILD_ROOT/%{_sysconfdir}/makedumpfile.conf.sample
+install -m 755 makedumpfile-%{mkdf_ver}/eppic_makedumpfile.so $RPM_BUILD_ROOT/%{_libdir}/eppic_makedumpfile.so
+mkdir -p $RPM_BUILD_ROOT/usr/share/makedumpfile/eppic_scripts/
+install -m 644 makedumpfile-%{mkdf_ver}/eppic_scripts/* $RPM_BUILD_ROOT/usr/share/makedumpfile/eppic_scripts/
+%endif
+
+%define remove_dracut_prefix() %(echo -n %1|sed 's/.*dracut-//g')
+%define remove_dracut_early_kdump_prefix() %(echo -n %1|sed 's/.*dracut-early-kdump-//g')
+%define remove_dracut_fadump_prefix() %(echo -n %1|sed 's/.*dracut-fadump-//g')
+
+# deal with dracut modules
+mkdir -p -m755 $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99kdumpbase
+cp %{SOURCE100} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99kdumpbase/%{remove_dracut_prefix %{SOURCE100}}
+cp %{SOURCE101} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99kdumpbase/%{remove_dracut_prefix %{SOURCE101}}
+cp %{SOURCE102} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99kdumpbase/%{remove_dracut_prefix %{SOURCE102}}
+cp %{SOURCE104} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99kdumpbase/%{remove_dracut_prefix %{SOURCE104}}
+cp %{SOURCE106} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99kdumpbase/%{remove_dracut_prefix %{SOURCE106}}
+cp %{SOURCE107} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99kdumpbase/%{remove_dracut_prefix %{SOURCE107}}
+chmod 755 $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99kdumpbase/%{remove_dracut_prefix %{SOURCE100}}
+chmod 755 $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99kdumpbase/%{remove_dracut_prefix %{SOURCE101}}
+mkdir -p -m755 $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99earlykdump
+cp %{SOURCE108} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99earlykdump/%{remove_dracut_prefix %{SOURCE108}}
+cp %{SOURCE109} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99earlykdump/%{remove_dracut_early_kdump_prefix %{SOURCE109}}
+chmod 755 $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99earlykdump/%{remove_dracut_prefix %{SOURCE108}}
+chmod 755 $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99earlykdump/%{remove_dracut_early_kdump_prefix %{SOURCE109}}
+%ifarch ppc64 ppc64le
+mkdir -p -m755 $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99zz-fadumpinit
+cp %{SOURCE200} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99zz-fadumpinit/%{remove_dracut_fadump_prefix %{SOURCE200}}
+cp %{SOURCE201} $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99zz-fadumpinit/%{remove_dracut_fadump_prefix %{SOURCE201}}
+chmod 755 $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99zz-fadumpinit/%{remove_dracut_fadump_prefix %{SOURCE200}}
+chmod 755 $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/99zz-fadumpinit/%{remove_dracut_fadump_prefix %{SOURCE201}}
+%endif
+
+
+%define dracutlibdir %{_prefix}/lib/dracut
+#and move the custom dracut modules to the dracut directory
+mkdir -p $RPM_BUILD_ROOT/%{dracutlibdir}/modules.d/
+mv $RPM_BUILD_ROOT/etc/kdump-adv-conf/kdump_dracut_modules/* $RPM_BUILD_ROOT/%{dracutlibdir}/modules.d/
+
+%pre
+# Save the old default crashkernel values to /tmp/ when upgrading the package
+# so kdumpctl later can tell if it should update the kernel crashkernel
+# parameter in the posttrans scriptlet.  Note this feauture of auto-updating
+# the kernel crashkernel parameter currently doesn't support ostree, so skip it
+# for ostree.
+if [ ! -f /run/ostree-booted ] && [ $1 == 2 ] && grep -q get-default-crashkernel /usr/bin/kdumpctl; then
+  kdumpctl get-default-crashkernel kdump > /tmp/old_default_crashkernel 2>/dev/null
+%ifarch ppc64 ppc64le
+  kdumpctl get-default-crashkernel fadump > /tmp/old_default_crashkernel_fadump 2>/dev/null
+%endif
+fi
+# don't block package update
+:
+
+%post
+# Initial installation
+%systemd_post kdump.service
+
+touch /etc/kdump.conf
+
+%ifarch ppc64 ppc64le
+servicelog_notify --remove --command=/usr/lib/kdump/kdump-migrate-action.sh 2>/dev/null
+servicelog_notify --add --command=/usr/lib/kdump/kdump-migrate-action.sh --match='refcode="#MIGRATE" and serviceable=0' --type=EVENT --method=pairs_stdin
+%endif
+
+# This portion of the script is temporary.  Its only here
+# to fix up broken boxes that require special settings 
+# in /etc/sysconfig/kdump.  It will be removed when 
+# These systems are fixed.
+
+if [ -d /proc/bus/mckinley ]
+then
+	# This is for HP zx1 machines
+	# They require machvec=dig on the kernel command line
+	sed -e's/\(^KDUMP_COMMANDLINE_APPEND.*\)\("$\)/\1 machvec=dig"/' \
+	/etc/sysconfig/kdump > /etc/sysconfig/kdump.new
+	mv /etc/sysconfig/kdump.new /etc/sysconfig/kdump
+elif [ -d /proc/sgi_sn ]
+then
+	# This is for SGI SN boxes
+	# They require the --noio option to kexec 
+	# since they don't support legacy io
+	sed -e's/\(^KEXEC_ARGS.*\)\("$\)/\1 --noio"/' \
+	/etc/sysconfig/kdump > /etc/sysconfig/kdump.new
+	mv /etc/sysconfig/kdump.new /etc/sysconfig/kdump
+fi
+
+
+%postun
+%systemd_postun_with_restart kdump.service
+
+%preun
+%ifarch ppc64 ppc64le
+servicelog_notify --remove --command=/usr/lib/kdump/kdump-migrate-action.sh
+%endif
+%systemd_preun kdump.service
+
+%triggerin -- kernel-kdump
+touch %{_sysconfdir}/kdump.conf
+
+
+%triggerpostun -- kernel kernel-xen kernel-debug kernel-PAE kernel-kdump
+# List out the initrds here, strip out version nubmers
+# and search for corresponding kernel installs, if a kernel
+# is not found, remove the corresponding kdump initrd
+
+
+IMGDIR=/boot
+for i in `ls $IMGDIR/initramfs*kdump.img 2>/dev/null`
+do
+	KDVER=`echo $i | sed -e's/^.*initramfs-//' -e's/kdump.*$//'`
+	if [ ! -e $IMGDIR/vmlinuz-$KDVER ]
+	then
+		# We have found an initrd with no corresponding kernel
+		# so we should be able to remove it
+		rm -f $i
+	fi
+done
+
+%posttrans
+# Try to reset kernel crashkernel value to new default value based on the old
+# default value or set up crasherkernel value for osbuild
+#
+# Note
+#  1. Skip ostree systems as they are not supported.
+#  2. "[ $1 == 1 ]" in posttrans scriptlet means both install and upgrade. The
+#     former case is used to set up crashkernel for osbuild
+if [ ! -f /run/ostree-booted ] && [ $1 == 1 ]; then
+  kdumpctl reset-crashkernel-after-update
+  rm /tmp/old_default_crashkernel 2>/dev/null
+%ifarch ppc64 ppc64le
+  rm /tmp/old_default_crashkernel_fadump 2>/dev/null
+%endif
+  # dnf would complain about the exit code not being 0. To keep it happy,
+  # always return 0
+  :
+fi
 
 
 %files
-%{_sbindir}/kexec
-%{_mandir}/man8/kexec.8*
-%{_sbindir}/vmcore-dmesg
-%{_mandir}/man8/vmcore-dmesg.8*
+/usr/sbin/kexec
+%ifarch %{ix86} x86_64 ppc64 s390x ppc64le aarch64
+/usr/sbin/makedumpfile
+%endif
+%ifarch ppc64 ppc64le
+/usr/sbin/mkfadumprd
+%endif
+/usr/sbin/mkdumprd
+/usr/sbin/vmcore-dmesg
+%{_bindir}/*
+%{_datadir}/kdump
+%{_prefix}/lib/kdump
+%ifarch %{ix86} x86_64 ppc64 s390x ppc64le aarch64
+%{_sysconfdir}/makedumpfile.conf.sample
+%endif
+%config(noreplace,missingok) %{_sysconfdir}/sysconfig/kdump
+%config(noreplace,missingok) %verify(not mtime) %{_sysconfdir}/kdump.conf
+%ifnarch s390x
+%config %{_udevrulesdir}
+%{_udevrulesdir}/../kdump-udev-throttler
+%endif
+%{dracutlibdir}/modules.d/*
+%dir %{_localstatedir}/crash
+%dir %{_sysconfdir}/kdump
+%dir %{_sysconfdir}/kdump/pre.d
+%dir %{_sysconfdir}/kdump/post.d
+%dir %{_sharedstatedir}/kdump
+%{_mandir}/man8/kdumpctl.8.gz
+%{_mandir}/man8/kexec.8.gz
+%ifarch %{ix86} x86_64 ppc64 s390x ppc64le aarch64
+%{_mandir}/man8/makedumpfile.8.gz
+%endif
+%{_mandir}/man8/mkdumprd.8.gz
+%{_mandir}/man8/vmcore-dmesg.8.gz
+%{_mandir}/man5/*
+%{_unitdir}/kdump.service
+%{_prefix}/lib/systemd/system-generators/kdump-dep-generator.sh
+%{_prefix}/lib/kernel/install.d/60-kdump.install
+%{_prefix}/lib/kernel/install.d/92-crashkernel.install
 %doc News
 %license COPYING
 %doc TODO
+%doc kexec-kdump-howto.txt
+%doc early-kdump-howto.txt
+%doc fadump-howto.txt
+%doc kdump-in-cluster-environment.txt
+%doc live-image-kdump-howto.txt
+%doc crashkernel-howto.txt
+%ifarch %{ix86} x86_64 ppc64 s390x ppc64le aarch64
+%{_libdir}/eppic_makedumpfile.so
+/usr/share/makedumpfile/
+%endif
 
 %changelog
-* Thu Oct 16 2025 Packit <hello@packit.dev> - 2.0.32-1
-- Update to version 2.0.32
-- Resolves: rhbz#2404365
-
-* Thu Jul 24 2025 Fedora Release Engineering <releng@fedoraproject.org> - 2.0.31-3
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_43_Mass_Rebuild
-
-* Wed May 21 2025 Coiby Xu <coxu@redhat.com> - 2.0.31-2
-- Add BuildRequires libzstd-devel to support loading zstd-compressed kernel
-
-* Tue Apr 22 2025 Packit <hello@packit.dev> - 2.0.31-1
-- Update to version 2.0.31
-- Resolves: rhbz#2359477
-
-* Fri Jan 17 2025 Fedora Release Engineering <releng@fedoraproject.org> - 2.0.30-3
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_42_Mass_Rebuild
-
-* Sun Jan 12 2025 Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl> - 2.0.30-2
-- Rebuilt for the bin-sbin merge (2nd attempt)
-
-* Mon Dec 02 2024 Packit <hello@packit.dev> - 2.0.30-1
-- Update to version 2.0.30
-- Resolves: rhbz#2326470
-
-* Tue Aug 06 2024 Coiby Xu <coxu@redhat.com> - 2.0.29-1
-- Update to version 2.0.29
-- Resolves: 2297928
-
-* Thu Jul 18 2024 Fedora Release Engineering <releng@fedoraproject.org> - 2.0.28-14
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_41_Mass_Rebuild
-
-* Sat Jul 13 2024 Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl> - 2.0.28-13
-- Rebuilt for the bin-sbin merge (again)
-
-* Thu Jul 11 2024 Coiby Xu <coxu@redhat.com> - 2.0.28-12
-- Re-add missing build dependencies
-
-* Tue Jul 09 2024 Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl> - 2.0.28-11
-- Rebuilt for the bin-sbin merge
-
-* Thu Apr 25 2024 Coiby Xu <coxu@redhat.com> - 2.0.28-10
-- Split out kdump-utils and makedumpfile
-
-* Thu Apr 25 2024 Coiby Xu <coxu@redhat.com> - 2.0.28-9
-- Update to makedumpfile-1.7.5
-
-* Tue Apr 09 2024 Coiby Xu <coxu@redhat.com> - 2.0.28-8
-- Add a kdump-utils subpackage
-
-* Sun Apr 07 2024 Coiby Xu <coxu@redhat.com> - 2.0.28-7
-- Release 2.0.28-7
-
-* Sat Mar 16 2024 Coiby Xu <coxu@redhat.com> - 2.0.28-6
-- let kexec-tools depends on makedumpfile
-
-* Fri Feb 23 2024 Carl George <carlwgeorge@fedoraproject.org> - 2.0.28-5
-- Add a makedumpfile subpackage
-
-* Fri Feb 02 2024 Coiby Xu <coxu@redhat.com> - 2.0.28-4
-- kexec: don't use kexec_file_load on XEN
-- Fix building on x86_64 with binutils 2.41
-
-* Wed Jan 24 2024 Fedora Release Engineering <releng@fedoraproject.org> - 2.0.28-3
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild
-
-* Sun Jan 21 2024 Fedora Release Engineering <releng@fedoraproject.org> - 2.0.28-2
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild
-
-* Wed Jan 17 2024 Coiby Xu <coxu@redhat.com> - 2.0.28-1
-- kexec-tools 2.0.28 (Simon Horman)
-- Use the same /etc/resolve.conf in kdump initrd if it's managed manually
-- dracut-module-setup: consolidate s390 network device config
-
-* Mon Dec 11 2023 Coiby Xu <coxu@redhat.com> - 2.0.27-5
-- Let %post scriptlet always exits with the zero exit status
-
-* Wed Nov 08 2023 Coiby Xu <coxu@redhat.com> - 2.0.27-4
-- update to makedumpfile-1.7.4
-- kdump-lib.sh: add extra 64M to default crashkernel if sme/sev is active
-- Allow _crashkernel_add to address larger memory ranges
-
-* Tue Oct 17 2023 Coiby Xu <coxu@redhat.com> - 2.0.27-3
-- Only try to reset crashkernel when kdump.service is enabled
-
-* Fri Oct 13 2023 Coiby Xu <coxu@redhat.com> - 2.0.27-2
-- update to latest upstream kexec-tools
-
-* Tue Oct 10 2023 Coiby Xu <coxu@redhat.com> - 2.0.27-1
-- kexec-tools 2.0.27 (Simon Horman)
-
-* Thu Aug 31 2023 Coiby Xu <coxu@redhat.com> - 2.0.27-1
-- kexec-tools 2.0.27 (Simon Horman)
-
-* Thu Jul 20 2023 Fedora Release Engineering <releng@fedoraproject.org> - 2.0.26-8
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_39_Mass_Rebuild
-
-* Wed Jun 14 2023 Coiby <coxu@redhat.com> - 2.0.26-7
-- kdumpctl: Fix the matching of plus symbol by grep's EREs
-- kdump-lib: Evaluate the memory consumption by smmu and mlx5 separately
-- kdump-lib: add support for 64K aarch64
-- kdump-lib: Introduce parse_kver_from_path() to get kernel version from its path name
-- kdump-lib: Introduce a help function _crashkernel_add()
-
-* Fri Jun 02 2023 Timothée Ravier <tim@siosm.fr> - 2.0.26-6
-- Make binutils a recommend as it's only needed for UKI support
-
-* Mon May 29 2023 Coiby <coxu@redhat.com> - 2.0.26-5
-- Simplify the management of the kernel parameter crashkernel
-- Let _update_kernel_cmdline return the correct return code
-- mkdumprd: call dracut with --add-device to install the drivers needed by /boot partition automatically for FIPS
-- kdump-lib: fix the matching pattern for debug-kernel
-
-* Tue May 16 2023 Coiby <coxu@redhat.com> - 2.0.26-4
-- kdumpctl: Add support for systemd-boot paths
-- mkdumprd: add --aggressive-strip as default dracut args
-- kdumpctl: Add basic UKI support
-- kdumpctl: Move temp file in get_kernel_size to global temp dir
-- kdumpctl: Move get_kernel_size to kdumpctl
-- kdumpctl: fix is_dracut_mod_omitted
-- kdump-lib: move is_dracut_mod_omitted to kdumpctl
-- kdump-lib: remove get_nmcli_connection_apath_by_ifname
-- kdump-lib: remove get_nmcli_field_by_conpath
-- dracut-module-setup: remove dead source_ifcfg_file
-- kdump-lib-initramfs: remove is_fs_dump_target
-- kdump-lib-initramfs: harden is_mounted
-- Show how much time kdump has waited for the network to be ready
-- Tell nmcli to not escape colon when getting the path of connection profile
-- kdumpctl: lower the log level in reset_crashkernel_for_installed_kernel
-- Install nfsv4-related drivers when users specify nfs dumping via dracut_args
-- sysconfig: add zfcp.allow_lun_scan to KDUMP_COMMANDLINE_REMOVE on s390
-- Use the correct command to get architecture
-
-* Mon Jan 30 2023 Coiby <coxu@redhat.com> - 2.0.26-3
-- kdumpctl: make do_estimate more robust
-- kdumpctl: refractor check_rebuild
-- kdumpctl: cleanup 'stop'
-- kdumpctl: cleanup 'start'
-- kdump-lib: fix prepare_cmdline
-- kdumpctl: move aws workaround to kdump-lib
-- unit tests: add tests for prepare_cmdline
-- kdump-lib: always specify version in is_squash_available
-- mkfadumprd: drop unset globals from debug output
-- kdumpctl: merge check_current_{kdump,fadump}_status
-- dracut-early-kdump: explicitly use bash
-- dracut-early-kdump: fix shellcheck findings
-- kdumpctl: simplify check_failure_action_config
-- makedumpfile: Fix wrong exclusion of slab pages on Linux 6.2-rc1
-
-* Thu Jan 19 2023 Fedora Release Engineering <releng@fedoraproject.org> - 2.0.26-2
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_38_Mass_Rebuild
-
-* Thu Dec 22 2022 Coiby <coxu@redhat.com> - 2.0.26-1
-- Update kexec-tools to 2.0.25
-- Don't try to update crashkernel when bootloader is not installed
-- dracut-module-setup.sh: also install the driver of physical NIC for Hyper-V VM with accelerated networking
-- dracut-module-setup.sh: skip installing driver for the loopback interface
-
-* Wed Dec 07 2022 Coiby <coxu@redhat.com> - 2.0.25-4
-- dracut-module-setup.sh: stop overwriting dracut's trap handler
-- fadump: avoid status check while starting in fadump mode
-- fadump: add a kernel install hook to clean up fadump initramfs
-- fadump: fix default initrd backup and restore logic
-- fadump: use 'zstd' as the default compression method
-
-* Fri Nov 25 2022 Coiby <coxu@redhat.com> - 2.0.25-3
-- kdumpctl: Optimize _find_kernel_path_by_release regex string
-- unit tests: adapt check_config to gen-kdump-conf.sh
-- kdump.conf: use a simple generator script to maintain
-- Don't run kdump_check_setup_iscsi in a subshell in order to collect needed network interfaces
-- Simplify setup_znet by copying connection profile to initrd
-- Wait for the network to be truly ready before dumping vmcore
-- Address the cases where a NIC has a different name in kdump kernel
-- Reduce kdump memory consumption by only installing needed NIC drivers
-- Reduce kdump memory consumption by not letting NetworkManager manage unneeded network interfaces
-- Set up kdump network by directly copying NM connection profile to initrd
-- Stop dracut 35network-manager from running nm-initrd-generator
-- Apply the timeout configuration of nm-initrd-generator
-- Determine whether IPv4 or IPv6 is needed
-- Add functions to copy NetworkManage connection profiles to the initramfs
-- Fix error for vlan over team network interface
-- Skip reset_crashkernel_after_update during package install
-- Don't check fs modified when dump target is lvm2 thinp
-- tests: use .nmconnection to set up test network
-- fadump: preserve file modification time to help with hardlinking
-- fadump: do not use squash to reduce image size
-- selftest: Add lvm2 thin provision for kdump test
-- selftest: Only iterate the .sh files for test execution
-- Add dependency of dracut lvmthinpool-monitor module
-- lvm.conf should be check modified if lvm2 thinp enabled
-- Add lvm2 thin provision dump target checker
-
-* Thu Oct 27 2022 Coiby <coxu@redhat.com> - 2.0.25-2
-- Update makedumpfile to 1.7.2
-- Skip reading /etc/defaut/grub for s390x
-- Include the memory overhead cost of cryptsetup when estimating the memory requirement for LUKS-encrypted target
-- Choosing the most memory-consuming key slot when estimating the memory requirement for LUKS-encrypted target
-- Fix grep warnings "grep: warning: stray \ before -"
-- Only try to reset crashkernel for osbuild during package install
-- Prefix reset-crashkernel-{for-installed_kernel,after-update} with underscore
-- Seperate dracut and dracut-squash compressor for zstd
-- Fix the sync issue for dump_fs
-- virtiofs support for kexec-tools
-- fadump: avoid non-debug kernel use for fadump case
-- mkdumprd: Improve error messages on non-existing NFS target directories
-- kdumpctl: make the kdump.log root-readable-only
-- sysconfig: use a simple generator script to maintain
-
 * Wed Aug 03 2022 Coiby <coxu@redhat.com> - 2.0.25-1
 - Update kexec-tools to 2.0.25
 - remind the users to run zipl after calling grubby on s390x
@@ -920,7 +1047,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 - Revert "dracut-module-setup.sh: pass correct ip= param for ipv6"
 
 * Sat Apr 28 2018 Dave Young <dyoung@redhat.com> - 2.0.17-2
-- pull in makedumpfile 1.6.3
+- pull in makedumpfile 1.6.3 
 
 * Sat Apr 28 2018 Dave Young <dyoung@redhat.com> - 2.0.17-1
 - pull in 2.0.17
@@ -980,10 +1107,10 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 * Tue Aug 8 2017 Dave Young <dyoung@redhat.com> - 2.0.15-10
 - Improve 'cpu add' udev rules
 - module-setup: suppress the early iscsi error messages
-- mkdumprd: use 300s as the default systemd unit timeout for kdump mount
+- mkdumprd: use 300s as the default systemd unit timeout for kdump mount 
 
 * Mon Aug 7 2017 Dave Young <dyoung@redhat.com> - 2.0.15-9
-- fix makedumpfile bug 1474706
+- fix makedumpfile bug 1474706 
 
 * Thu Aug 03 2017 Fedora Release Engineering <releng@fedoraproject.org> - 2.0.15-8
 - Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild
@@ -1139,9 +1266,9 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 - module-setup: Use get_ifcfg_filename() to get the proper ifcfg file
 
 * Mon May 30 2016 Dave Young <dyoung@redhat.com> - 2.0.12-4
-- update kdump anaconda addon to add mem range in tui
+- update kdump anaconda addon to add mem range in tui 
 - .gitignore: Update to make it more generic
-- kdumpctl: check_rebuild improvement
+- kdumpctl: check_rebuild improvement 
 - kdumpctl: Do not rebuild initramfs when $KDUMP_BOOTDIR is read only
 
 * Tue Mar 29 2016 Dave Young <dyoung@redhat.com> - 2.0.12-3
@@ -1152,7 +1279,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 - ppc64le: fix kexec hang due to ppc64 elf abi breakage
 
 * Tue Mar 22 2016 Dave Young <dyoung@redhat.com> - 2.0.12-1
-- Rebase kexec-tools to 2.0.12
+- Rebase kexec-tools to 2.0.12 
 
 * Thu Feb 04 2016 Fedora Release Engineering <releng@fedoraproject.org> - 2.0.11-4
 - Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild
@@ -1165,7 +1292,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 - fix bogus date in changelog
 
 * Thu Nov 19 2015 Dave Young <dyoung@redhat.com> - 2.0.11-2
-- Rebase to upstream makedumpfile 1.5.9
+- Rebase to upstream makedumpfile 1.5.9 
 
 * Mon Nov 9 2015 Dave Young <dyoung@redhat.com> - 2.0.11-1
 - Rebase to upstream kexec-tools 2.0.11
@@ -1175,7 +1302,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 - Remove duplicate prefix path ${initdir}
 
 * Tue Sep 8 2015 Dave Young <dyoung@redhat.com> - 2.0.10-8
-- update kdump addon to fix a kickstart installationi issue
+- update kdump addon to fix a kickstart installationi issue 
 
 * Wed Aug 19 2015 Dave Young <dyoung@redhat.com> - 2.0.10-7
 - add man page for kdumpctl
@@ -1517,7 +1644,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 
 * Thu Mar 14 2013 Baoquan He <bhe@redhat.com> - 2.0.3-69
 - Support for eppic language as a subpackage
-
+ 
 * Thu Mar 14 2013 Baoquan He <bhe@redhat.com> - 2.0.3-68
 - tune sysconfig to save memory usage
 - Remove useless codes related to LOGGER in kdumpctl
@@ -1644,7 +1771,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 - do not add fstab-sys module in dracut cmdline
 - omit dash module
 - network dns config fix
-- shell exit value fix
+- shell exit value fix 
 
 * Thu Jul 19 2012 Fedora Release Engineering <rel-eng@lists.fedoraproject.org> - 2.0.3-52
 - Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild
@@ -1971,7 +2098,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 - Make makedumpfile a dynamic binary
 
 * Mon Jul 06 2009 Neil Horman <nhorman@redhat.com> 2.0.0-19
-- Fix build issue
+- Fix build issue 
 
 * Mon Jul 06 2009 Neil Horman <nhorman@redhat.com> 2.0.0-18
 - Updated initscript to use mkdumprd2 if manifest is present
@@ -2183,7 +2310,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 - updating mkdumprd to use new kcp syntax
 
 * Wed Aug 23 2006 Neil Horman <nhorman@redhat.com> - 1.101-48
-- Bumping revision number
+- Bumping revision number 
 
 * Tue Aug 22 2006 Jarod Wilson <jwilson@redhat.com> - 1.101-47
 - ppc64 no-more-platform fix
@@ -2203,7 +2330,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 
 * Tue Aug 15 2006 Neil Horman <nhorman@redhat.com> - 1.101-44
 - updated init script to implement status function/scrub err messages
-
+ 
 * Wed Aug 09 2006 Jarod Wilson <jwilson@redhat.com> - 1.101-43
 - Misc spec cleanups and macro-ifications
 
@@ -2211,13 +2338,13 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 - Add %%dir /var/crash, so default kdump setup works
 
 * Thu Aug 03 2006 Neil Horman <nhorman@redhat.com> - 1.101-41
-- fix another silly makefile error for makedumpfile
+- fix another silly makefile error for makedumpfile 
 
 * Thu Aug 03 2006 Neil Horman <nhorman@redhat.com> - 1.101-40
-- exclude makedumpfile from build on non-x86[_64] arches
+- exclude makedumpfile from build on non-x86[_64] arches 
 
 * Thu Aug 03 2006 Neil Horman <nhorman@redhat.com> - 1.101-39
-- exclude makedumpfile from build on non-x86[_64] arches
+- exclude makedumpfile from build on non-x86[_64] arches 
 
 * Thu Aug 03 2006 Neil Horman <nhorman@redhat.com> - 1.101-38
 - updating makedumpfile makefile to use pkg-config on glib-2.0
@@ -2314,7 +2441,7 @@ rm -f %{buildroot}/%{_libdir}/kexec-tools/kexec_test
 
 * Wed Nov 16 2005 Thomas Graf <tgraf@redhat.com> - 1.101-5
 - Report missing kdump kernel image as warning
-
+ 
 * Thu Nov  3 2005 Jeff Moyer <jmoyer@redhat.com> - 1.101-4
 - Build for x86_64 as well.  Kdump support doesn't work there, but users
   should be able to use kexec.

live-image-kdump-howto.txt

@@ -0,0 +1,25 @@
+Kdump now works on live images with some manual configurations. Here is the step
+by step guide.
+
+1. Enable crashkernel reservation
+
+Since there isn't any config file that can be used to configure kernel
+parameters for live images before booting them, we have to append 'crashkernel'
+argument in boot menu every time we boot a live image.
+
+2. Change dump target in /etc/kdump.conf
+
+When kdump kernel boots in a live environment, the default target /var/crash is
+in RAM so you need to change the dump target to an external disk or a network
+dump target.
+
+Besides, make sure that "default dump_to_rootfs" is not specified.
+
+3. Start kdump service
+
+    $ kdumpctl start
+
+4. Trigger a kdump test
+
+    $ echo 1 > /proc/sys/kernel/sysrq
+    $ echo c > /proc/sysrq-trigger

mkdumprd

@@ -0,0 +1,460 @@
+#!/bin/bash --norc
+# New mkdumprd
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Written by Cong Wang <amwang@redhat.com>
+#
+
+if [[ -f /etc/sysconfig/kdump ]]; then
+	. /etc/sysconfig/kdump
+fi
+
+[[ $dracutbasedir ]] || dracutbasedir=/usr/lib/dracut
+. $dracutbasedir/dracut-functions.sh
+. /lib/kdump/kdump-lib.sh
+. /lib/kdump/kdump-logger.sh
+export IN_KDUMP=1
+
+#initiate the kdump logger
+if ! dlog_init; then
+	echo "failed to initiate the kdump logger."
+	exit 1
+fi
+
+SSH_KEY_LOCATION=$DEFAULT_SSHKEY
+SAVE_PATH=$(get_save_path)
+OVERRIDE_RESETTABLE=0
+
+extra_modules=""
+dracut_args=(--add kdumpbase --quiet --hostonly --hostonly-cmdline --hostonly-i18n --hostonly-mode strict -o "plymouth resume ifcfg earlykdump")
+
+MKDUMPRD_TMPDIR="$(mktemp -d -t mkdumprd.XXXXXX)"
+[ -d "$MKDUMPRD_TMPDIR" ] || perror_exit "dracut: mktemp -p -d -t dracut.XXXXXX failed."
+MKDUMPRD_TMPMNT="$MKDUMPRD_TMPDIR/target"
+
+trap '
+    ret=$?;
+    is_mounted $MKDUMPRD_TMPMNT && umount -f $MKDUMPRD_TMPMNT;
+    [[ -d $MKDUMPRD_TMPDIR ]] && rm --one-file-system -rf -- "$MKDUMPRD_TMPDIR";
+    exit $ret;
+    ' EXIT
+
+# clean up after ourselves no matter how we die.
+trap 'exit 1;' SIGINT
+
+add_dracut_arg()
+{
+	dracut_args+=("$@")
+}
+
+add_dracut_mount()
+{
+	add_dracut_arg "--mount" "$1"
+}
+
+add_dracut_sshkey()
+{
+	add_dracut_arg "--sshkey" "$1"
+}
+
+# caller should ensure $1 is valid and mounted in 1st kernel
+to_mount()
+{
+	local _target=$1 _fstype=$2 _options=$3 _sed_cmd _new_mntpoint _pdev
+
+	_new_mntpoint=$(get_kdump_mntpoint_from_target "$_target")
+	_fstype="${_fstype:-$(get_fs_type_from_target "$_target")}"
+	_options="${_options:-$(get_mntopt_from_target "$_target")}"
+	_options="${_options:-defaults}"
+
+	if [[ $_fstype == "nfs"* ]]; then
+		_pdev=$_target
+		_sed_cmd+='s/,\(mount\)\?addr=[^,]*//g;'
+		_sed_cmd+='s/,\(mount\)\?proto=[^,]*//g;'
+		_sed_cmd+='s/,clientaddr=[^,]*//;'
+	else
+		# for non-nfs _target converting to use udev persistent name
+		_pdev="$(kdump_get_persistent_dev "$_target")"
+		if [[ -z $_pdev ]]; then
+			return 1
+		fi
+	fi
+
+	# mount fs target as rw in 2nd kernel
+	_sed_cmd+='s/\(^\|,\)ro\($\|,\)/\1rw\2/g;'
+	# with 'noauto' in fstab nfs and non-root disk mount will fail in 2nd
+	# kernel, filter it out here.
+	_sed_cmd+='s/\(^\|,\)noauto\($\|,\)/\1/g;'
+	# drop nofail or nobootwait
+	_sed_cmd+='s/\(^\|,\)nofail\($\|,\)/\1/g;'
+	_sed_cmd+='s/\(^\|,\)nobootwait\($\|,\)/\1/g;'
+
+	_options=$(echo "$_options" | sed "$_sed_cmd")
+
+	echo "$_pdev $_new_mntpoint $_fstype $_options"
+}
+
+#Function: get_ssh_size
+#$1=dump target
+#called from while loop and shouldn't read from stdin, so we're using "ssh -n"
+get_ssh_size()
+{
+	local _out
+	local _opt=("-i" "$SSH_KEY_LOCATION" "-o" "BatchMode=yes" "-o" "StrictHostKeyChecking=yes")
+
+	if ! _out=$(ssh -q -n "${_opt[@]}" "$1" "df" "--output=avail" "$SAVE_PATH"); then
+		perror_exit "checking remote ssh server available size failed."
+	fi
+
+	echo -n "$_out" | tail -1
+}
+
+#mkdir if save path does not exist on ssh dump target
+#$1=ssh dump target
+#caller should ensure write permission on $1:$SAVE_PATH
+#called from while loop and shouldn't read from stdin, so we're using "ssh -n"
+mkdir_save_path_ssh()
+{
+	local _opt _dir
+	_opt=(-i "$SSH_KEY_LOCATION" -o BatchMode=yes -o StrictHostKeyChecking=yes)
+	ssh -qn "${_opt[@]}" "$1" mkdir -p "$SAVE_PATH" &> /dev/null ||
+		perror_exit "mkdir failed on $1:$SAVE_PATH"
+
+	# check whether user has write permission on $1:$SAVE_PATH
+	_dir=$(ssh -qn "${_opt[@]}" "$1" mktemp -dqp "$SAVE_PATH" 2> /dev/null) ||
+		perror_exit "Could not create temporary directory on $1:$SAVE_PATH. Make sure user has write permission on destination"
+	ssh -qn "${_opt[@]}" "$1" rmdir "$_dir"
+
+	return 0
+}
+
+#Function: get_fs_size
+#$1=dump target
+get_fs_size()
+{
+	df --output=avail "$(get_mntpoint_from_target "$1")/$SAVE_PATH" | tail -1
+}
+
+#Function: get_raw_size
+#$1=dump target
+get_raw_size()
+{
+	fdisk -s "$1"
+}
+
+#Function: check_size
+#$1: dump type string ('raw', 'fs', 'ssh')
+#$2: dump target
+check_size()
+{
+	local avail memtotal
+
+	memtotal=$(awk '/MemTotal/{print $2}' /proc/meminfo)
+	case "$1" in
+	raw)
+		avail=$(get_raw_size "$2")
+		;;
+	ssh)
+		avail=$(get_ssh_size "$2")
+		;;
+	fs)
+		avail=$(get_fs_size "$2")
+		;;
+	*)
+		return
+		;;
+	esac || perror_exit "Check dump target size failed"
+
+	if [[ $avail -lt $memtotal ]]; then
+		dwarn "Warning: There might not be enough space to save a vmcore."
+		dwarn "         The size of $2 should be greater than $memtotal kilo bytes."
+	fi
+}
+
+check_save_path_fs()
+{
+	local _path=$1
+
+	if [[ ! -d $_path ]]; then
+		perror_exit "Dump path $_path does not exist."
+	fi
+}
+
+mount_failure()
+{
+	local _target=$1
+	local _mnt=$2
+	local _fstype=$3
+	local msg="Failed to mount $_target"
+
+	if [[ -n $_mnt ]]; then
+		msg="$msg on $_mnt"
+	fi
+
+	msg="$msg for kdump preflight check."
+
+	if [[ $_fstype == "nfs" ]]; then
+		msg="$msg Please make sure nfs-utils has been installed."
+	fi
+
+	perror_exit "$msg"
+}
+
+check_user_configured_target()
+{
+	local _target=$1 _cfg_fs_type=$2 _mounted
+	local _mnt _opt _fstype
+
+	_mnt=$(get_mntpoint_from_target "$_target")
+	_opt=$(get_mntopt_from_target "$_target")
+	_fstype=$(get_fs_type_from_target "$_target")
+
+	if [[ -n $_fstype ]]; then
+		# In case of nfs4, nfs should be used instead, nfs* options is deprecated in kdump.conf
+		[[ $_fstype == "nfs"* ]] && _fstype=nfs
+
+		if [[ -n $_cfg_fs_type ]] && [[ $_fstype != "$_cfg_fs_type" ]]; then
+			perror_exit "\"$_target\" have a wrong type config \"$_cfg_fs_type\", expected \"$_fstype\""
+		fi
+	else
+		_fstype="$_cfg_fs_type"
+		_fstype="$_cfg_fs_type"
+	fi
+
+	# For noauto mount, mount it inplace with default value.
+	# Else use the temporary target directory
+	if [[ -n $_mnt ]]; then
+		if ! is_mounted "$_mnt"; then
+			if [[ $_opt == *",noauto"* ]]; then
+				mount "$_mnt" || mount_failure "$_target" "$_mnt" "$_fstype"
+				_mounted=$_mnt
+			else
+				perror_exit "Dump target \"$_target\" is neither mounted nor configured as \"noauto\""
+			fi
+		fi
+	else
+		_mnt=$MKDUMPRD_TMPMNT
+		mkdir -p "$_mnt"
+		mount "$_target" "$_mnt" -t "$_fstype" -o defaults || mount_failure "$_target" "" "$_fstype"
+		_mounted=$_mnt
+	fi
+
+	# For user configured target, use $SAVE_PATH as the dump path within the target
+	if [[ ! -d "$_mnt/$SAVE_PATH" ]]; then
+		perror_exit "Dump path \"$_mnt/$SAVE_PATH\" does not exist in dump target \"$_target\""
+	fi
+
+	check_size fs "$_target"
+
+	# Unmount it early, if function is interrupted and didn't reach here, the shell trap will clear it up anyway
+	if [[ -n $_mounted ]]; then
+		umount -f -- "$_mounted"
+	fi
+}
+
+# $1: core_collector config value
+verify_core_collector()
+{
+	local _cmd="${1%% *}"
+	local _params="${1#* }"
+
+	if [[ $_cmd != "makedumpfile" ]]; then
+		if is_raw_dump_target; then
+			dwarn "Warning: specifying a non-makedumpfile core collector, you will have to recover the vmcore manually."
+		fi
+		return
+	fi
+
+	if is_ssh_dump_target || is_raw_dump_target; then
+		if ! strstr "$_params" "-F"; then
+			perror_exit 'The specified dump target needs makedumpfile "-F" option.'
+		fi
+		_params="$_params vmcore"
+	else
+		_params="$_params vmcore dumpfile"
+	fi
+
+	# shellcheck disable=SC2086
+	if ! $_cmd --check-params $_params; then
+		perror_exit "makedumpfile parameter check failed."
+	fi
+}
+
+add_mount()
+{
+	local _mnt
+
+	_mnt=$(to_mount "$@") || exit 1
+
+	add_dracut_mount "$_mnt"
+}
+
+#handle the case user does not specify the dump target explicitly
+handle_default_dump_target()
+{
+	local _target
+	local _mntpoint
+
+	is_user_configured_dump_target && return
+
+	check_save_path_fs "$SAVE_PATH"
+
+	_save_path=$(get_bind_mount_source "$SAVE_PATH")
+	_target=$(get_target_from_path "$_save_path")
+	_mntpoint=$(get_mntpoint_from_target "$_target")
+
+	SAVE_PATH=${_save_path##"$_mntpoint"}
+	add_mount "$_target"
+	check_size fs "$_target"
+}
+
+# $1: function name
+for_each_block_target()
+{
+	local dev majmin
+
+	for dev in $(get_kdump_targets); do
+		[[ -b $dev ]] || continue
+		majmin=$(get_maj_min "$dev")
+		check_block_and_slaves "$1" "$majmin" && return 1
+	done
+
+	return 0
+}
+
+#judge if a specific device with $1 is unresettable
+#return false if unresettable.
+is_unresettable()
+{
+	local path device resettable=1
+
+	path="/sys/$(udevadm info --query=all --path="/sys/dev/block/$1" | awk '/^P:/ {print $2}' | sed -e 's/\(cciss[0-9]\+\/\).*/\1/g' -e 's/\/block\/.*$//')/resettable"
+	if [[ -f $path ]]; then
+		resettable="$(< "$path")"
+		[[ $resettable -eq 0 ]] && [[ $OVERRIDE_RESETTABLE -eq 0 ]] && {
+			device=$(udevadm info --query=all --path="/sys/dev/block/$1" | awk -F= '/DEVNAME/{print $2}')
+			derror "Error: Can not save vmcore because device $device is unresettable"
+			return 0
+		}
+	fi
+
+	return 1
+}
+
+#check if machine is resettable.
+#return true if resettable
+check_resettable()
+{
+	local _target _override_resettable
+
+	_override_resettable=$(kdump_get_conf_val override_resettable)
+	OVERRIDE_RESETTABLE=${_override_resettable:-$OVERRIDE_RESETTABLE}
+	if [ "$OVERRIDE_RESETTABLE" != "0" ] && [ "$OVERRIDE_RESETTABLE" != "1" ]; then
+		perror_exit "override_resettable value '$OVERRIDE_RESETTABLE' is invalid"
+	fi
+
+	for_each_block_target is_unresettable && return
+
+	return 1
+}
+
+check_crypt()
+{
+	local _dev
+
+	for _dev in $(get_kdump_targets); do
+		if [[ -n $(get_luks_crypt_dev "$(get_maj_min "$_dev")") ]]; then
+			derror "Device $_dev is encrypted." && return 1
+		fi
+	done
+}
+
+if ! check_resettable; then
+	exit 1
+fi
+
+if ! check_crypt; then
+	dwarn "Warning: Encrypted device is in dump path, which is not recommended, see kexec-kdump-howto.txt for more details."
+fi
+
+# firstly get right SSH_KEY_LOCATION
+keyfile=$(kdump_get_conf_val sshkey)
+if [[ -f $keyfile ]]; then
+	# canonicalize the path
+	SSH_KEY_LOCATION=$(/usr/bin/readlink -m "$keyfile")
+fi
+
+while read -r config_opt config_val; do
+	# remove inline comments after the end of a directive.
+	case "$config_opt" in
+	extra_modules)
+		extra_modules="$extra_modules $config_val"
+		;;
+	ext[234] | xfs | btrfs | minix | nfs)
+		check_user_configured_target "$config_val" "$config_opt"
+		add_mount "$config_val" "$config_opt"
+		;;
+	raw)
+		# checking raw disk writable
+		dd if="$config_val" count=1 of=/dev/null > /dev/null 2>&1 || {
+			perror_exit "Bad raw disk $config_val"
+		}
+		_praw=$(persistent_policy="by-id" kdump_get_persistent_dev "$config_val")
+		if [[ -z $_praw ]]; then
+			exit 1
+		fi
+		add_dracut_arg "--device" "$_praw"
+		check_size raw "$config_val"
+		;;
+	ssh)
+		if strstr "$config_val" "@"; then
+			mkdir_save_path_ssh "$config_val"
+			check_size ssh "$config_val"
+			add_dracut_sshkey "$SSH_KEY_LOCATION"
+		else
+			perror_exit "Bad ssh dump target $config_val"
+		fi
+		;;
+	core_collector)
+		verify_core_collector "$config_val"
+		;;
+	dracut_args)
+		while read -r dracut_arg; do
+			add_dracut_arg "$dracut_arg"
+		done <<< "$(echo "$config_val" | xargs -n 1 echo)"
+		;;
+	*) ;;
+
+	esac
+done <<< "$(kdump_read_conf)"
+
+handle_default_dump_target
+
+if ! have_compression_in_dracut_args; then
+	# Here zstd is set as the default compression method. If squash module
+	# is available for dracut, libzstd will be used by mksquashfs. If
+	# squash module is unavailable, command zstd will be used instead.
+	if is_squash_available || is_zstd_command_available; then
+		add_dracut_arg "--compress" "zstd"
+	fi
+fi
+
+if [[ -n $extra_modules ]]; then
+	add_dracut_arg "--add-drivers" "$extra_modules"
+fi
+
+# TODO: The below check is not needed anymore with the introduction of
+#       'zz-fadumpinit' module, that isolates fadump's capture kernel initrd,
+#       but still sysroot.mount unit gets generated based on 'root=' kernel
+#       parameter available in fadump case. So, find a way to fix that first
+#       before removing this check.
+if ! is_fadump_capable; then
+	# The 2nd rootfs mount stays behind the normal dump target mount,
+	# so it doesn't affect the logic of check_dump_fs_modified().
+	is_dump_to_rootfs && add_mount "$(to_dev_name "$(get_root_fs_device)")"
+
+	add_dracut_arg "--no-hostonly-default-device"
+fi
+
+dracut "${dracut_args[@]}" "$@"

mkdumprd.8

@@ -0,0 +1,39 @@
+.TH MKDUMRD 8 "Fri Feb 9 2007"
+.SH NAME
+mkdumprd \- creates initial ramdisk images for kdump crash recovery 
+.SH SYNOPSIS
+\fBmkdumprd\fR [OPTION]
+
+.SH DESCRIPTION
+\fBmkdumprd\fR creates an initial ram file system for use in conjunction with
+the booting of a kernel within the kdump framework for crash recovery.
+\fBmkdumprds\fR purpose is to create an initial ram filesystem capable of copying
+the crashed systems vmcore image to a location specified in \fI/etc/kdump.conf 
+
+\fBmkdumprd\fR interrogates the running system to understand what modules need to
+be loaded in the initramfs (based on configuration retrieved from
+\fI/etc/kdump.conf)\fR
+
+\fBmkdumprd\fR add a new \fBdracut\fR module 99kdumpbase and use \fBdracut\fR
+utility to generate the initramfs. When generating a kdump initramfs, \fBmkdumprd\fR
+will determine how much disk space is available, if the dump target's available
+space is not greater than the total system memory, \fBmkdumprd\fR will print a
+warning to remind that there might not be enough space to save a vmcore. The
+warning covers extreme scenarios such as the slab explodes with non-zero data or
+a full vmcore, etc. Therefore, need to prevent users from having minimum disk
+space for crash dump.
+
+\fBmkdumprd\fR was not intended for casual use outside of the service
+initialization script for the kdump utility, and should not be run manually.  If
+you require a custom kdump initramfs image, it is suggested that you use the
+kdump service infrastructure to create one, and then manually unpack, modify and
+repack the image.
+
+
+.SH OPTIONS
+.TP
+All options here are passed to dracut directly, please refer \fBdracut\fR docs
+for the info.
+
+.SH "SEE ALSO"
+.BR dracut (8)

mkfadumprd

@@ -0,0 +1,74 @@
+#!/bin/bash --norc
+# Generate an initramfs image that isolates dump capture capability within
+# the default initramfs using zz-fadumpinit dracut module.
+
+if [[ -f /etc/sysconfig/kdump ]]; then
+	. /etc/sysconfig/kdump
+fi
+
+[[ $dracutbasedir ]] || dracutbasedir=/usr/lib/dracut
+. $dracutbasedir/dracut-functions.sh
+. /lib/kdump/kdump-lib.sh
+. /lib/kdump/kdump-logger.sh
+
+#initiate the kdump logger
+if ! dlog_init; then
+	echo "mkfadumprd: failed to initiate the kdump logger."
+	exit 1
+fi
+
+MKFADUMPRD_TMPDIR="$(mktemp -d -t mkfadumprd.XXXXXX)"
+[ -d "$MKFADUMPRD_TMPDIR" ] || perror_exit "mkfadumprd: mktemp -d -t mkfadumprd.XXXXXX failed."
+trap '
+    ret=$?;
+    [[ -d $MKFADUMPRD_TMPDIR ]] && rm --one-file-system -rf -- "$MKFADUMPRD_TMPDIR";
+    exit $ret;
+    ' EXIT
+
+# clean up after ourselves no matter how we die.
+trap 'exit 1;' SIGINT
+
+MKDUMPRD="/sbin/mkdumprd -f"
+# Default boot initramfs to be rebuilt
+REBUILD_INITRD="$1" && shift
+TARGET_INITRD="$1" && shift
+FADUMP_INITRD="$MKFADUMPRD_TMPDIR/fadump.img"
+
+### First build an initramfs with dump capture capability
+# this file tells the initrd is fadump enabled
+touch "$MKFADUMPRD_TMPDIR/fadump.initramfs"
+ddebug "rebuild fadump initrd: $FADUMP_INITRD $DEFAULT_INITRD $KDUMP_KERNELVER"
+if ! $MKDUMPRD "$FADUMP_INITRD" -i "$MKFADUMPRD_TMPDIR/fadump.initramfs" /etc/fadump.initramfs; then
+	perror_exit "mkfadumprd: failed to build image with dump capture support"
+fi
+
+### Unpack the initramfs having dump capture capability
+mkdir -p "$MKFADUMPRD_TMPDIR/fadumproot"
+if ! (pushd "$MKFADUMPRD_TMPDIR/fadumproot" > /dev/null && lsinitrd --unpack "$FADUMP_INITRD" &&
+	popd > /dev/null); then
+	derror "mkfadumprd: failed to unpack '$MKFADUMPRD_TMPDIR'"
+	exit 1
+fi
+
+### Pack it into the normal boot initramfs with zz-fadumpinit module
+_dracut_isolate_args=(
+	--rebuild "$REBUILD_INITRD" --add zz-fadumpinit
+	-i "$MKFADUMPRD_TMPDIR/fadumproot" /fadumproot
+	-i "$MKFADUMPRD_TMPDIR/fadumproot/usr/lib/dracut/hostonly-kernel-modules.txt"
+	/usr/lib/dracut/fadump-kernel-modules.txt
+)
+
+if is_squash_available; then
+	_dracut_isolate_args+=(--add squash)
+fi
+
+# Same as setting zstd in mkdumprd
+if ! have_compression_in_dracut_args; then
+	if is_squash_available || is_zstd_command_available; then
+		_dracut_isolate_args+=(--compress zstd)
+	fi
+fi
+
+if ! dracut --force --quiet "${_dracut_isolate_args[@]}" "$@" "$TARGET_INITRD"; then
+	perror_exit "mkfadumprd: failed to setup '$TARGET_INITRD' with dump capture capability"
+fi

sources

@@ -1 +1,3 @@
-SHA512 (kexec-tools-2.0.32.tar.xz) = 60f120f8e46b9fb5dcf5a5b344ee8b303878ba9f71d58a3eefa1c9f044a6a2192b285154b738970263384c6e7281a854cd48a185334c08141aa4e6cf08230654
+SHA512 (eppic-e8844d3.tar.gz) = d86b9f90c57e694107272d8f71b87f66a30743b9530480fb6f665026bbada4c6b0205a83e40b5383663a945681cfbfcf1ee79469fc219ddf679473c4b2290763
+SHA512 (kexec-tools-2.0.25.tar.xz) = 6fd3fe11d428c5bb2ce318744146e03ddf752cc77632064bdd7418ef3ad355ad2e2db212d68a5bc73554d78f786901beb42d72bd62e2a4dae34fb224b667ec6b
+SHA512 (makedumpfile-1.7.1.tar.gz) = 93e36487b71f567d3685b151459806cf36017e52bf3ee68dd448382b279a422d1a8abef72e291ccb8206f2149ccd08ba484ec0027d1caab3fa1edbc3d28c3632

spec/kdump-lib_spec.sh

@@ -48,74 +48,4 @@ Describe 'kdump-lib'
 		End
 	End
 
-	Describe "_crashkernel_add()"
-		Context "For valid input values"
-			Parameters
-				"1G-4G:256M,4G-64G:320M,64G-:576M" "100M" "1G-4G:356M,4G-64G:420M,64G-:676M"
-				"1G-4G:256M" "100" "1G-4G:268435556" # avoids any rounding when size % 1024 != 0
-				"1G-4G:256M,4G-64G:320M,64G-:576M@4G" "100M" "1G-4G:356M,4G-64G:420M,64G-:676M@4G"
-				"1G-4G:1G,4G-64G:2G,64G-:3G@4G" "100M" "1G-4G:1124M,4G-64G:2148M,64G-:3172M@4G"
-				"1G-4G:10000K,4G-64G:20000K,64G-:40000K@4G" "100M" "1G-4G:112400K,4G-64G:122400K,64G-:142400K@4G"
-				"1,high" "1" "2,high"
-				"1K,low" "1" "1025,low"
-				"128G-1T:4G" "0" "128G-1T:4G"
-				"10T-100T:1T" "0" "10T-100T:1T"
-				"128G-1T:4G" "0M" "128G-1T:4G"
-				"128G-1P:4G" "0M" "128G-1P:4G"
-				"128G-1E:4G" "0M" "128G-1E:4G"
-				"1M@1G" "1k" "1025K@1G"
-				"500M@1G" "-100m" "400M@1G"
-				"1099511627776" "0" "1T"
-			End
-			It "should add delta to every value after ':'"
-				When call _crashkernel_add "$1" "$2"
-				The output should equal "$3"
-			End
-		End
-		Context "For invalid input values"
-			Parameters
-				"1G-4G:256M.4G-64G:320M" "100M"
-				"foo" "1"
-				"1" "bar"
-			End
-			It "shall return an error"
-				When call _crashkernel_add "$1" "$2"
-				The output should equal ""
-				The status should be failure
-			End
-		End
-	End
-
-	Describe 'prepare_cmdline()'
-		get_bootcpu_apicid() {
-			echo 1
-		}
-
-		get_watchdog_drvs() {
-			echo foo
-		}
-
-		add="disable_cpu_apicid=1 foo.pretimeout=0"
-
-		Parameters
-		       #test  cmdline       remove    add       result
-			"#1"  "a b c"       ""        ""        "a b c"
-			"#2"  "a b c"       "b"       ""        "a c"
-			"#3"  "a b=x c"     "b"       ""        "a c"
-			"#4"  "a b='x y' c" "b"       ""        "a c"
-			"#5"  "a b='x y' c" "b=x"     ""        "a c"
-			"#6"  "a b='x y' c" "b='x y'" ""        "a c"
-			"#7"  "a b c"       ""        "x"       "a b c x"
-			"#8"  "a b c"       ""        "x=1"     "a b c x=1"
-			"#9"  "a b c"       ""        "x='1 2'" "a b c x='1 2'"
-			"#10" "a b c"       "a"       "x='1 2'" "b c x='1 2'"
-			"#11" "a b c"       "x"       "x='1 2'" "a b c x='1 2'"
-		End
-
-		It "Test $1: should generate the correct kernel command line"
-			When call prepare_cmdline "$2" "$3" "$4"
-			The output should equal "$5 $add"
-		End
-	End
-
 End

spec/kdumpctl_general_spec.sh

@@ -107,105 +107,92 @@ Describe 'kdumpctl'
 		End
 	End
 
-	Describe "_get_dracut_arg"
-		dracut_args='-o "foo bar baz" -t 1 --test="a b c" --omit bla'
-		Parameters
-			-o	--omit	2	"foo bar baz bla"
-			-e	--empty	0	""
-			-t	""	1	"1"
-			""	--test	1	"a b c"
-			""	""	0	""
-		End
-		It "should parse the dracut_args correctly"
-			When call _get_dracut_arg "$1" "$2" "$dracut_args"
-			The status should equal $3
-			The output should equal "$4"
-		End
-	End
+	Describe '_update_kernel_arg_in_grub_etc_default()'
+		GRUB_ETC_DEFAULT=/tmp/default_grub
 
-	Describe "is_dracut_mod_omitted()"
-		KDUMP_CONFIG_FILE=$(mktemp -t kdump_conf.XXXXXXXXXX)
 		cleanup() {
-			rm -f "$kdump_conf"
+			rm -rf "$GRUB_ETC_DEFAULT"
 		}
 		AfterAll 'cleanup'
 
-		Parameters:dynamic
-			for opt in '-o ' '--omit ' '--omit='; do
-				for val in \
-					'foo' \
-					'"foo"' \
-					'"foo bar baz"' \
-					'"bar foo baz"' \
-					'"bar baz foo"'; do
-					%data success foo "$opt$val"
-					%data success foo "-a x $opt$val -i y"
-					%data failure xyz "$opt$val"
-					%data failure xyz "-a x $opt$val -i y"
-				done
-			done
-			%data success foo "-o xxx -o foo"
-			%data failure foo "-a x -i y"
+		Context 'when the given parameter is in different positions'
+			Parameters
+				"crashkernel=222M fadump=on rhgb quiet" crashkernel 333M
+				" fadump=on crashkernel=222M rhgb quiet" crashkernel 333M
+				"fadump=on rhgb quiet crashkernel=222M" crashkernel 333M
+				"fadump=on rhgb quiet" crashkernel 333M
+				"fadump=on foo=bar1 rhgb quiet" foo bar2
+			End
+
+			It 'should update the kernel parameter correctly'
+				echo 'GRUB_CMDLINE_LINUX="'"$1"'"' >$GRUB_ETC_DEFAULT
+				When call _update_kernel_arg_in_grub_etc_default "$2" "$3"
+				# the updated kernel parameter should appear in the end
+				The contents of file $GRUB_ETC_DEFAULT should include "$2=$3\""
+			End
 		End
-		It "shall return $1 for module $2 and dracut_args '$3'"
-			echo "dracut_args $3" > $KDUMP_CONFIG_FILE
-			parse_config
-			When call is_dracut_mod_omitted $2
-			The status should be $1
+
+		It 'should only update the given parameter and not update the parameter that has the given parameter as suffix'
+			echo 'GRUB_CMDLINE_LINUX="fadump=on rhgb quiet ckcrashkernel=222M"' >$GRUB_ETC_DEFAULT
+			_ck_val=1G-4G:192M,4G-64G:256M,64G-102400T:512M
+			When call _update_kernel_arg_in_grub_etc_default crashkernel "$_ck_val"
+			The contents of file $GRUB_ETC_DEFAULT should include "crashkernel=$_ck_val\""
+			The contents of file $GRUB_ETC_DEFAULT should include "ckcrashkernel=222M"
 		End
+
+		It 'should be able to handle the cases of there are multiple crashkernel entries'
+			echo 'GRUB_CMDLINE_LINUX="fadump=on rhgb quiet crashkernel=101M crashkernel=222M"' >$GRUB_ETC_DEFAULT
+			_ck_val=1G-4G:192M,4G-64G:256M,64G-102400T:512M
+			When call _update_kernel_arg_in_grub_etc_default crashkernel "$_ck_val"
+			The contents of file $GRUB_ETC_DEFAULT should include "crashkernel=$_ck_val\""
+			The contents of file $GRUB_ETC_DEFAULT should not include "crashkernel=222M"
+		End
+
+		Context 'when it removes a kernel parameter'
+
+			It 'should remove all values for given arg'
+				echo 'GRUB_CMDLINE_LINUX="crashkernel=33M crashkernel=11M fadump=on crashkernel=222M"' >$GRUB_ETC_DEFAULT
+				When call _update_kernel_arg_in_grub_etc_default crashkernel
+				The contents of file $GRUB_ETC_DEFAULT should equal 'GRUB_CMDLINE_LINUX="fadump=on"'
+			End
+
+			It 'should not remove args that have the given arg as suffix'
+				echo 'GRUB_CMDLINE_LINUX="ckcrashkernel=33M crashkernel=11M ckcrashkernel=222M"' >$GRUB_ETC_DEFAULT
+				When call _update_kernel_arg_in_grub_etc_default crashkernel
+				The contents of file $GRUB_ETC_DEFAULT should equal 'GRUB_CMDLINE_LINUX="ckcrashkernel=33M ckcrashkernel=222M"'
+			End
+		End
+
 	End
 
-	Describe '_find_kernel_path_by_release()'
-		# When the array length changes, the Parameters:dynamic should change as well
-		kernel_paths=(/boot/vmlinuz-6.2.11-200.fc37.x86_64
-		              /boot/vmlinuz-5.14.0-316.el9.aarch64+64k
-		              /boot/vmlinuz-5.14.0-322.el9.aarch64
-		              /boot/efi/36b54597c46383/6.4.0-0.rc0.20230427git6e98b09da931.5.fc39.aarch64/linux)
-
-		kernels=(vmlinuz-6.2.11-200.fc37.x86_64
-		         vmlinuz-5.14.0-316.el9.aarch64+64k
-		         vmlinuz-5.14.0-322.el9.aarch64
-		         6.4.0-0.rc0.20230427git6e98b09da931.5.fc39.aarch64)
-
-		grubby() {
-			for key in "${!kernel_paths[@]}"; do
-				echo "kernel=\"${kernel_paths[$key]}\""
-			done
-		}
-
-		Parameters:dynamic
-			# Due to a bug [1] in shellspec, hardcode the loop number instead of using the
-			# array length
-			# [1] https://github.com/shellspec/shellspec/issues/259
-			for key in {0..3}; do
-				%data "${kernels[$key]}" "${kernel_paths[$key]}"
-			done
-		End
-
-		It 'returns the kernel path for the given release'
-			When call _find_kernel_path_by_release "$1"
-			The output should equal "$2"
+	Describe '_read_kernel_arg_in_grub_etc_default()'
+		GRUB_ETC_DEFAULT=/tmp/default_grub
+		It 'should read the value for given arg'
+			echo 'GRUB_CMDLINE_LINUX="crashkernel=33M crashkernel=11M ckcrashkernel=222M"' >$GRUB_ETC_DEFAULT
+			When call _read_kernel_arg_in_grub_etc_default crashkernel
+			 The output should equal '11M'
 		End
 	End
 
 	Describe 'parse_config()'
-		KDUMP_CONFIG_FILE=$(mktemp -t kdump_conf.XXXXXXXXXX)
+		bad_kdump_conf=$(mktemp -t bad_kdump_conf.XXXXXXXXXX)
 		cleanup() {
-			rm -f "$KDUMP_CONFIG_FILE"
+			rm -f "$bad_kdump_conf"
 		}
 		AfterAll 'cleanup'
 
 		It 'should not be happy with unkown option in kdump.conf'
-			echo blabla > "$KDUMP_CONFIG_FILE"
+			KDUMP_CONFIG_FILE="$bad_kdump_conf"
+			echo blabla > "$bad_kdump_conf"
 			When call parse_config
 			The status should be failure
 			The stderr should include 'Invalid kdump config option blabla'
 		End
 
-		Parameters:value aarch64 ppc64le s390x x86_64
-
 		It 'should be happy with the default kdump.conf'
-			./gen-kdump-conf.sh "$1" > "$KDUMP_CONFIG_FILE"
+		 # shellcheck disable=SC2034
+			# override the KDUMP_CONFIG_FILE variable
+			KDUMP_CONFIG_FILE=./kdump.conf
 			When call parse_config
 			The status should be success
 		End

spec/kdumpctl_manage_crashkernel_spec.sh

@@ -1,118 +0,0 @@
-#!/bin/bash
-
-Describe 'Management of the kernel crashkernel parameter.'
-	Include ./kdumpctl
-	kernel1=/boot/vmlinuz-5.15.6-100.fc34.x86_64
-	kernel2=/boot/vmlinuz-5.14.14-200.fc34.x86_64
-	old_ck=1G-4G:162M,4G-64G:256M,64G-:512M
-	new_ck=1G-4G:196M,4G-64G:256M,64G-:512M
-	KDUMP_SPEC_TEST_RUN_DIR=$(mktemp -u /tmp/spec_test.XXXXXXXXXX)
-	GRUB_CFG="$KDUMP_SPEC_TEST_RUN_DIR/grub.cfg"
-
-	uname() {
-		if [[ $1 == '-m' ]]; then
-			echo -n x86_64
-		elif [[ $1 == '-r' ]]; then
-			echo -n $current_kernel
-		fi
-	}
-
-	# dinfo is a bit complex for unit tets, simply mock it
-	dinfo() {
-		echo "$1"
-	}
-
-	kdump_get_arch_recommend_crashkernel() {
-		echo -n "$new_ck"
-	}
-
-	setup() {
-		mkdir -p "$KDUMP_SPEC_TEST_RUN_DIR"
-		cp -r spec/support/boot_load_entries "$KDUMP_SPEC_TEST_RUN_DIR"
-		cp spec/support/grub_env "$KDUMP_SPEC_TEST_RUN_DIR"/env_temp
-		touch "$GRUB_CFG"
-
-		grubby --args crashkernel=$old_ck --update-kernel=$kernel1
-		grubby --args crashkernel=$new_ck --update-kernel=$kernel2
-		grubby --remove-args fadump --update-kernel=ALL
-
-	}
-
-	cleanup() {
-		rm -rf "$KDUMP_SPEC_TEST_RUN_DIR"
-	}
-
-	# the boot loader entries are for a system without a boot partition, mock
-	# mountpoint to let grubby know it
-	Mock mountpoint
-		exit 1
-	End
-
-	grubby() {
-		# - --no-etc-grub-update, not update /etc/default/grub
-		# - --bad-image-okay, don't check the validity of the image
-		# - --env, specify custom grub2 environment block file to avoid modifying
-		#   the default /boot/grub2/grubenv
-		# - --bls-directory, specify custom BootLoaderSpec config files to avoid
-		#   modifying the default /boot/loader/entries
-		/usr/sbin/grubby --no-etc-grub-update --grub2 --config-file="$GRUB_CFG" --bad-image-okay --env="$KDUMP_SPEC_TEST_RUN_DIR"/env_temp -b "$KDUMP_SPEC_TEST_RUN_DIR"/boot_load_entries "$@"
-	}
-
-	# The mocking breaks has_command. Mock it as well to fix the tests.
-	has_command() {
-		[[ "$1" == grubby ]]
-	}
-
-	Describe "When kexec-tools have its default crashkernel updated, "
-
-		Context "if kexec-tools is updated alone, "
-			BeforeAll 'setup'
-			AfterAll 'cleanup'
-			Specify 'reset_crashkernel_after_update should report updated kernels and note that auto_reset_crashkernel=yes'
-				When call reset_crashkernel_after_update
-				The output should include "For kernel=$kernel1, crashkernel=$new_ck now."
-				The output should not include "For kernel=$kernel2, crashkernel=$new_ck now."
-				# A hint on how to turn off auto update of crashkernel
-				The output should include "auto_reset_crashkernel=no"
-			End
-
-			Specify 'kernel1 should have crashkernel updated'
-				When call grubby --info $kernel1
-				The line 3 of output should include crashkernel="$new_ck"
-			End
-
-			Specify 'kernel2 should also have crashkernel updated'
-				When call grubby --info $kernel2
-				The line 3 of output should include crashkernel="$new_ck"
-			End
-
-		End
-
-		Context "If kernel package is installed alone, "
-			BeforeAll 'setup'
-			AfterAll 'cleanup'
-			# BeforeAll somehow doesn't work as expected, manually call setup to bypass this issue.
-			setup
-			new_kernel_ver=new_kernel
-			new_kernel=/boot/vmlinuz-$new_kernel_ver
-			grubby --add-kernel=$new_kernel --initrd=/boot/initramfs-$new_kernel_ver.img --title=$new_kernel_ver
-
-			Specify 'reset_crashkernel_for_installed_kernel should report the new kernel has its crashkernel updated'
-				When call reset_crashkernel_for_installed_kernel $new_kernel_ver
-				The output should include "crashkernel=$new_ck"
-			End
-
-			Specify 'the new kernel should have crashkernel updated'
-				When call grubby --info $new_kernel
-				The output should include crashkernel="$new_ck"
-			End
-
-			Specify 'kernel1 keeps its crashkernel value'
-				When call grubby --info $kernel1
-				The output should include crashkernel="$old_ck"
-			End
-
-		End
-
-	End
-End

spec/kdumpctl_reset_crashkernel_spec.sh

@@ -19,12 +19,6 @@ Describe 'kdumpctl reset-crashkernel [--kernel] [--fadump]'
 	BeforeAll 'setup'
 	AfterAll 'cleanup'
 
-	# the boot loader entries are for a system without a boot partition, mock
-	# mountpoint to let grubby know it
-	Mock mountpoint
-		exit 1
-	End
-
 	grubby() {
 		# - --no-etc-grub-update, not update /etc/default/grub
 		# - --bad-image-okay, don't check the validity of the image
@@ -32,12 +26,7 @@ Describe 'kdumpctl reset-crashkernel [--kernel] [--fadump]'
 		#   the default /boot/grub2/grubenv
 		# - --bls-directory, specify custom BootLoaderSpec config files to avoid
 		#   modifying the default /boot/loader/entries
-		/usr/sbin/grubby --no-etc-grub-update --grub2 --bad-image-okay --env="$KDUMP_SPEC_TEST_RUN_DIR"/env_temp -b "$KDUMP_SPEC_TEST_RUN_DIR"/boot_load_entries "$@"
-	}
-
-	# The mocking breaks has_command. Mock it as well to fix the tests.
-	has_command() {
-		[[ "$1" == grubby ]]
+		@grubby --no-etc-grub-update --grub2 --bad-image-okay --env="$KDUMP_SPEC_TEST_RUN_DIR"/env_temp -b "$KDUMP_SPEC_TEST_RUN_DIR"/boot_load_entries "$@"
 	}
 
 	Describe "Test the kdump dump mode "
@@ -117,6 +106,11 @@ Describe 'kdumpctl reset-crashkernel [--kernel] [--fadump]'
 			fi
 		}
 
+		_update_kernel_arg_in_grub_etc_default() {
+			# don't modify /etc/default/grub during the test
+			echo _update_kernel_arg_in_grub_etc_default "$@"
+		}
+
 		kdump_crashkernel=$(get_default_crashkernel kdump)
 		fadump_crashkernel=$(get_default_crashkernel fadump)
 		Context "when no --kernel specified"
@@ -142,6 +136,7 @@ Describe 'kdumpctl reset-crashkernel [--kernel] [--fadump]'
 			grubby --args crashkernel=$ck --update-kernel ALL
 			Specify 'kdumpctl should warn the user that crashkernel has been udpated'
 				When call reset_crashkernel --kernel=ALL --fadump=on
+				The line 1 of output should include "_update_kernel_arg_in_grub_etc_default crashkernel $fadump_crashkernel"
 				The error should include "Updated crashkernel=$fadump_crashkernel for kernel=$kernel1"
 				The error should include "Updated crashkernel=$fadump_crashkernel for kernel=$kernel2"
 			End
@@ -200,6 +195,8 @@ Describe 'kdumpctl reset-crashkernel [--kernel] [--fadump]'
 			grubby --args fadump=on --update-kernel ALL
 			Specify 'fadump=on to fadump=nocma'
 				When call reset_crashkernel --kernel=ALL --fadump=nocma
+				The line 1 of output should equal "_update_kernel_arg_in_grub_etc_default crashkernel $fadump_crashkernel"
+				The line 2 of output should equal "_update_kernel_arg_in_grub_etc_default fadump nocma"
 				The error should include "Updated crashkernel=$fadump_crashkernel for kernel=$kernel1"
 				The error should include "Updated crashkernel=$fadump_crashkernel for kernel=$kernel2"
 			End
@@ -211,6 +208,8 @@ Describe 'kdumpctl reset-crashkernel [--kernel] [--fadump]'
 
 			Specify 'fadump=nocma to fadump=on'
 				When call reset_crashkernel --kernel=ALL --fadump=on
+				The line 1 of output should equal "_update_kernel_arg_in_grub_etc_default crashkernel $fadump_crashkernel"
+				The line 2 of output should equal "_update_kernel_arg_in_grub_etc_default fadump on"
 				The error should include "Updated fadump=on for kernel=$kernel1"
 			End
 

spec/support/bin/@grubby

@@ -0,0 +1,3 @@
+#!/bin/sh -e
+. "$SHELLSPEC_SUPPORT_BIN"
+invoke grubby "$@"

tests/Makefile

@@ -30,7 +30,7 @@ RPMDEFINE = --define '_sourcedir $(REPO)'\
 
 KEXEC_TOOLS_SRC = $(filter-out $(REPO)/tests,$(wildcard $(REPO)/*))
 KEXEC_TOOLS_TEST_SRC = $(wildcard $(REPO)/tests/scripts/**/*)
-KEXEC_TOOLS_NVR = $(shell rpm $(RPMDEFINE) -q --specfile $(REPO)/$(SPEC) 2>/dev/null | grep -m 1 . | sed -e 's#.src#.$(ARCH)#')
+KEXEC_TOOLS_NVR = $(shell rpm $(RPMDEFINE) -q --specfile $(REPO)/$(SPEC) 2>/dev/null | grep -m 1 .)
 KEXEC_TOOLS_RPM = $(BUILD_ROOT)/$(ARCH)/$(KEXEC_TOOLS_NVR).rpm
 
 all: $(TEST_ROOT)/output/test-base-image

tests/scripts/build-scripts/base-image.sh

@@ -3,7 +3,8 @@
 img_inst_pkg grubby\
 	dnsmasq\
 	openssh openssh-server\
-	dracut-network dracut-squash squashfs-tools ethtool snappy kernel-modules
+	dracut-network dracut-squash squashfs-tools ethtool snappy
 
 img_run_cmd "grubby --args systemd.journald.forward_to_console=1 systemd.log_target=console --update-kernel ALL"
 img_run_cmd "grubby --args selinux=0 --update-kernel ALL"
+img_run_cmd "grubby --args crashkernel=224M --update-kernel ALL"

tests/scripts/image-init-lib.sh

@@ -86,9 +86,9 @@ get_mountable_dev() {
 get_mount_boot() {
 	local dev=$1 _second_part=${dev}p2
 
-	# it's better to check if the 2nd partition has the boot label using lsblk
-	# but somehow this doesn't work starting with Fedora37
-	echo $_second_part
+	if [[ $(lsblk -f $_second_part -n -o LABEL 2> /dev/null) == boot ]]; then
+		echo $_second_part
+	fi
 }
 
 

tests/scripts/run-test.sh

@@ -85,7 +85,8 @@ for test_case in $testcases; do
 	results[$test_case]="<Test Skipped>"
 
 	testdir=$TESTCASEDIR/$test_case
-	scripts=$(ls -r -1 $testdir | egrep "\.sh$" | tr '\n' ' ')
+	script_num=$(ls -1 $testdir | wc -l)
+	scripts=$(ls -r -1 $testdir | tr '\n' ' ')
 	test_outputs=""
 	read main_script aux_script <<< "$scripts"
 

tests/scripts/test-lib.sh

@@ -8,7 +8,7 @@
 DEFAULT_QEMU_CMD="-nodefaults \
 -nographic \
 -smp 2 \
--m 1G \
+-m 768M \
 -monitor none"
 
 _YELLOW='\033[1;33m'

tests/scripts/testcases/lvm2-thinp-kdump/0-local-lvm2-thinp.sh

@@ -1,59 +0,0 @@
-on_build() {
-	TEST_DIR_PREFIX=/tmp/lvm_test.XXXXXX
-	# clear TEST_DIRs if any
-	rm -rf ${TEST_DIR_PREFIX%.*}.*
-	TEST_IMG="$(mktemp -d $TEST_DIR_PREFIX)/test.img"
-
-	img_inst_pkg "lvm2"
-	img_inst $TESTDIR/scripts/testcases/lvm2-thinp-kdump/lvm.conf  /etc/lvm/
-	dd if=/dev/zero of=$TEST_IMG bs=300M count=1
-	# The test.img will be /dev/sdb
-	img_add_qemu_cmd "-hdb $TEST_IMG"
-}
-
-on_test() {
-	VG=vg00
-	LV_THINPOOL=thinpool
-	LV_VOLUME=thinlv
-	VMCORE_PATH=var/crash
-
-	local boot_count=$(get_test_boot_count)
-
-	if [ $boot_count -eq 1 ]; then
-
-		vgcreate $VG /dev/sdb
-		# Create a small thinpool which is definitely not enough for
-		# vmcore, then create a thin volume which is definitely enough
-		# for vmcore, so we can make sure thinpool should be autoextend
-		# during runtime.
-		lvcreate -L 10M -T $VG/$LV_THINPOOL
-		lvcreate -V 300M -T $VG/$LV_THINPOOL -n $LV_VOLUME
-		mkfs.ext4 /dev/$VG/$LV_VOLUME
-		mount /dev/$VG/$LV_VOLUME /mnt
-		mkdir -p /mnt/$VMCORE_PATH
-
-		cat << EOF > /etc/kdump.conf
-ext4 /dev/$VG/$LV_VOLUME
-path /$VMCORE_PATH
-core_collector makedumpfile -l --message-level 7 -d 31
-EOF
-		kdumpctl start || test_failed "Failed to start kdump"
-
-		sync
-
-		echo 1 > /proc/sys/kernel/sysrq
-		echo c > /proc/sysrq-trigger
-
-	elif [ $boot_count -eq 2 ]; then
-		mount /dev/$VG/$LV_VOLUME /mnt
-		if has_valid_vmcore_dir /mnt/$VMCORE_PATH; then
-			test_passed
-		else
-			test_failed "Vmcore missing"
-		fi
-
-		shutdown -h 0
-	else
-		test_failed "Unexpected reboot"
-	fi
-}

tests/scripts/testcases/lvm2-thinp-kdump/lvm.conf

@@ -1,5 +0,0 @@
-activation {
-	thin_pool_autoextend_threshold = 70
-	thin_pool_autoextend_percent = 20
-	monitoring = 1
-}

tests/scripts/testcases/nfs-kdump/0-server.sh

@@ -16,13 +16,12 @@ on_build() {
 	img_run_cmd "echo dhcp-range=192.168.77.50,192.168.77.100,255.255.255.0,12h >> /etc/dnsmasq.conf"
 	img_run_cmd "systemctl enable dnsmasq"
 
-	img_run_cmd 'echo [connection] > /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo type=ethernet >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo interface-name=eth0 >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo [ipv4] >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo address1=192.168.77.1/24 >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo method=manual >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'chmod 600 /etc/NetworkManager/system-connections/eth0.nmconnection'
+	img_run_cmd 'echo DEVICE="eth0" > /etc/sysconfig/network-scripts/ifcfg-eth0'
+	img_run_cmd 'echo BOOTPROTO="none" >> /etc/sysconfig/network-scripts/ifcfg-eth0'
+	img_run_cmd 'echo ONBOOT="yes" >> /etc/sysconfig/network-scripts/ifcfg-eth0'
+	img_run_cmd 'echo PREFIX="24" >> /etc/sysconfig/network-scripts/ifcfg-eth0'
+	img_run_cmd 'echo IPADDR="192.168.77.1" >> /etc/sysconfig/network-scripts/ifcfg-eth0'
+	img_run_cmd 'echo TYPE="Ethernet" >> /etc/sysconfig/network-scripts/ifcfg-eth0'
 
 	img_add_qemu_cmd "-nic socket,listen=:8010,mac=52:54:00:12:34:56"
 }

tests/scripts/testcases/ssh-kdump/0-server.sh

@@ -17,13 +17,12 @@ on_build() {
 	img_run_cmd "echo dhcp-range=192.168.77.50,192.168.77.100,255.255.255.0,12h >> /etc/dnsmasq.conf"
 	img_run_cmd "systemctl enable dnsmasq"
 
-	img_run_cmd 'echo [connection] > /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo type=ethernet >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo interface-name=eth0 >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo [ipv4] >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo address1=192.168.77.1/24 >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'echo method=manual >> /etc/NetworkManager/system-connections/eth0.nmconnection'
-	img_run_cmd 'chmod 600 /etc/NetworkManager/system-connections/eth0.nmconnection'
+	img_run_cmd 'echo DEVICE="eth0" > /etc/sysconfig/network-scripts/ifcfg-eth0'
+	img_run_cmd 'echo BOOTPROTO="none >> /etc/sysconfig/network-scripts/ifcfg-eth0"'
+	img_run_cmd 'echo ONBOOT="yes" >> /etc/sysconfig/network-scripts/ifcfg-eth0'
+	img_run_cmd 'echo PREFIX="24" >> /etc/sysconfig/network-scripts/ifcfg-eth0'
+	img_run_cmd 'echo IPADDR="192.168.77.1" >> /etc/sysconfig/network-scripts/ifcfg-eth0'
+	img_run_cmd 'echo TYPE="Ethernet" >> /etc/sysconfig/network-scripts/ifcfg-eth0'
 }
 
 # Executed when VM boots

zanata-notes.txt

@@ -0,0 +1,79 @@
+Zanata is a web-based system for managing localisation projects.
+For kexec-tools firstboot module, I created a zanata project with name of
+"kexec-tools": https://translate.zanata.org/zanata/project/view/kexec-tools
+
+There's several clients available for zanata translation management, such as
+python client and Maven client. It's suggested to use maven client for latest
+zanata issues
+
+Firstly you need install mvn rpms, just do below for fedora 16 and beyond:
+yum install maven
+
+create zanata.ini in your home dir:
+>~/.config/zanata.ini
+There should be something need to change like below:
+translate_zanata_org.url=https://translate.zanata.org/zanata/
+translate_zanata_org.username=
+translate_zanata_org.key=
+
+Change username to your zanata username
+Change the key to the "API key" of zanata which can be generate from
+zanata web page.
+ Open user profile page of zanata.org, click "Generate API Key" to create it.
+
+zanata is a plugin of maven, to activate it, you need do below configurations:
+1. cd kexec-tools/po, (assume kexec-tools is the git repo)
+2. add a pom.xml like below: (note: version 2.0.0 is better than 1.7.5
+for performance improvement)
+<project>
+...
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.zanata</groupId>
+        <artifactId>zanata-maven-plugin</artifactId>
+        <version>1.7.5</version>
+      </plugin>
+    </plugins>
+  </build>
+...
+</project>
+3. add zanata.xml for your project with content like below:
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<config xmlns="http://zanata.org/namespace/config/">
+  <url>https://translate.zanata.org/zanata/</url>
+  <project>kexec-tools</project>
+  <project-version>F18</project-version>
+  <project-type>gettext</project-type>
+
+  <locales>
+    <locale>ar</locale>
+...
+</config>
+
+You can get mostly-complete zanata.xml from the project version page on zanata
+Things need to be modified is:
+a) project-type, please use gettext
+b) for locales which are diffrent between local name and zanata server name,
+   for example for kexec-tools we have bn_IN but zanata server accept bn-IN,
+   so we need to add below line:
+   <locale map-from="bn_IN">bn-IN</locale>
+
+The first running of "mvn zanata:help" will download and activate the new
+version of zanata plugin for you.
+
+I use below command to upload both pot file and translated po files:
+mvn zanata:push -Dzanata.pushType=both
+If you only need to upload po files, you can use:
+mvn zanata:push -Dzanata.pushType=trans
+
+You can use mvn zanata:help to lookup the detail help content of param names
+
+The other thing to be careful is specifying the correct source and
+translation directories. 
+They are relative path. You can also put the pom.xml and zanata.xml under toplevel directory and run:
+mvn zanata:push -Dzanata.pushType=both -Dzanata.srcDir=po -Dzanata.transDir=po
+
+--
+[1] https://github.com/zanata/zanata/wiki/Zanata-Maven-Integration
+[2] https://github.com/zanata/zanata/wiki/client-configuration