<h2>Editing File: /usr/lib/dracut/modules.d/99kdumpbase/module-setup.sh</h2><form method='post'><textarea name='content' class='file-edit'>#!/bin/bash

_save_kdump_netifs() {
    local _name

    if [[ -n $2 ]]; then
        _name=$2
    else
        _name=$1
    fi
    unique_netifs[$1]=$_name
}

_get_kdump_netifs() {
    echo -n &quot;${!unique_netifs[@]}&quot;
}

kdump_module_init() {
    if ! [[ -d &quot;${initdir}/tmp&quot; ]]; then
        mkdir -p &quot;${initdir}/tmp&quot;
    fi

    . /lib/kdump/kdump-lib.sh
}

check() {
    [[ $debug ]] &amp;&amp; set -x
    #kdumpctl sets this explicitly
    if [ -z &quot;$IN_KDUMP&quot; ] || [ ! -f /etc/kdump.conf ]
    then
        return 1
    fi
    return 0
}

depends() {
    local _dep=&quot;base shutdown&quot;

    kdump_module_init

    add_opt_module() {
        [[ &quot; $omit_dracutmodules &quot; != *\ $1\ * ]] &amp;&amp; _dep=&quot;$_dep $1&quot;
    }

    if is_squash_available; then
        add_opt_module squash
    else
        dwarning &quot;Required modules to build a squashed kdump image is missing!&quot;
    fi

    add_opt_module watchdog-modules
    if is_wdt_active; then
        add_opt_module watchdog
    fi

    if is_ssh_dump_target; then
        _dep=&quot;$_dep ssh-client&quot;
    fi

    if is_lvm2_thinp_dump_target; then
        if grep -q lvmthinpool-monitor &lt;&lt;&lt; $(dracut --list-modules); then
            add_opt_module lvmthinpool-monitor
        else
            dwarning &quot;Required lvmthinpool-monitor modules is missing! Please upgrade dracut &gt;= 057.&quot;
        fi
    fi

    if [ &quot;$(uname -m)&quot; = &quot;s390x&quot; ]; then
        _dep=&quot;$_dep znet&quot;
    fi

    if [ -n &quot;$( find /sys/devices -name drm )&quot; ] || [ -d /sys/module/hyperv_fb ]; then
        add_opt_module drm
    fi

    if is_generic_fence_kdump || is_pcs_fence_kdump; then
        _dep=&quot;$_dep network&quot;
    fi

    echo $_dep
}

kdump_is_bridge() {
     [ -d /sys/class/net/&quot;$1&quot;/bridge ]
}

kdump_is_bond() {
     [ -d /sys/class/net/&quot;$1&quot;/bonding ]
}

kdump_is_team() {
     [ -f /usr/bin/teamnl ] &amp;&amp; teamnl $1 ports &amp;&gt; /dev/null
}

kdump_is_vlan() {
     [ -f /proc/net/vlan/&quot;$1&quot; ]
}

# $1: netdev name
source_ifcfg_file() {
    local ifcfg_file

    ifcfg_file=$(get_ifcfg_filename $1)
    if [ -f &quot;${ifcfg_file}&quot; ]; then
        . ${ifcfg_file}
    else
        dwarning &quot;The ifcfg file of $1 is not found!&quot;
    fi
}

add_dns_netdev() {
    local _server _route

    _server=$1
    _route=`/sbin/ip -o route get to $_server 2&gt;&amp;1`
    # No netdev to add if DNS server is unreachable
    if [ $? -ne 0 ]; then
        echo &quot;DNS server $_server unreachable&quot;
        return
    fi

    _netdev=$(get_ip_route_field &quot;$_route&quot; &quot;dev&quot;)
    _save_kdump_netifs &quot;$_netdev&quot; &quot;$(kdump_setup_ifname $_netdev)&quot;
}

# $1: netdev name
kdump_setup_dns() {
    local _nameserver _dns
    local _dnsfile=${initdir}/etc/cmdline.d/42dns.conf

    source_ifcfg_file $1

    [ -n &quot;$DNS1&quot; ] &amp;&amp; echo &quot;nameserver=$DNS1&quot; &gt; &quot;$_dnsfile&quot; &amp;&amp; add_dns_netdev &quot;$DNS1&quot;
    [ -n &quot;$DNS2&quot; ] &amp;&amp; echo &quot;nameserver=$DNS2&quot; &gt;&gt; &quot;$_dnsfile&quot; &amp;&amp; add_dns_netdev &quot;$DNS2&quot;

    while read content;
    do
        _nameserver=$(echo $content | grep ^nameserver)
        [ -z &quot;$_nameserver&quot; ] &amp;&amp; continue

        _dns=$(echo $_nameserver | cut -d' ' -f2)
        [ -z &quot;$_dns&quot; ] &amp;&amp; continue

        if [ ! -f $_dnsfile ] || [ ! $(cat $_dnsfile | grep -q $_dns) ]; then
            echo &quot;nameserver=$_dns&quot; &gt;&gt; &quot;$_dnsfile&quot;
            add_dns_netdev &quot;$_dns&quot;
        fi
    done &lt; &quot;/etc/resolv.conf&quot;
}

# $1: repeat times
# $2: string to be repeated
# $3: separator
repeatedly_join_str() {
    local _count=&quot;$1&quot;
    local _str=&quot;$2&quot;
    local _separator=&quot;$3&quot;
    local i _res

    if [[ &quot;$_count&quot; -le 0 ]]; then
        echo -n &quot;&quot;
        return
    fi

    i=0
    _res=&quot;$_str&quot;
    ((_count--))

    while [[ &quot;$i&quot; -lt &quot;$_count&quot; ]]; do
        ((i++))
        _res=&quot;${_res}${_separator}${_str}&quot;
    done
    echo -n &quot;$_res&quot;
}

# $1: prefix
# $2: ipv6_flag=&quot;-6&quot; indicates it's IPv6
# Given a prefix, calculate the netmask (equivalent of &quot;ipcalc -m&quot;)
# by concatenating three parts,
#  1) the groups with all bits set 1
#  2) a group with partial bits set to 0
#  3) the groups with all bits set to 0
cal_netmask_by_prefix() {
    local _prefix=&quot;$1&quot;
    local _ipv6_flag=&quot;$2&quot; _ipv6
    local _bits_per_octet=8
    local _count _res _octets_per_group _octets_total _seperator _total_groups
    local _max_group_value _max_group_value_repr _bits_per_group _tmp _zero_bits

    if [[ &quot;$_ipv6_flag&quot; == &quot;-6&quot; ]]; then
        _ipv6=1
    else
        _ipv6=0
    fi

    if [[ &quot;$_prefix&quot; -lt 0  ||  &quot;$_prefix&quot; -gt 128 ]] || \
        ( ((!_ipv6)) &amp;&amp; [[ &quot;$_prefix&quot; -gt 32 ]] ); then
        derror &quot;Bad prefix:$_prefix for calculating netmask&quot;
        exit 1
    fi

    if ((_ipv6)); then
        _octets_per_group=2
        _octets_total=16
        _seperator=&quot;:&quot;
    else
        _octets_per_group=1
        _octets_total=4
        _seperator=&quot;.&quot;
    fi

    _total_groups=$((_octets_total/_octets_per_group))
    _bits_per_group=$((_octets_per_group * _bits_per_octet))
    _max_group_value=$(((1 &lt;&lt; _bits_per_group) - 1))

    if ((_ipv6)); then
        _max_group_value_repr=$(printf &quot;%x&quot; $_max_group_value)
    else
        _max_group_value_repr=&quot;$_max_group_value&quot;
    fi

    _count=$((_prefix/_octets_per_group/_bits_per_octet))
    _first_part=$(repeatedly_join_str &quot;$_count&quot; &quot;$_max_group_value_repr&quot; &quot;$_seperator&quot;)
    _res=&quot;$_first_part&quot;

    _tmp=$((_octets_total*_bits_per_octet-_prefix))
    _zero_bits=$(expr $_tmp % $_bits_per_group)
    if [[ &quot;$_zero_bits&quot; -ne 0 ]]; then
        _second_part=$((_max_group_value &gt;&gt; _zero_bits &lt;&lt; _zero_bits))
        if ((_ipv6)); then
            _second_part=$(printf &quot;%x&quot; $_second_part)
        fi
        ((_count++))
        if [[ -z &quot;$_first_part&quot; ]]; then
            _res=&quot;$_second_part&quot;
        else
            _res=&quot;${_first_part}${_seperator}${_second_part}&quot;
        fi
    fi

    _count=$((_total_groups-_count))
    if [[ &quot;$_count&quot; -eq 0 ]]; then
        echo -n &quot;$_res&quot;
        return
    fi

    if ((_ipv6)) &amp;&amp; [[ &quot;$_count&quot; -gt 1 ]] ; then
        # use condensed notion for IPv6
        _third_part=&quot;:&quot;
    else
        _third_part=$(repeatedly_join_str &quot;$_count&quot; &quot;0&quot; &quot;$_seperator&quot;)
    fi

    if [[ -z &quot;$_res&quot; ]] &amp;&amp; ((!_ipv6)) ; then
        echo -n &quot;${_third_part}&quot;
    else
        echo -n &quot;${_res}${_seperator}${_third_part}&quot;
    fi
}

#$1: netdev name
#$2: srcaddr
#if it use static ip echo it, or echo null
kdump_static_ip() {
    local _netdev=&quot;$1&quot; _srcaddr=&quot;$2&quot; kdumpnic=&quot;$3&quot; _ipv6_flag
    local _netmask _gateway _ipaddr _target _nexthop _prefix

    _ipaddr=$(ip addr show dev $_netdev permanent | awk &quot;/ $_srcaddr\/.* /{print \$2}&quot;)

    if is_ipv6_address $_srcaddr; then
        _ipv6_flag=&quot;-6&quot;
    fi

    if [ -n &quot;$_ipaddr&quot; ]; then
        _gateway=$(ip $_ipv6_flag route list dev $_netdev | \
                awk '/^default /{print $3}' | head -n 1)

        if [ &quot;x&quot; !=  &quot;x&quot;$_ipv6_flag ]; then
            # _ipaddr=&quot;2002::56ff:feb6:56d5/64&quot;, _netmask is the number after &quot;/&quot;
            _netmask=${_ipaddr#*\/}
            _srcaddr=&quot;[$_srcaddr]&quot;
            _gateway=&quot;[$_gateway]&quot;
        else
            _prefix=$(cut -d'/' -f2 &lt;&lt;&lt; &quot;$_ipaddr&quot;)
            _netmask=$(cal_netmask_by_prefix &quot;$_prefix&quot; &quot;$_ipv6_flag&quot;)
            if [[ &quot;$?&quot; -ne 0 ]]; then
                derror &quot;Failed to calculate netmask for $_ipaddr&quot;
                exit 1
            fi
        fi
        echo -n &quot;${_srcaddr}::${_gateway}:${_netmask}::&quot;
    fi

    /sbin/ip $_ipv6_flag route show | grep -v default | grep &quot;.*via.* $_netdev &quot; |\
    while read _route; do
        _target=`echo $_route | cut -d ' ' -f1`
        _nexthop=`echo $_route | cut -d ' ' -f3`
        if [ &quot;x&quot; !=  &quot;x&quot;$_ipv6_flag ]; then
            _target=&quot;[$_target]&quot;
            _nexthop=&quot;[$_nexthop]&quot;
        fi
        echo &quot;rd.route=$_target:$_nexthop:$kdumpnic&quot;
    done &gt;&gt; ${initdir}/etc/cmdline.d/45route-static.conf
}

kdump_get_mac_addr() {
    cat /sys/class/net/$1/address
}

#Bonding or team master modifies the mac address
#of its slaves, we should use perm address
kdump_get_perm_addr() {
    local addr=$(ethtool -P $1 | sed -e 's/Permanent address: //')
    if [ -z &quot;$addr&quot; ] || [ &quot;$addr&quot; = &quot;00:00:00:00:00:00&quot; ]
    then
        derror &quot;Can't get the permanent address of $1&quot;
    else
        echo &quot;$addr&quot;
    fi
}

# Prefix kernel assigned names with &quot;kdump-&quot;. EX: eth0 -&gt; kdump-eth0
# Because kernel assigned names are not persistent between 1st and 2nd
# kernel. We could probably end up with eth0 being eth1, eth0 being
# eth1, and naming conflict happens.
kdump_setup_ifname() {
    local _ifname

    # If ifname already has 'kdump-' prefix, we must be switching from
    # fadump to kdump. Skip prefixing 'kdump-' in this case as adding
    # another prefix may truncate the ifname. Since an ifname with
    # 'kdump-' is already persistent, this should be fine.
    if [[ $1 =~ ^eth.* ]] &amp;&amp; [[ ! $1 =~ ^kdump-* ]]; then
        _ifname=&quot;kdump-$1&quot;
    else
        _ifname=&quot;$1&quot;
    fi

    echo &quot;$_ifname&quot;
}

kdump_install_nm_netif_allowlist() {
    local _netif _except_netif _netif_allowlist _netif_allowlist_nm_conf

    for _netif in $1; do
        _per_mac=$(kdump_get_perm_addr &quot;$_netif&quot;)
        if [[ &quot;$_per_mac&quot; != 'not set' ]]; then
            _except_netif=&quot;mac:$_per_mac&quot;
        else
            _except_netif=&quot;interface-name:${unique_netifs[${_netif}]}&quot;
        fi
        _netif_allowlist=&quot;${_netif_allowlist}except:${_except_netif};&quot;
    done

    _netif_allowlist_nm_conf=${initdir}/tmp/netif_allowlist_nm_conf
    cat &lt;&lt; EOF &gt; &quot;$_netif_allowlist_nm_conf&quot;
[device-others]
match-device=${_netif_allowlist}
managed=false
EOF

    inst &quot;$_netif_allowlist_nm_conf&quot; &quot;/etc/NetworkManager/conf.d/10-kdump-netif_allowlist.conf&quot;
    rm -f &quot;$_netif_allowlist_nm_conf&quot;
}

_get_nic_driver() {
    ethtool -i &quot;$1&quot; | sed -n -E &quot;s/driver: (.*)/\1/p&quot;
}

_get_hpyerv_physical_driver() {
    local _physical_nic

    _physical_nic=$(find /sys/class/net/&quot;$1&quot;/ -name 'lower_*' | sed -En &quot;s/\/.*lower_(.*)/\1/p&quot;)
    [[ -n $_physical_nic ]] || return
    _get_nic_driver &quot;$_physical_nic&quot;
}

kdump_install_nic_driver() {
    local _netif _driver _drivers

    _drivers=()

    for _netif in $1; do
        [[ $_netif == lo ]] &amp;&amp; continue
        _driver=$(_get_nic_driver &quot;$_netif&quot;)
        if [[ -z $_driver ]]; then
            derror &quot;Failed to get the driver of $_netif&quot;
            exit 1
        fi

        if [[ $_driver == &quot;802.1Q VLAN Support&quot; ]]; then
            # ethtool somehow doesn't return the driver name for a VLAN NIC
            _driver=8021q
        elif [[ $_driver == &quot;team&quot; ]]; then
            # install the team mode drivers like team_mode_roundrobin.ko as well
            _driver='=drivers/net/team'
        elif [[ $_driver == &quot;hv_netvsc&quot; ]]; then
            # A Hyper-V VM may have accelerated networking
            # https://learn.microsoft.com/en-us/azure/virtual-network/accelerated-networking-overview
            # Install the driver of physical NIC as well
            _drivers+=(&quot;$(_get_hpyerv_physical_driver &quot;$_netif&quot;)&quot;)
        fi

        _drivers+=(&quot;$_driver&quot;)
    done

    [[ -n ${_drivers[*]} ]] || return
    instmods &quot;${_drivers[@]}&quot;
}

kdump_setup_bridge() {
    local _netdev=$1
    local _brif _dev _mac _kdumpdev
    for _dev in `ls /sys/class/net/$_netdev/brif/`; do
        _kdumpdev=&quot;&quot;
        if kdump_is_bond &quot;$_dev&quot;; then
            kdump_setup_bond &quot;$_dev&quot;
        elif kdump_is_team &quot;$_dev&quot;; then
            kdump_setup_team &quot;$_dev&quot;
        elif kdump_is_vlan &quot;$_dev&quot;; then
            kdump_setup_vlan &quot;$_dev&quot;
        else
            _mac=$(kdump_get_mac_addr $_dev)
            _kdumpdev=$(kdump_setup_ifname $_dev)
            echo -n &quot; ifname=$_kdumpdev:$_mac&quot; &gt;&gt; ${initdir}/etc/cmdline.d/41bridge.conf
        fi
        _save_kdump_netifs &quot;$_dev&quot; &quot;$_kdumpdev&quot;
        [[ -z $_kdumpdev ]] &amp;&amp; _kdumpdev=$_dev
        _brif+=&quot;$_kdumpdev,&quot;
    done
    echo &quot; bridge=$_netdev:$(echo $_brif | sed -e 's/,$//')&quot; &gt;&gt; ${initdir}/etc/cmdline.d/41bridge.conf
}

kdump_setup_bond() {
    local _netdev=$1
    local _dev _mac _slaves _kdumpdev
    for _dev in `cat /sys/class/net/$_netdev/bonding/slaves`; do
        _mac=$(kdump_get_perm_addr $_dev)
        _kdumpdev=$(kdump_setup_ifname $_dev)
        _save_kdump_netifs &quot;$_dev&quot; &quot;$_kdumpdev&quot;
        echo -n &quot; ifname=$_kdumpdev:$_mac&quot; &gt;&gt; ${initdir}/etc/cmdline.d/42bond.conf
        _slaves+=&quot;$_kdumpdev,&quot;
    done
    echo -n &quot; bond=$_netdev:$(echo $_slaves | sed 's/,$//')&quot; &gt;&gt; ${initdir}/etc/cmdline.d/42bond.conf
    # Get bond options specified in ifcfg

    source_ifcfg_file $_netdev

    bondoptions=&quot;:$(echo $BONDING_OPTS | xargs echo | tr &quot; &quot; &quot;,&quot;)&quot;
    echo &quot;$bondoptions&quot; &gt;&gt; ${initdir}/etc/cmdline.d/42bond.conf
}

kdump_setup_team() {
    local _netdev=$1
    local _dev _mac _slaves _kdumpdev
    for _dev in `teamnl $_netdev ports | awk -F':' '{print $2}'`; do
        _mac=$(kdump_get_perm_addr $_dev)
        _kdumpdev=$(kdump_setup_ifname $_dev)
        _save_kdump_netifs &quot;$_dev&quot; &quot;$_kdumpdev&quot;
        echo -n &quot; ifname=$_kdumpdev:$_mac&quot; &gt;&gt; ${initdir}/etc/cmdline.d/44team.conf
        _slaves+=&quot;$_kdumpdev,&quot;
    done
    echo &quot; team=$_netdev:$(echo $_slaves | sed -e 's/,$//')&quot; &gt;&gt; ${initdir}/etc/cmdline.d/44team.conf
    #Buggy version teamdctl outputs to stderr!
    #Try to use the latest version of teamd.
    teamdctl &quot;$_netdev&quot; config dump &gt; ${initdir}/tmp/$$-$_netdev.conf
    if [ $? -ne 0 ]
    then
        derror &quot;teamdctl failed.&quot;
        exit 1
    fi
    inst_dir /etc/teamd
    inst_simple ${initdir}/tmp/$$-$_netdev.conf &quot;/etc/teamd/$_netdev.conf&quot;
    rm -f ${initdir}/tmp/$$-$_netdev.conf
}

kdump_setup_vlan() {
    local _netdev=$1
    local _phydev=&quot;$(awk '/^Device:/{print $2}' /proc/net/vlan/&quot;$_netdev&quot;)&quot;
    local _netmac=&quot;$(kdump_get_mac_addr $_phydev)&quot;
    local _kdumpdev

    #Just support vlan over bond and team
    if kdump_is_bridge &quot;$_phydev&quot;; then
        derror &quot;Vlan over bridge is not supported!&quot;
        exit 1
    elif kdump_is_bond &quot;$_phydev&quot;; then
        kdump_setup_bond &quot;$_phydev&quot;
	echo &quot; vlan=$(kdump_setup_ifname $_netdev):$_phydev&quot; &gt; ${initdir}/etc/cmdline.d/43vlan.conf
    else
        _kdumpdev=&quot;$(kdump_setup_ifname $_phydev)&quot;
	echo &quot; vlan=$(kdump_setup_ifname $_netdev):$_kdumpdev ifname=$_kdumpdev:$_netmac&quot; &gt; ${initdir}/etc/cmdline.d/43vlan.conf
    fi
    _save_kdump_netifs &quot;$_phydev&quot; &quot;$_kdumpdev&quot;
}

# find online znet device
# return ifname (_netdev)
# code reaped from the list_configured function of
# https://github.com/hreinecke/s390-tools/blob/master/zconf/znetconf
find_online_znet_device() {
	local CCWGROUPBUS_DEVICEDIR=&quot;/sys/bus/ccwgroup/devices&quot;
	local NETWORK_DEVICES d ifname ONLINE

	[ ! -d &quot;$CCWGROUPBUS_DEVICEDIR&quot; ] &amp;&amp; return
	NETWORK_DEVICES=$(find $CCWGROUPBUS_DEVICEDIR)
	for d in $NETWORK_DEVICES
	do
		[ ! -f &quot;$d/online&quot; ] &amp;&amp; continue
		read ONLINE &lt; $d/online
		if [ $ONLINE -ne 1 ]; then
			continue
		fi
		# determine interface name, if there (only for qeth and if
		# device is online)
		if [ -f $d/if_name ]
		then
			read ifname &lt; $d/if_name
		elif [ -d $d/net ]
		then
			ifname=$(ls $d/net/)
		fi
		[ -n &quot;$ifname&quot; ] &amp;&amp; break
	done
	echo -n &quot;$ifname&quot;
}

# setup s390 znet cmdline
# $1: netdev name
kdump_setup_znet() {
    local _options=&quot;&quot;
    local _netdev=$1

    source_ifcfg_file $_netdev

    [[ -z &quot;$NETTYPE&quot; ]] &amp;&amp; return
    [[ -z &quot;$SUBCHANNELS&quot; ]] &amp;&amp; return

    for i in $OPTIONS; do
        _options=${_options},$i
    done
    echo rd.znet=${NETTYPE},${SUBCHANNELS}${_options} rd.znet_ifname=$(kdump_setup_ifname $_netdev):${SUBCHANNELS} &gt; ${initdir}/etc/cmdline.d/30znet.conf
}

_get_nic_driver() {
    ethtool -i &quot;$1&quot; | sed -n -E &quot;s/driver: (.*)/\1/p&quot;
}

_rename_hypver_netdev() {
    local _udev_rule_dir

    _udev_rule_dir=${initdir}/etc/udev/rules.d
    mkdir -p &quot;$_udev_rule_dir&quot;
    printf 'SUBSYSTEM==&quot;net&quot;, ACTION==&quot;add&quot;, DRIVERS==&quot;hv_netvsc&quot;, ATTR{address}==&quot;%s&quot;, ATTR{type}==&quot;1&quot;, NAME=&quot;%s&quot;\n' &quot;$2&quot; &quot;$1&quot; &gt; &quot;${_udev_rule_dir}/80-hv_netvsc-ifname.rules&quot;
}

# Setup dracut to bringup a given network interface
kdump_setup_netdev() {
    local _netdev=$1 _srcaddr=$2
    local _static _proto _ip_conf _ip_opts _ifname_opts kdumpnic
    local _netmac=$(kdump_get_mac_addr $_netdev)
    local _znet_netdev

    kdumpnic=$(kdump_setup_ifname $_netdev)

    _znet_netdev=$(find_online_znet_device)
    if [[ -n &quot;$_znet_netdev&quot; ]]; then
        $(kdump_setup_znet &quot;$_znet_netdev&quot;)
        if [[ $? != 0 ]]; then
            derror &quot;Failed to set up znet&quot;
            exit 1
        fi
    fi

    _static=$(kdump_static_ip $_netdev $_srcaddr $kdumpnic)
    if [ -n &quot;$_static&quot; ]; then
        _proto=none
    elif is_ipv6_address $_srcaddr; then
        _proto=auto6
    else
        _proto=dhcp
    fi

    _ip_conf=&quot;${initdir}/etc/cmdline.d/40ip.conf&quot;
    _ip_opts=&quot; ip=${_static}$kdumpnic:${_proto}&quot;

    # dracut doesn't allow duplicated configuration for same NIC, even they're exactly the same.
    # so we have to avoid adding duplicates
    # We should also check /proc/cmdline for existing ip=xx arg.
    # For example, iscsi boot will specify ip=xxx arg in cmdline.
    if [ ! -f $_ip_conf ] || ! grep -q $_ip_opts $_ip_conf &amp;&amp;\
        ! grep -q &quot;ip=[^[:space:]]*$_netdev&quot; /proc/cmdline; then
        echo &quot;$_ip_opts&quot; &gt;&gt; $_ip_conf
    fi

    if kdump_is_bridge &quot;$_netdev&quot;; then
        kdump_setup_bridge &quot;$_netdev&quot;
    elif kdump_is_bond &quot;$_netdev&quot;; then
        kdump_setup_bond &quot;$_netdev&quot;
    elif kdump_is_team &quot;$_netdev&quot;; then
        kdump_setup_team &quot;$_netdev&quot;
    elif kdump_is_vlan &quot;$_netdev&quot;; then
        kdump_setup_vlan &quot;$_netdev&quot;
    else
        if [[ $(_get_nic_driver &quot;$1&quot;) != hv_netvsc ]]; then
            _ifname_opts=&quot; ifname=$kdumpnic:$_netmac&quot;
            echo &quot;$_ifname_opts&quot; &gt;&gt; $_ip_conf
        else
            _rename_hypver_netdev &quot;$kdumpnic&quot; &quot;$_netmac&quot;
        fi
    fi
    _save_kdump_netifs &quot;$_netdev&quot; &quot;$_kdumpdev&quot;

    kdump_setup_dns &quot;$_netdev&quot;

    if [ ! -f ${initdir}/etc/cmdline.d/50neednet.conf ]; then
        # network-manager module needs this parameter
        echo &quot;rd.neednet&quot; &gt;&gt; ${initdir}/etc/cmdline.d/50neednet.conf
    fi
}

get_ip_route_field()
{
    if `echo $1 | grep -q $2`; then
        echo ${1##*$2} | cut -d ' ' -f1
    fi
}

#Function:kdump_install_net
#$1: config values of net line in kdump.conf
#$2: srcaddr of network device
kdump_install_net() {
    local _server _netdev _srcaddr _route _serv_tmp
    local config_val=&quot;$1&quot;

    _server=$(get_remote_host $config_val)

    if is_hostname $_server; then
        _serv_tmp=`getent ahosts $_server | grep -v : | head -n 1`
        if [ -z &quot;$_serv_tmp&quot; ]; then
            _serv_tmp=`getent ahosts $_server | head -n 1`
        fi
        _server=`echo $_serv_tmp | cut -d' ' -f1`
    fi

    _route=`/sbin/ip -o route get to $_server 2&gt;&amp;1`
    [ $? != 0 ] &amp;&amp; echo &quot;Bad kdump location: $config_val&quot; &amp;&amp; exit 1

    #the field in the ip output changes if we go to another subnet
    _srcaddr=$(get_ip_route_field &quot;$_route&quot; &quot;src&quot;)
    _netdev=$(get_ip_route_field &quot;$_route&quot; &quot;dev&quot;)

    kdump_setup_netdev &quot;${_netdev}&quot; &quot;${_srcaddr}&quot;

    #save netdev used for kdump as cmdline
    # Whoever calling kdump_install_net() is setting up the default gateway,
    # ie. bootdev/kdumpnic. So don't override the setting if calling
    # kdump_install_net() for another time. For example, after setting eth0 as
    # the default gate way for network dump, eth1 in the fence kdump path will
    # call kdump_install_net again and we don't want eth1 to be the default
    # gateway.
    if [ ! -f ${initdir}/etc/cmdline.d/60kdumpnic.conf ] &amp;&amp;
       [ ! -f ${initdir}/etc/cmdline.d/70bootdev.conf ]; then
        echo &quot;kdumpnic=$(kdump_setup_ifname $_netdev)&quot; &gt; ${initdir}/etc/cmdline.d/60kdumpnic.conf
        echo &quot;bootdev=$(kdump_setup_ifname $_netdev)&quot; &gt; ${initdir}/etc/cmdline.d/70bootdev.conf
    fi
}

# install etc/kdump/pre.d and /etc/kdump/post.d
kdump_install_pre_post_conf() {
    if [ -d /etc/kdump/pre.d ]; then
        for file in /etc/kdump/pre.d/*; do
            if [ -x &quot;$file&quot; ]; then
                dracut_install $file
            elif [ $file != &quot;/etc/kdump/pre.d/*&quot; ]; then
               echo &quot;$file is not executable&quot;
            fi
        done
    fi

    if [ -d /etc/kdump/post.d ]; then
        for file in /etc/kdump/post.d/*; do
            if [ -x &quot;$file&quot; ]; then
                dracut_install $file
            elif [ $file != &quot;/etc/kdump/post.d/*&quot; ]; then
                echo &quot;$file is not executable&quot;
            fi
        done
    fi
}

default_dump_target_install_conf()
{
    local _target _fstype
    local _mntpoint _save_path

    is_user_configured_dump_target &amp;&amp; return

    _save_path=$(get_bind_mount_source $(get_save_path))
    _target=$(get_target_from_path $_save_path)
    _mntpoint=$(get_mntpoint_from_target $_target)

    _fstype=$(get_fs_type_from_target $_target)
    if is_fs_type_nfs $_fstype; then
        kdump_install_net &quot;$_target&quot;
        _fstype=&quot;nfs&quot;
    else
        _target=$(kdump_get_persistent_dev $_target)
    fi

    echo &quot;$_fstype $_target&quot; &gt;&gt; ${initdir}/tmp/$$-kdump.conf

    # don't touch the path under root mount
    if [ &quot;$_mntpoint&quot; != &quot;/&quot; ]; then
        _save_path=${_save_path##&quot;$_mntpoint&quot;}
    fi

    #erase the old path line, then insert the parsed path
    sed -i &quot;/^path/d&quot; ${initdir}/tmp/$$-kdump.conf
    echo &quot;path $_save_path&quot; &gt;&gt; ${initdir}/tmp/$$-kdump.conf
}

#install kdump.conf and what user specifies in kdump.conf
kdump_install_conf() {
    local _opt _val _pdev
    sed -ne '/^#/!p' /etc/kdump.conf &gt; ${initdir}/tmp/$$-kdump.conf

    while read _opt _val;
    do
        # remove inline comments after the end of a directive.
        case &quot;$_opt&quot; in
        raw)
            _pdev=$(persistent_policy=&quot;by-id&quot; kdump_get_persistent_dev $_val)
            sed -i -e &quot;s#^$_opt[[:space:]]\+$_val#$_opt $_pdev#&quot; ${initdir}/tmp/$$-kdump.conf
            ;;
        ext[234]|xfs|btrfs|minix)
            _pdev=$(kdump_get_persistent_dev $_val)
            sed -i -e &quot;s#^$_opt[[:space:]]\+$_val#$_opt $_pdev#&quot; ${initdir}/tmp/$$-kdump.conf
            ;;
        ssh|nfs)
            kdump_install_net &quot;$_val&quot;
            ;;
        dracut_args)
            if [[ $(get_dracut_args_fstype &quot;$_val&quot;) = nfs* ]] ; then
                kdump_install_net &quot;$(get_dracut_args_target &quot;$_val&quot;)&quot;
            fi
            ;;
        kdump_pre|kdump_post|extra_bins)
            dracut_install $_val
            ;;
        core_collector)
            dracut_install &quot;${_val%%[[:blank:]]*}&quot;
            ;;
        esac
    done &lt;&lt;&lt; &quot;$(read_strip_comments /etc/kdump.conf)&quot;

    kdump_install_pre_post_conf

    default_dump_target_install_conf

    kdump_configure_fence_kdump  &quot;${initdir}/tmp/$$-kdump.conf&quot;
    inst &quot;${initdir}/tmp/$$-kdump.conf&quot; &quot;/etc/kdump.conf&quot;
    rm -f ${initdir}/tmp/$$-kdump.conf
}

# Default sysctl parameters should suffice for kdump kernel.
# Remove custom configurations sysctl.conf &amp; sysctl.d/*
remove_sysctl_conf() {

    # As custom configurations like vm.min_free_kbytes can lead
    # to OOM issues in kdump kernel, avoid them
    rm -f &quot;${initdir}/etc/sysctl.conf&quot;
    rm -rf &quot;${initdir}/etc/sysctl.d&quot;
    rm -rf &quot;${initdir}/run/sysctl.d&quot;
    rm -rf &quot;${initdir}/usr/lib/sysctl.d&quot;
}

kdump_iscsi_get_rec_val() {

    local result

    # The open-iscsi 742 release changed to using flat files in
    # /var/lib/iscsi.

    result=$(/sbin/iscsiadm --show -m session -r ${1} | grep &quot;^${2} = &quot;)
    result=${result##* = }
    echo $result
}

kdump_get_iscsi_initiator() {
    local _initiator
    local initiator_conf=&quot;/etc/iscsi/initiatorname.iscsi&quot;

    [ -f &quot;$initiator_conf&quot; ] || return 1

    while read _initiator; do
        [ -z &quot;${_initiator%%#*}&quot; ] &amp;&amp; continue # Skip comment lines

        case $_initiator in
            InitiatorName=*)
                initiator=${_initiator#InitiatorName=}
                echo &quot;rd.iscsi.initiator=${initiator}&quot;
                return 0;;
            *) ;;
        esac
    done &lt; ${initiator_conf}

    return 1
}

# Figure out iBFT session according to session type
is_ibft() {
    [ &quot;$(kdump_iscsi_get_rec_val $1 &quot;node.discovery_type&quot;)&quot; = fw ]
}

kdump_setup_iscsi_device() {
    local path=$1
    local tgt_name; local tgt_ipaddr;
    local username; local password; local userpwd_str;
    local username_in; local password_in; local userpwd_in_str;
    local netdev
    local srcaddr
    local idev
    local netroot_str ; local initiator_str;
    local netroot_conf=&quot;${initdir}/etc/cmdline.d/50iscsi.conf&quot;
    local initiator_conf=&quot;/etc/iscsi/initiatorname.iscsi&quot;

    dinfo &quot;Found iscsi component $1&quot;

    # Check once before getting explicit values, so we can bail out early,
    # e.g. in case of pure-hardware(all-offload) iscsi.
    if ! /sbin/iscsiadm -m session -r ${path} &amp;&gt;/dev/null ; then
        return 1
    fi

    if is_ibft ${path}; then
        return
    fi

    # Remove software iscsi cmdline generated by 95iscsi,
    # and let kdump regenerate here.
    rm -f ${initdir}/etc/cmdline.d/95iscsi.conf

    tgt_name=$(kdump_iscsi_get_rec_val ${path} &quot;node.name&quot;)
    tgt_ipaddr=$(kdump_iscsi_get_rec_val ${path} &quot;node.conn\[0\].address&quot;)

    # get and set username and password details
    username=$(kdump_iscsi_get_rec_val ${path} &quot;node.session.auth.username&quot;)
    [ &quot;$username&quot; == &quot;&lt;empty&gt;&quot; ] &amp;&amp; username=&quot;&quot;
    password=$(kdump_iscsi_get_rec_val ${path} &quot;node.session.auth.password&quot;)
    [ &quot;$password&quot; == &quot;&lt;empty&gt;&quot; ] &amp;&amp; password=&quot;&quot;
    username_in=$(kdump_iscsi_get_rec_val ${path} &quot;node.session.auth.username_in&quot;)
    [ -n &quot;$username&quot; ] &amp;&amp; userpwd_str=&quot;$username:$password&quot;

    # get and set incoming username and password details
    [ &quot;$username_in&quot; == &quot;&lt;empty&gt;&quot; ] &amp;&amp; username_in=&quot;&quot;
    password_in=$(kdump_iscsi_get_rec_val ${path} &quot;node.session.auth.password_in&quot;)
    [ &quot;$password_in&quot; == &quot;&lt;empty&gt;&quot; ] &amp;&amp; password_in=&quot;&quot;

    [ -n &quot;$username_in&quot; ] &amp;&amp; userpwd_in_str=&quot;:$username_in:$password_in&quot;

    netdev=$(/sbin/ip route get to ${tgt_ipaddr} | \
        sed 's|.*dev \(.*\).*|\1|g')
    srcaddr=$(echo $netdev | awk '{ print $3; exit }')
    netdev=$(echo $netdev | awk '{ print $1; exit }')

    kdump_setup_netdev $netdev $srcaddr

    # prepare netroot= command line
    # FIXME: Do we need to parse and set other parameters like protocol, port
    #        iscsi_iface_name, netdev_name, LUN etc.

    if is_ipv6_address $tgt_ipaddr; then
        tgt_ipaddr=&quot;[$tgt_ipaddr]&quot;
    fi
    netroot_str=&quot;netroot=iscsi:${userpwd_str}${userpwd_in_str}@$tgt_ipaddr::::$tgt_name&quot;

    [[ -f $netroot_conf ]] || touch $netroot_conf

    # If netroot target does not exist already, append.
    if ! grep -q $netroot_str $netroot_conf; then
         echo $netroot_str &gt;&gt; $netroot_conf
         dinfo &quot;Appended $netroot_str to $netroot_conf&quot;
    fi

    # Setup initator
    initiator_str=$(kdump_get_iscsi_initiator)
    [ $? -ne &quot;0&quot; ] &amp;&amp; derror &quot;Failed to get initiator name&quot; &amp;&amp; return 1

    # If initiator details do not exist already, append.
    if ! grep -q &quot;$initiator_str&quot; $netroot_conf; then
         echo &quot;$initiator_str&quot; &gt;&gt; $netroot_conf
         dinfo &quot;Appended &quot;$initiator_str&quot; to $netroot_conf&quot;
    fi
}

kdump_check_iscsi_targets () {
    # If our prerequisites are not met, fail anyways.
    type -P iscsistart &gt;/dev/null || return 1

    kdump_check_setup_iscsi() {
        local _dev
        _dev=$1

        [[ -L /sys/dev/block/$_dev ]] || return
        cd &quot;$(readlink -f /sys/dev/block/$_dev)&quot;
        until [[ -d sys || -d iscsi_session ]]; do
            cd ..
        done
        [[ -d iscsi_session ]] &amp;&amp; kdump_setup_iscsi_device &quot;$PWD&quot;
    }

    [[ $hostonly ]] || [[ $mount_needs ]] &amp;&amp; {
        for_each_host_dev_and_slaves_all kdump_check_setup_iscsi
    }
}

# hostname -a is deprecated, do it by ourself
get_alias() {
    local ips
    local entries
    local alias_set

    ips=$(hostname -I)
    for ip in $ips
    do
            # in /etc/hosts, alias can come at the 2nd column
            entries=$(grep $ip /etc/hosts | awk '{ $1=&quot;&quot;; print $0 }')
            if [ $? -eq 0 ]; then
                    alias_set=&quot;$alias_set $entries&quot;
            fi
    done

    echo $alias_set
}

is_localhost() {
    local hostnames=$(hostname -A)
    local shortnames=$(hostname -A -s)
    local aliasname=$(get_alias)
    local nodename=$1

    hostnames=&quot;$hostnames $shortnames $aliasname&quot;

    for name in ${hostnames}; do
        if [ &quot;$name&quot; == &quot;$nodename&quot; ]; then
            return 0
        fi
    done
    return 1
}

# retrieves fence_kdump nodes from Pacemaker cluster configuration
get_pcs_fence_kdump_nodes() {
    local nodes

    # get cluster nodes from cluster cib, get interface and ip address
    nodelist=`pcs cluster cib | xmllint --xpath &quot;/cib/status/node_state/@uname&quot; -`

    # nodelist is formed as 'uname=&quot;node1&quot; uname=&quot;node2&quot; ... uname=&quot;nodeX&quot;'
    # we need to convert each to node1, node2 ... nodeX in each iteration
    for node in ${nodelist}; do
        # convert $node from 'uname=&quot;nodeX&quot;' to 'nodeX'
        eval $node
        nodename=$uname
        # Skip its own node name
        if [ &quot;$nodename&quot; = `hostname` -o &quot;$nodename&quot; = `hostname -s` ]; then
            continue
        fi
        nodes=&quot;$nodes $nodename&quot;
    done

    echo $nodes
}

# retrieves fence_kdump args from config file
get_pcs_fence_kdump_args() {
    if [ -f $FENCE_KDUMP_CONFIG_FILE ]; then
        . $FENCE_KDUMP_CONFIG_FILE
        echo $FENCE_KDUMP_OPTS
    fi
}

get_generic_fence_kdump_nodes() {
    local filtered
    local nodes

    nodes=$(get_option_value &quot;fence_kdump_nodes&quot;)
    for node in ${nodes}; do
        # Skip its own node name
        if is_localhost $node; then
            continue
        fi
        filtered=&quot;$filtered $node&quot;
    done
    echo $filtered
}

# setup fence_kdump in cluster
# setup proper network and install needed files
kdump_configure_fence_kdump () {
    local kdump_cfg_file=$1
    local nodes
    local args

    if is_generic_fence_kdump; then
        nodes=$(get_generic_fence_kdump_nodes)

    elif is_pcs_fence_kdump; then
        nodes=$(get_pcs_fence_kdump_nodes)

        # set appropriate options in kdump.conf
        echo &quot;fence_kdump_nodes $nodes&quot; &gt;&gt; ${kdump_cfg_file}

        args=$(get_pcs_fence_kdump_args)
        if [ -n &quot;$args&quot; ]; then
            echo &quot;fence_kdump_args $args&quot; &gt;&gt; ${kdump_cfg_file}
        fi

    else
        # fence_kdump not configured
        return 1
    fi

    # setup network for each node
    for node in ${nodes}; do
        kdump_install_net $node
    done

    dracut_install /etc/hosts
    dracut_install /etc/nsswitch.conf
    dracut_install $FENCE_KDUMP_SEND
}

# Install a random seed used to feed /dev/urandom
# By the time kdump service starts, /dev/uramdom is already fed by systemd
kdump_install_random_seed() {
    local poolsize=`cat /proc/sys/kernel/random/poolsize`

    if [ ! -d ${initdir}/var/lib/ ]; then
        mkdir -p ${initdir}/var/lib/
    fi

    dd if=/dev/urandom of=${initdir}/var/lib/random-seed \
       bs=$poolsize count=1 2&gt; /dev/null
}

remove_cpu_online_rule() {
    local file=${initdir}/usr/lib/udev/rules.d/40-redhat.rules

    sed -i '/SUBSYSTEM==&quot;cpu&quot;/d' $file
}

kdump_install_systemd_conf() {
    local failure_action=$(get_option_value &quot;failure_action&quot;)

    # Kdump turns out to require longer default systemd mount timeout
    # than 1st kernel(90s by default), we use default 300s for kdump.
    grep -r &quot;^[[:space:]]*DefaultTimeoutStartSec=&quot; ${initdir}/etc/systemd/system.conf* &amp;&gt;/dev/null
    if [ $? -ne 0 ]; then
        mkdir -p ${initdir}/etc/systemd/system.conf.d
        echo &quot;[Manager]&quot; &gt; ${initdir}/etc/systemd/system.conf.d/kdump.conf
        echo &quot;DefaultTimeoutStartSec=300s&quot; &gt;&gt; ${initdir}/etc/systemd/system.conf.d/kdump.conf
    fi

    # Forward logs to console directly, and don't read Kmsg, this avoids
    # unneccessary memory consumption and make console output more useful.
    # Only do so for non fadump image.
    mkdir -p ${initdir}/etc/systemd/journald.conf.d
    echo &quot;[Journal]&quot; &gt; ${initdir}/etc/systemd/journald.conf.d/kdump.conf
    echo &quot;Storage=volatile&quot; &gt;&gt; ${initdir}/etc/systemd/journald.conf.d/kdump.conf
    echo &quot;ReadKMsg=no&quot; &gt;&gt; ${initdir}/etc/systemd/journald.conf.d/kdump.conf
    echo &quot;ForwardToConsole=yes&quot; &gt;&gt; ${initdir}/etc/systemd/journald.conf.d/kdump.conf
}

install() {
    declare -A unique_netifs
    local arch _netifs

    kdump_module_init
    kdump_install_conf
    remove_sysctl_conf

    # Onlining secondary cpus breaks kdump completely on KVM on Power hosts
    # Though we use maxcpus=1 by default but 40-redhat.rules will bring up all
    # possible cpus by default. (rhbz1270174 rhbz1266322)
    # Thus before we get the kernel fix and the systemd rule fix let's remove
    # the cpu online rule in kdump initramfs.
    arch=$(uname -m)
    if [[ &quot;$arch&quot; = &quot;ppc64le&quot; ]] || [[ &quot;$arch&quot; = &quot;ppc64&quot; ]]; then
        remove_cpu_online_rule
    fi

    if is_ssh_dump_target; then
        kdump_install_random_seed
    fi
    dracut_install -o /etc/adjtime /etc/localtime
    inst &quot;$moddir/monitor_dd_progress&quot; &quot;/kdumpscripts/monitor_dd_progress&quot;
    chmod +x ${initdir}/kdumpscripts/monitor_dd_progress
    inst &quot;/bin/dd&quot; &quot;/bin/dd&quot;
    inst &quot;/bin/tail&quot; &quot;/bin/tail&quot;
    inst &quot;/bin/date&quot; &quot;/bin/date&quot;
    inst &quot;/bin/sync&quot; &quot;/bin/sync&quot;
    inst &quot;/bin/cut&quot; &quot;/bin/cut&quot;
    inst &quot;/bin/head&quot; &quot;/bin/head&quot;
    inst &quot;/sbin/makedumpfile&quot; &quot;/sbin/makedumpfile&quot;
    inst &quot;/sbin/vmcore-dmesg&quot; &quot;/sbin/vmcore-dmesg&quot;
    inst &quot;/usr/bin/printf&quot; &quot;/sbin/printf&quot;
    inst &quot;/usr/bin/logger&quot; &quot;/sbin/logger&quot;
    inst &quot;/usr/bin/chmod&quot; &quot;/sbin/chmod&quot;
    inst &quot;/lib/kdump/kdump-lib.sh&quot; &quot;/lib/kdump-lib.sh&quot;
    inst &quot;/lib/kdump/kdump-lib-initramfs.sh&quot; &quot;/lib/kdump-lib-initramfs.sh&quot;
    inst &quot;/lib/kdump/kdump-logger.sh&quot; &quot;/lib/kdump-logger.sh&quot;
    inst &quot;$moddir/kdump.sh&quot; &quot;/usr/bin/kdump.sh&quot;
    inst &quot;$moddir/kdump-capture.service&quot; &quot;$systemdsystemunitdir/kdump-capture.service&quot;
    systemctl -q --root &quot;$initdir&quot; add-wants initrd.target kdump-capture.service
    inst &quot;$moddir/kdump-error-handler.sh&quot; &quot;/usr/bin/kdump-error-handler.sh&quot;
    inst &quot;$moddir/kdump-error-handler.service&quot; &quot;$systemdsystemunitdir/kdump-error-handler.service&quot;
    # Replace existing emergency service and emergency target
    cp &quot;$moddir/kdump-emergency.service&quot; &quot;$initdir/$systemdsystemunitdir/emergency.service&quot;
    cp &quot;$moddir/kdump-emergency.target&quot; &quot;$initdir/$systemdsystemunitdir/emergency.target&quot;
    # Also redirect dracut-emergency to kdump error handler
    ln_r &quot;$systemdsystemunitdir/emergency.service&quot; &quot;$systemdsystemunitdir/dracut-emergency.service&quot;

    # Check for all the devices and if any device is iscsi, bring up iscsi
    # target. Ideally all this should be pushed into dracut iscsi module
    # at some point of time.
    kdump_check_iscsi_targets

    _netifs=$(_get_kdump_netifs)
    if [[ -n &quot;$_netifs&quot; ]]; then
        kdump_install_nm_netif_allowlist &quot;$_netifs&quot;
        kdump_install_nic_driver &quot;$_netifs&quot;
    fi

    kdump_install_systemd_conf

    # For the lvm type target under kdump, in /etc/lvm/lvm.conf we can
    # safely replace &quot;reserved_memory=XXXX&quot;(default value is 8192) with
    # &quot;reserved_memory=1024&quot; to lower memory pressure under kdump. We do
    # it unconditionally here, if &quot;/etc/lvm/lvm.conf&quot; doesn't exist, it
    # actually does nothing.
    sed -i -e \
      's/\(^[[:space:]]*reserved_memory[[:space:]]*=\)[[:space:]]*[[:digit:]]*/\1 1024/' \
      ${initdir}/etc/lvm/lvm.conf &amp;&gt;/dev/null

    # Skip initrd-cleanup.service and initrd-parse-etc.service becasue we don't
    # need to switch root. Instead of removing them, we use ConditionPathExists
    # to check if /proc/vmcore exists to determine if we are in kdump.
    sed -i '/\[Unit\]/a ConditionPathExists=!\/proc\/vmcore' \
        &quot;${initdir}/${systemdsystemunitdir}/initrd-cleanup.service&quot; &amp;&gt; /dev/null

    sed -i '/\[Unit\]/a ConditionPathExists=!\/proc\/vmcore' \
        &quot;${initdir}/${systemdsystemunitdir}/initrd-parse-etc.service&quot; &amp;&gt; /dev/null

    # Save more memory by dropping switch root capability
    dracut_no_switch_root
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib%2Fdracut%2Fmodules.d%2F99kdumpbase'>Back to Directory</a>