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

export DRACUT_SYSTEMD
export NEWROOT
if [ -n &quot;$NEWROOT&quot; ]; then
    [ -d $NEWROOT ] || mkdir -p -m 0755 $NEWROOT
fi

if ! [ -d /run/initramfs ]; then
    mkdir -p -m 0755 /run/initramfs/log
    ln -sfn /run/initramfs/log /var/log
fi

[ -d /run/lock ] || mkdir -p -m 0755 /run/lock
[ -d /run/log ] || mkdir -p -m 0755 /run/log

debug_off() {
    set +x
}

debug_on() {
    [ &quot;$RD_DEBUG&quot; = &quot;yes&quot; ] &amp;&amp; set -x
}

# returns OK if $1 contains literal string $2 (and isn't empty)
strstr() {
    [ &quot;${1##*&quot;$2&quot;*}&quot; != &quot;$1&quot; ]
}

# returns OK if $1 matches (completely) glob pattern $2
# An empty $1 will not be considered matched, even if $2 is * which technically
# matches; as it would match anything, it's not an interesting case.
strglob() {
    [ -n &quot;$1&quot; -a -z &quot;${1##$2}&quot; ]
}

# returns OK if $1 contains (anywhere) a match of glob pattern $2
# An empty $1 will not be considered matched, even if $2 is * which technically
# matches; as it would match anything, it's not an interesting case.
strglobin() {
    [ -n &quot;$1&quot; -a -z &quot;${1##*$2*}&quot; ]
}

# returns OK if $1 contains literal string $2 at the beginning, and isn't empty
str_starts() {
    [ &quot;${1#&quot;$2&quot;*}&quot; != &quot;$1&quot; ]
}

# returns OK if $1 contains literal string $2 at the end, and isn't empty
str_ends() {
    [ &quot;${1%*&quot;$2&quot;}&quot; != &quot;$1&quot; ]
}

trim() {
    local var=&quot;$*&quot;
    var=&quot;${var#&quot;${var%%[![:space:]]*}&quot;}&quot;   # remove leading whitespace characters
    var=&quot;${var%&quot;${var##*[![:space:]]}&quot;}&quot;   # remove trailing whitespace characters
    printf &quot;%s&quot; &quot;$var&quot;
}

if [ -z &quot;$DRACUT_SYSTEMD&quot; ]; then

    warn() {
        check_quiet
        echo &quot;&lt;28&gt;dracut Warning: $*&quot; &gt; /dev/kmsg
        echo &quot;dracut Warning: $*&quot; &gt;&amp;2
    }

    info() {
        check_quiet
        echo &quot;&lt;30&gt;dracut: $*&quot; &gt; /dev/kmsg
        [ &quot;$DRACUT_QUIET&quot; != &quot;yes&quot; ] &amp;&amp; \
            echo &quot;dracut: $*&quot; &gt;&amp;2
    }

else

    warn() {
        echo &quot;Warning: $*&quot; &gt;&amp;2
    }

    info() {
        echo &quot;$*&quot;
    }

fi

vwarn() {
    while read line || [ -n &quot;$line&quot; ]; do
        warn $line;
    done
}

vinfo() {
    while read line || [ -n &quot;$line&quot; ]; do
        info $line;
    done
}

# replaces all occurrences of 'search' in 'str' with 'replacement'
#
# str_replace str search replacement
#
# example:
# str_replace '  one two  three  ' ' ' '_'
str_replace() {
    local in=&quot;$1&quot;; local s=&quot;$2&quot;; local r=&quot;$3&quot;
    local out=''

    while strstr &quot;${in}&quot; &quot;$s&quot;; do
        chop=&quot;${in%%&quot;$s&quot;*}&quot;
        out=&quot;${out}${chop}$r&quot;
        in=&quot;${in#*&quot;$s&quot;}&quot;
    done
    echo &quot;${out}${in}&quot;
}

killall_proc_mountpoint() {
    local _pid
    local _t
    local _killed=0
    for _pid in /proc/*; do
        _pid=${_pid##/proc/}
        case $_pid in
            *[!0-9]*) continue;;
        esac
        [ -e &quot;/proc/$_pid/exe&quot; ] || continue
        [ -e &quot;/proc/$_pid/root&quot; ] || continue
        if strstr &quot;$(ls -l -- &quot;/proc/$_pid&quot; &quot;/proc/$_pid/fd&quot; 2&gt;/dev/null)&quot; &quot;$1&quot; ; then
            kill -9 &quot;$_pid&quot;
            _killed=1
        fi
    done
    return $_killed
}

getcmdline() {
    local _line
    local _i
    local CMDLINE_ETC_D
    local CMDLINE_ETC
    local CMDLINE_PROC
    unset _line

    if [ -e /etc/cmdline ]; then
        while read -r _line || [ -n &quot;$_line&quot; ]; do
            CMDLINE_ETC=&quot;$CMDLINE_ETC $_line&quot;;
        done &lt;/etc/cmdline;
    fi
    for _i in /etc/cmdline.d/*.conf; do
        [ -e &quot;$_i&quot; ] || continue
        while read -r _line || [ -n &quot;$_line&quot; ]; do
            CMDLINE_ETC_D=&quot;$CMDLINE_ETC_D $_line&quot;;
        done &lt;&quot;$_i&quot;;
    done
    if [ -e /proc/cmdline ]; then
        while read -r _line || [ -n &quot;$_line&quot; ]; do
            CMDLINE_PROC=&quot;$CMDLINE_PROC $_line&quot;
        done &lt;/proc/cmdline;
    fi
    CMDLINE=&quot;$CMDLINE_ETC_D $CMDLINE_ETC $CMDLINE_PROC&quot;
    printf &quot;%s&quot; &quot;$CMDLINE&quot;
}

_dogetarg() {
    local _o _val _doecho
    unset _val
    unset _o
    unset _doecho
    CMDLINE=$(getcmdline)

    for _o in $CMDLINE; do
        if [ &quot;${_o%%=*}&quot; = &quot;${1%%=*}&quot; ]; then
            if [ -n &quot;${1#*=}&quot; -a &quot;${1#*=*}&quot; != &quot;${1}&quot; ]; then
                # if $1 has a &quot;=&lt;value&gt;&quot;, we want the exact match
                if [ &quot;$_o&quot; = &quot;$1&quot; ]; then
                    _val=&quot;1&quot;;
                    unset _doecho
                fi
                continue
            fi

            if [ &quot;${_o#*=}&quot; = &quot;$_o&quot; ]; then
                # if cmdline argument has no &quot;=&lt;value&gt;&quot;, we assume &quot;=1&quot;
                _val=&quot;1&quot;;
                unset _doecho
                continue
            fi

            _val=&quot;${_o#*=}&quot;
            _doecho=1
        fi
    done
    if [ -n &quot;$_val&quot; ]; then
        [ &quot;x$_doecho&quot; != &quot;x&quot; ] &amp;&amp; echo &quot;$_val&quot;;
        return 0;
    fi
    return 1;
}

getarg() {
    debug_off
    local _deprecated _newoption
    while [ $# -gt 0 ]; do
        case $1 in
            -d) _deprecated=1; shift;;
            -y) if _dogetarg $2 &gt;/dev/null; then
                    if [ &quot;$_deprecated&quot; = &quot;1&quot; ]; then
                        [ -n &quot;$_newoption&quot; ] &amp;&amp; warn &quot;Kernel command line option '$2' is deprecated, use '$_newoption' instead.&quot; || warn &quot;Option '$2' is deprecated.&quot;
                    fi
                    echo 1
                    debug_on
                    return 0
                fi
                _deprecated=0
                shift 2;;
            -n) if _dogetarg $2 &gt;/dev/null; then
                    echo 0;
                    if [ &quot;$_deprecated&quot; = &quot;1&quot; ]; then
                        [ -n &quot;$_newoption&quot; ] &amp;&amp; warn &quot;Kernel command line option '$2' is deprecated, use '$_newoption=0' instead.&quot; || warn &quot;Option '$2' is deprecated.&quot;
                    fi
                    debug_on
                    return 1
                fi
                _deprecated=0
                shift 2;;
            *)  if [ -z &quot;$_newoption&quot; ]; then
                    _newoption=&quot;$1&quot;
                fi
                if _dogetarg $1; then
                    if [ &quot;$_deprecated&quot; = &quot;1&quot; ]; then
                        [ -n &quot;$_newoption&quot; ] &amp;&amp; warn &quot;Kernel command line option '$1' is deprecated, use '$_newoption' instead.&quot; || warn &quot;Option '$1' is deprecated.&quot;
                    fi
                    debug_on
                    return 0;
                fi
                _deprecated=0
                shift;;
        esac
    done
    debug_on
    return 1
}

# getargbool &lt;defaultval&gt; &lt;args...&gt;
# False if &quot;getarg &lt;args...&gt;&quot; returns &quot;0&quot;, &quot;no&quot;, or &quot;off&quot;.
# True if getarg returns any other non-empty string.
# If not found, assumes &lt;defaultval&gt; - usually 0 for false, 1 for true.
# example: getargbool 0 rd.info
#   true: rd.info, rd.info=1, rd.info=xxx
#   false: rd.info=0, rd.info=off, rd.info not present (default val is 0)
getargbool() {
    local _b
    unset _b
    local _default
    _default=&quot;$1&quot;; shift
    _b=$(getarg &quot;$@&quot;)
    [ $? -ne 0 -a -z &quot;$_b&quot; ] &amp;&amp; _b=&quot;$_default&quot;
    if [ -n &quot;$_b&quot; ]; then
        [ $_b = &quot;0&quot; ] &amp;&amp; return 1
        [ $_b = &quot;no&quot; ] &amp;&amp; return 1
        [ $_b = &quot;off&quot; ] &amp;&amp; return 1
    fi
    return 0
}

isdigit() {
    case &quot;$1&quot; in
        *[!0-9]*|&quot;&quot;) return 1;;
    esac

    return 0
}

# getargnum &lt;defaultval&gt; &lt;minval&gt; &lt;maxval&gt; &lt;arg&gt;
# Will echo the arg if it's in range [minval - maxval].
# If it's not set or it's not valid, will set it &lt;defaultval&gt;.
# Note all values are required to be &gt;= 0 here.
# &lt;defaultval&gt; should be with [minval -maxval].
getargnum() {
    local _b
    unset _b
    local _default _min _max
    _default=&quot;$1&quot;; shift
    _min=&quot;$1&quot;; shift
    _max=&quot;$1&quot;; shift
    _b=$(getarg &quot;$1&quot;)
    [ $? -ne 0 -a -z &quot;$_b&quot; ] &amp;&amp; _b=$_default
    if [ -n &quot;$_b&quot; ]; then
        isdigit &quot;$_b&quot; &amp;&amp; _b=$(($_b)) &amp;&amp; \
          [ $_b -ge $_min ] &amp;&amp; [ $_b -le $_max ] &amp;&amp; echo $_b &amp;&amp; return
    fi
    echo $_default
}

_dogetargs() {
    debug_off
    local _o _found _key
    unset _o
    unset _found
    CMDLINE=$(getcmdline)
    _key=&quot;$1&quot;
    set --
    for _o in $CMDLINE; do
        if [ &quot;$_o&quot; = &quot;$_key&quot; ]; then
            _found=1;
        elif [ &quot;${_o%%=*}&quot; = &quot;${_key%=}&quot; ]; then
            [ -n &quot;${_o%%=*}&quot; ] &amp;&amp; set -- &quot;$@&quot; &quot;${_o#*=}&quot;;
            _found=1;
        fi
    done
    if [ -n &quot;$_found&quot; ]; then
        [ $# -gt 0 ] &amp;&amp; printf '%s' &quot;$*&quot;
        return 0
    fi
    return 1;
}

getargs() {
    debug_off
    local _val _i _args _gfound _deprecated
    unset _val
    unset _gfound
    _newoption=&quot;$1&quot;
    _args=&quot;$@&quot;
    set --
    for _i in $_args; do
        if [ &quot;$_i&quot; = &quot;-d&quot; ]; then
            _deprecated=1
            continue
        fi
        _val=&quot;$(_dogetargs $_i)&quot;
        if [ $? -eq 0 ]; then
            if [ &quot;$_deprecated&quot; = &quot;1&quot; ]; then
                [ -n &quot;$_newoption&quot; ] &amp;&amp; warn &quot;Option '$_i' is deprecated, use '$_newoption' instead.&quot; || warn &quot;Option $_i is deprecated!&quot;
            fi
            _gfound=1
        fi
        [ -n &quot;$_val&quot; ] &amp;&amp; set -- &quot;$@&quot; &quot;$_val&quot;
        _deprecated=0
    done
    if [ -n &quot;$_gfound&quot; ]; then
        if [ $# -gt 0 ]; then
            printf '%s' &quot;$*&quot;
        fi
        debug_on
        return 0
    fi
    debug_on
    return 1;
}


# Prints value of given option.  If option is a flag and it's present,
# it just returns 0.  Otherwise 1 is returned.
# $1 = options separated by commas
# $2 = option we are interested in
#
# Example:
# $1 = cipher=aes-cbc-essiv:sha256,hash=sha256,verify
# $2 = hash
# Output:
# sha256
getoptcomma() {
    local line=&quot;,$1,&quot;; local opt=&quot;$2&quot;; local tmp

    case &quot;${line}&quot; in
        *,${opt}=*,*)
            tmp=&quot;${line#*,${opt}=}&quot;
            echo &quot;${tmp%%,*}&quot;
            return 0
            ;;
        *,${opt},*) return 0;;
    esac
    return 1
}

# Splits given string 'str' with separator 'sep' into variables 'var1', 'var2',
# 'varN'.  If number of fields is less than number of variables, remaining are
# not set.  If number of fields is greater than number of variables, the last
# variable takes remaining fields.  In short - it acts similary to 'read'.
#
# splitsep sep str var1 var2 varN
#
# example:
#   splitsep ':' 'foo:bar:baz' v1 v2
# in result:
#   v1='foo', v2='bar:baz'
#
# TODO: ':' inside fields.
splitsep() {
    debug_off
    local sep=&quot;$1&quot;; local str=&quot;$2&quot;; shift 2
    local tmp

    while [ -n &quot;$str&quot; -a &quot;$#&quot; -gt 1 ]; do
        tmp=&quot;${str%%$sep*}&quot;
        local -n _splitsep_ref=&quot;$1&quot;
        _splitsep_ref=&quot;$tmp&quot;
        unset -n _splitsep_ref
        str=&quot;${str#&quot;$tmp&quot;}&quot;
        str=&quot;${str#$sep}&quot;
        shift
    done
    if [ -n &quot;$str&quot; -a -n &quot;$1&quot; ]; then
        local -n _splitsep_ref=&quot;$1&quot;
        _splitsep_ref=&quot;$str&quot;
        unset -n _splitsep_ref
    fi
    debug_on
    return 0
}

setdebug() {
    [ -f /usr/lib/initrd-release ] || return
    if [ -z &quot;$RD_DEBUG&quot; ]; then
        if [ -e /proc/cmdline ]; then
            RD_DEBUG=no
            if getargbool 0 rd.debug -d -y rdinitdebug -d -y rdnetdebug; then
                RD_DEBUG=yes
                [ -n &quot;$BASH&quot; ] &amp;&amp; \
                    export PS4='${BASH_SOURCE}@${LINENO}(${FUNCNAME[0]}): ';
           fi
        fi
        export RD_DEBUG
    fi
    debug_on
}

setdebug

source_all() {
    local f
    local _dir
    _dir=$1; shift
    [ &quot;$_dir&quot; ] &amp;&amp; [  -d &quot;/$_dir&quot; ] || return
    for f in &quot;/$_dir&quot;/*.sh; do [ -e &quot;$f&quot; ] &amp;&amp; . &quot;$f&quot; &quot;$@&quot;; done
}

hookdir=/lib/dracut/hooks
export hookdir

source_hook() {
    local _dir
    _dir=$1; shift
    source_all &quot;/lib/dracut/hooks/$_dir&quot; &quot;$@&quot;
}

check_finished() {
    local f
    for f in $hookdir/initqueue/finished/*.sh; do
        [ &quot;$f&quot; = &quot;$hookdir/initqueue/finished/*.sh&quot; ] &amp;&amp; return 0
        { [ -e &quot;$f&quot; ] &amp;&amp; ( . &quot;$f&quot; ) ; } || return 1
    done
    return 0
}

source_conf() {
    local f
    [ &quot;$1&quot; ] &amp;&amp; [  -d &quot;/$1&quot; ] || return
    for f in &quot;/$1&quot;/*.conf; do [ -e &quot;$f&quot; ] &amp;&amp; . &quot;$f&quot;; done
}

die() {
    {
        echo &quot;&lt;24&gt;dracut: FATAL: $*&quot;;
        echo &quot;&lt;24&gt;dracut: Refusing to continue&quot;;
    } &gt; /dev/kmsg

    {
        printf 'warn dracut: FATAL: %q\n' &quot;$*&quot;
        echo &quot;warn dracut: Refusing to continue&quot;
    } &gt;&gt; $hookdir/emergency/01-die.sh
    [ -d /run/initramfs ] || mkdir -p -- /run/initramfs

    &gt; /run/initramfs/.die

    if getargbool 0 &quot;rd.shell&quot;; then
        emergency_shell
    else
        source_hook &quot;shutdown-emergency&quot;
    fi

    if [ -n &quot;$DRACUT_SYSTEMD&quot; ]; then
        systemctl --no-block --force halt
    fi

    exit 1
}

check_quiet() {
    if [ -z &quot;$DRACUT_QUIET&quot; ]; then
        DRACUT_QUIET=&quot;yes&quot;
        getargbool 0 rd.info -d -y rdinfo &amp;&amp; DRACUT_QUIET=&quot;no&quot;
        getargbool 0 rd.debug -d -y rdinitdebug &amp;&amp; DRACUT_QUIET=&quot;no&quot;
        getarg quiet || DRACUT_QUIET=&quot;yes&quot;
        a=$(getarg loglevel=)
        [ -n &quot;$a&quot; ] &amp;&amp; [ $a -ge 28 ] &amp;&amp; DRACUT_QUIET=&quot;yes&quot;
        export DRACUT_QUIET
    fi
}


check_occurances() {
    # Count the number of times the character $ch occurs in $str
    # Return 0 if the count matches the expected number, 1 otherwise
    local str=&quot;$1&quot;
    local ch=&quot;$2&quot;
    local expected=&quot;$3&quot;
    local count=0

    while [ &quot;${str#*$ch}&quot; != &quot;${str}&quot; ]; do
        str=&quot;${str#*$ch}&quot;
        count=$(( $count + 1 ))
    done

    [ $count -eq $expected ]
}

incol2() {
    debug_off
    local dummy check;
    local file=&quot;$1&quot;;
    local str=&quot;$2&quot;;

    [ -z &quot;$file&quot; ] &amp;&amp; return 1;
    [ -z &quot;$str&quot;  ] &amp;&amp; return 1;

    while read dummy check restofline || [ -n &quot;$check&quot; ]; do
        if [ &quot;$check&quot; = &quot;$str&quot; ]; then
            debug_on
            return 0
        fi
    done &lt; $file
    debug_on
    return 1
}

udevsettle() {
    [ -z &quot;$UDEVVERSION&quot; ] &amp;&amp; export UDEVVERSION=$(udevadm --version | { read v _ ; echo $v ; })

    if [ $UDEVVERSION -ge 143 ]; then
        udevadm settle --exit-if-exists=$hookdir/initqueue/work $settle_exit_if_exists
    else
        udevadm settle --timeout=30
    fi
}

udevproperty() {
    [ -z &quot;$UDEVVERSION&quot; ] &amp;&amp; export UDEVVERSION=$(udevadm --version | { read v _ ; echo $v ; })

    if [ $UDEVVERSION -ge 143 ]; then
        for i in &quot;$@&quot;; do udevadm control --property=$i; done
    else
        for i in &quot;$@&quot;; do udevadm control --env=$i; done
    fi
}

find_mount() {
    local dev mnt etc wanted_dev
    wanted_dev=&quot;$(readlink -e -q $1)&quot;
    while read dev mnt etc || [ -n &quot;$dev&quot; ]; do
        [ &quot;$dev&quot; = &quot;$wanted_dev&quot; ] &amp;&amp; echo &quot;$dev&quot; &amp;&amp; return 0
    done &lt; /proc/mounts
    return 1
}

# usage: ismounted &lt;mountpoint&gt;
# usage: ismounted /dev/&lt;device&gt;
if command -v findmnt &gt;/dev/null; then
    ismounted() {
        findmnt &quot;$1&quot; &gt; /dev/null 2&gt;&amp;1
    }
else
    ismounted() {
        if [ -b &quot;$1&quot; ]; then
            find_mount &quot;$1&quot; &gt; /dev/null &amp;&amp; return 0
            return 1
        fi

        while read a m a || [ -n &quot;$m&quot; ]; do
            [ &quot;$m&quot; = &quot;$1&quot; ] &amp;&amp; return 0
        done &lt; /proc/mounts
        return 1
    }
fi

# root=nfs:[&lt;server-ip&gt;:]&lt;root-dir&gt;[:&lt;nfs-options&gt;]
# root=nfs4:[&lt;server-ip&gt;:]&lt;root-dir&gt;[:&lt;nfs-options&gt;]
nfsroot_to_var() {
    # strip nfs[4]:
    local arg=&quot;$@:&quot;
    nfs=&quot;${arg%%:*}&quot;
    arg=&quot;${arg##$nfs:}&quot;

    # check if we have a server
    if strstr &quot;$arg&quot; ':/' ; then
        server=&quot;${arg%%:/*}&quot;
        arg=&quot;/${arg##*:/}&quot;
    fi

    path=&quot;${arg%%:*}&quot;

    # rest are options
    options=&quot;${arg##$path}&quot;
    # strip leading &quot;:&quot;
    options=&quot;${options##:}&quot;
    # strip  &quot;:&quot;
    options=&quot;${options%%:}&quot;

    # Does it really start with '/'?
    [ -n &quot;${path%%/*}&quot; ] &amp;&amp; path=&quot;error&quot;;

    #Fix kernel legacy style separating path and options with ','
    if [ &quot;$path&quot; != &quot;${path#*,}&quot; ] ; then
        options=${path#*,}
        path=${path%%,*}
    fi
}

# Create udev rule match for a device with its device name, or the udev property
# ID_FS_UUID or ID_FS_LABEL
#
# example:
#   udevmatch LABEL=boot
# prints:
#   ENV{ID_FS_LABEL}=&quot;boot&quot;
#
# TODO: symlinks
udevmatch() {
    case &quot;$1&quot; in
    UUID=????????-????-????-????-????????????|LABEL=*|PARTLABEL=*|PARTUUID=????????-????-????-????-????????????)
        printf 'ENV{ID_FS_%s}==&quot;%s&quot;' &quot;${1%%=*}&quot; &quot;${1#*=}&quot;
        ;;
    UUID=*)
        printf 'ENV{ID_FS_UUID}==&quot;%s*&quot;' &quot;${1#*=}&quot;
        ;;
    PARTUUID=*)
        printf 'ENV{ID_FS_PARTUUID}==&quot;%s*&quot;' &quot;${1#*=}&quot;
        ;;
    /dev/?*) printf -- 'KERNEL==&quot;%s&quot;' &quot;${1#/dev/}&quot; ;;
    *) return 255 ;;
    esac
}

# Prints unique path for potential file inside specified directory.  It consists
# of specified directory, prefix and number at the end which is incremented
# until non-existing file is found.
#
# funiq dir prefix
#
# example:
# # ls /mnt
# cdrom0 cdrom1
#
# # funiq /mnt cdrom
# /mnt/cdrom2
funiq() {
    local dir=&quot;$1&quot;; local prefix=&quot;$2&quot;
    local i=0

    [ -d &quot;${dir}&quot; ] || return 1

    while [ -e &quot;${dir}/${prefix}$i&quot; ]; do
        i=$(($i+1)) || return 1
    done

    echo &quot;${dir}/${prefix}$i&quot;
}

# Creates unique directory and prints its path.  It's using funiq to generate
# path.
#
# mkuniqdir subdir new_dir_name
mkuniqdir() {
    local dir=&quot;$1&quot;; local prefix=&quot;$2&quot;
    local retdir; local retdir_new

    [ -d &quot;${dir}&quot; ] || mkdir -m 0755 -p &quot;${dir}&quot; || return 1

    retdir=$(funiq &quot;${dir}&quot; &quot;${prefix}&quot;) || return 1
    until mkdir -m 0755 &quot;${retdir}&quot; 2&gt;/dev/null; do
        retdir_new=$(funiq &quot;${dir}&quot; &quot;${prefix}&quot;) || return 1
        [ &quot;$retdir_new&quot; = &quot;$retdir&quot; ] &amp;&amp; return 1
        retdir=&quot;$retdir_new&quot;
    done

    echo &quot;${retdir}&quot;
}

# Copy the contents of SRC into DEST, merging the contents of existing
# directories (kinda like rsync, or cpio -p).
# Creates DEST if it doesn't exist. Overwrites files with the same names.
#
# copytree SRC DEST
copytree() {
    local src=&quot;$1&quot; dest=&quot;$2&quot;
    mkdir -p &quot;$dest&quot;; dest=$(readlink -e -q &quot;$dest&quot;)
    ( cd &quot;$src&quot;; cp -af . -t &quot;$dest&quot; )
}

# Evaluates command for UUIDs either given as arguments for this function or all
# listed in /dev/disk/by-uuid.  UUIDs doesn't have to be fully specified.  If
# beginning is given it is expanded to all matching UUIDs.  To pass full UUID to
# your command use '$___' as a place holder.  Remember to escape '$'!
#
# foreach_uuid_until [ -p prefix ] command UUIDs
#
# prefix - string to put just before $___
# command - command to be evaluated
# UUIDs - list of UUIDs separated by space
#
# The function returns after *first successful evaluation* of the given command
# with status 0.  If evaluation fails for every UUID function returns with
# status 1.
#
# Example:
# foreach_uuid_until &quot;mount -U \$___ /mnt; echo OK; umount /mnt&quot; \
#       &quot;01234 f512 a235567f-12a3-c123-a1b1-01234567abcb&quot;
foreach_uuid_until() (
    cd /dev/disk/by-uuid

    [ &quot;$1&quot; = -p ] &amp;&amp; local prefix=&quot;$2&quot; &amp;&amp; shift 2
    local cmd=&quot;$1&quot;; shift; local uuids_list=&quot;$*&quot;
    local uuid; local full_uuid; local ___

    [ -n &quot;${cmd}&quot; ] || return 1

    for uuid in ${uuids_list:-*}; do
        for full_uuid in ${uuid}*; do
            [ -e &quot;${full_uuid}&quot; ] || continue
            ___=&quot;${prefix}${full_uuid}&quot;
            eval ${cmd} &amp;&amp; return 0
        done
    done

    return 1
)

# Get kernel name for given device.  Device may be the name too (then the same
# is returned), a symlink (full path), UUID (prefixed with &quot;UUID=&quot;) or label
# (prefixed with &quot;LABEL=&quot;).  If just a beginning of the UUID is specified or
# even an empty, function prints all device names which UUIDs match - every in
# single line.
#
# NOTICE: The name starts with &quot;/dev/&quot;.
#
# Example:
#   devnames UUID=123
# May print:
#   /dev/dm-1
#   /dev/sdb1
#   /dev/sdf3
devnames() {
    local dev=&quot;$1&quot;; local d; local names

    case &quot;$dev&quot; in
    UUID=*)
        dev=&quot;$(foreach_uuid_until '! blkid -U $___' &quot;${dev#UUID=}&quot;)&quot; \
            &amp;&amp; return 255
        [ -z &quot;$dev&quot; ] &amp;&amp; return 255
        ;;
    LABEL=*) dev=&quot;$(blkid -L &quot;${dev#LABEL=}&quot;)&quot; || return 255 ;;
    /dev/?*) ;;
    *) return 255 ;;
    esac

    for d in $dev; do
        names=&quot;$names
$(readlink -e -q &quot;$d&quot;)&quot; || return 255
    done

    echo &quot;${names#
}&quot;
}


usable_root() {
    local _i

    [ -d &quot;$1&quot; ] || return 1

    for _i in &quot;$1&quot;/usr/lib*/ld-*.so &quot;$1&quot;/lib*/ld-*.so; do
        [ -e &quot;$_i&quot; ] &amp;&amp; return 0
    done

    for _i in proc sys dev; do
        [ -e &quot;$1&quot;/$_i ] || return 1
    done

    return 0
}

inst_hook() {
    local _hookname _unique _name _job _exe
    while [ $# -gt 0 ]; do
        case &quot;$1&quot; in
            --hook)
                _hookname=&quot;/$2&quot;;shift;;
            --unique)
                _unique=&quot;yes&quot;;;
            --name)
                _name=&quot;$2&quot;;shift;;
            *)
                break;;
        esac
        shift
    done

    if [ -z &quot;$_unique&quot; ]; then
        _job=&quot;${_name}$$&quot;
    else
        _job=&quot;${_name:-$1}&quot;
        _job=${_job##*/}
    fi

    _exe=$1
    shift

    [ -x &quot;$_exe&quot; ] || _exe=$(command -v $_exe)

    if [ -n &quot;$onetime&quot; ]; then
        {
            echo '[ -e &quot;$_job&quot; ] &amp;&amp; rm -f -- &quot;$_job&quot;'
            echo &quot;$_exe $@&quot;
        } &gt; &quot;/tmp/$$-${_job}.sh&quot;
    else
        echo &quot;$_exe $@&quot; &gt; &quot;/tmp/$$-${_job}.sh&quot;
    fi

    mv -f &quot;/tmp/$$-${_job}.sh&quot; &quot;$hookdir/${_hookname}/${_job}.sh&quot;
}

# inst_mount_hook &lt;mountpoint&gt; &lt;prio&gt; &lt;name&gt; &lt;script&gt;
#
# Install a mount hook with priority &lt;prio&gt;,
# which executes &lt;script&gt; as soon as &lt;mountpoint&gt; is mounted.
inst_mount_hook() {
    local _prio=&quot;$2&quot; _jobname=&quot;$3&quot; _script=&quot;$4&quot;
    local _hookname=&quot;mount-$(str_replace &quot;$1&quot; '/' '\\x2f')&quot;
    [ -d &quot;$hookdir/${_hookname}&quot; ] || mkdir -p &quot;$hookdir/${_hookname}&quot;
    inst_hook --hook &quot;$_hookname&quot; --unique --name &quot;${_prio}-${_jobname}&quot; &quot;$_script&quot;
}

# add_mount_point &lt;dev&gt; &lt;mountpoint&gt; &lt;filesystem&gt; &lt;fsopts&gt;
#
# Mount &lt;dev&gt; on &lt;mountpoint&gt; with &lt;filesystem&gt; and &lt;fsopts&gt;
# and call any mount hooks, as soon, as it is mounted
add_mount_point() {
    local _dev=&quot;$1&quot; _mp=&quot;$2&quot; _fs=&quot;$3&quot; _fsopts=&quot;$4&quot;
    local _hookname=&quot;mount-$(str_replace &quot;$2&quot; '/' '\\x2f')&quot;
    local _devname=&quot;dev-$(str_replace &quot;$1&quot; '/' '\\x2f')&quot;
    echo &quot;$_dev $_mp $_fs $_fsopts 0 0&quot; &gt;&gt; /etc/fstab

    exec 7&gt;/etc/udev/rules.d/99-mount-${_devname}.rules
    echo 'SUBSYSTEM!=&quot;block&quot;, GOTO=&quot;mount_end&quot;' &gt;&amp;7
    echo 'ACTION!=&quot;add|change&quot;, GOTO=&quot;mount_end&quot;' &gt;&amp;7
    if [ -n &quot;$_dev&quot; ]; then
        udevmatch &quot;$_dev&quot; &gt;&amp;7 || {
            warn &quot;add_mount_point dev=$_dev incorrect!&quot;
            continue
        }
        printf ', ' &gt;&amp;7
    fi

    {
        printf -- 'RUN+=&quot;%s --unique --onetime ' $(command -v initqueue)
        printf -- '--name mount-%%k '
        printf -- '%s %s&quot;\n' &quot;$(command -v mount_hook)&quot; &quot;${_mp}&quot;
    } &gt;&amp;7
    echo 'LABEL=&quot;mount_end&quot;' &gt;&amp;7
    exec 7&gt;&amp;-
}

# wait_for_mount &lt;mountpoint&gt;
#
# Installs a initqueue-finished script,
# which will cause the main loop only to exit,
# if &lt;mountpoint&gt; is mounted.
wait_for_mount()
{
    local _name
    _name=&quot;$(str_replace &quot;$1&quot; '/' '\\x2f')&quot;
    printf '. /lib/dracut-lib.sh\nismounted &quot;%s&quot;\n' $1 \
        &gt;&gt; &quot;$hookdir/initqueue/finished/ismounted-${_name}.sh&quot;
    {
        printf 'ismounted &quot;%s&quot; || ' $1
        printf 'warn &quot;\&quot;%s\&quot; is not mounted&quot;\n' $1
    } &gt;&gt; &quot;$hookdir/emergency/90-${_name}.sh&quot;
}

# get a systemd-compatible unit name from a path
# (mimicks unit_name_from_path_instance())
dev_unit_name()
{
    local dev=&quot;$1&quot;

    if command -v systemd-escape &gt;/dev/null; then
        systemd-escape -p -- &quot;$dev&quot;
        return
    fi

    if [ &quot;$dev&quot; = &quot;/&quot; -o -z &quot;$dev&quot; ]; then
        printf -- &quot;-&quot;
        exit 0
    fi

    dev=&quot;${1%%/}&quot;
    dev=&quot;${dev##/}&quot;
    dev=&quot;$(str_replace &quot;$dev&quot; '\' '\x5c')&quot;
    dev=&quot;$(str_replace &quot;$dev&quot; '-' '\x2d')&quot;
    if [ &quot;${dev##.}&quot; != &quot;$dev&quot; ]; then
        dev=&quot;\x2e${dev##.}&quot;
    fi
    dev=&quot;$(str_replace &quot;$dev&quot; '/' '-')&quot;

    printf -- &quot;%s&quot; &quot;$dev&quot;
}

# set_systemd_timeout_for_dev &lt;dev&gt;
# Set 'rd.timeout' as the systemd timeout for &lt;dev&gt;

set_systemd_timeout_for_dev()
{
    local _name
    local _needreload
    local _noreload
    local _timeout

    if [ &quot;$1&quot; = &quot;-n&quot; ]; then
        _noreload=1
        shift
    fi

    _timeout=$(getarg rd.timeout)
    _timeout=${_timeout:-0}

    if [ -n &quot;$DRACUT_SYSTEMD&quot; ]; then
        _name=$(dev_unit_name &quot;$1&quot;)
        if ! [ -L ${PREFIX}/etc/systemd/system/initrd.target.wants/${_name}.device ]; then
            [ -d ${PREFIX}/etc/systemd/system/initrd.target.wants ] || mkdir -p ${PREFIX}/etc/systemd/system/initrd.target.wants
            ln -s ../${_name}.device ${PREFIX}/etc/systemd/system/initrd.target.wants/${_name}.device
            type mark_hostonly &gt;/dev/null 2&gt;&amp;1 &amp;&amp; mark_hostonly /etc/systemd/system/initrd.target.wants/${_name}.device
            _needreload=1
        fi

        if ! [ -f ${PREFIX}/etc/systemd/system/${_name}.device.d/timeout.conf ]; then
            mkdir -p ${PREFIX}/etc/systemd/system/${_name}.device.d
            {
                echo &quot;[Unit]&quot;
                echo &quot;JobTimeoutSec=$_timeout&quot;
                echo &quot;JobRunningTimeoutSec=$_timeout&quot;
            } &gt; ${PREFIX}/etc/systemd/system/${_name}.device.d/timeout.conf
            type mark_hostonly &gt;/dev/null 2&gt;&amp;1 &amp;&amp; mark_hostonly /etc/systemd/system/${_name}.device.d/timeout.conf
            _needreload=1
        fi

        if [ -z &quot;$PREFIX&quot; ] &amp;&amp; [ &quot;$_needreload&quot; = 1 ] &amp;&amp; [ -z &quot;$_noreload&quot; ]; then
            /sbin/initqueue --onetime --unique --name daemon-reload systemctl daemon-reload
        fi
    fi
}
# wait_for_dev &lt;dev&gt;
#
# Installs a initqueue-finished script,
# which will cause the main loop only to exit,
# if the device &lt;dev&gt; is recognized by the system.
wait_for_dev()
{
    local _name
    local _noreload

    if [ &quot;$1&quot; = &quot;-n&quot; ]; then
        _noreload=-n
        shift
    fi

    _name=&quot;$(str_replace &quot;$1&quot; '/' '\x2f')&quot;

    type mark_hostonly &gt;/dev/null 2&gt;&amp;1 &amp;&amp; mark_hostonly &quot;$hookdir/initqueue/finished/devexists-${_name}.sh&quot;

    [ -e &quot;${PREFIX}$hookdir/initqueue/finished/devexists-${_name}.sh&quot; ] &amp;&amp; return 0

    printf '[ -e &quot;%s&quot; ]\n' $1 \
        &gt;&gt; &quot;${PREFIX}$hookdir/initqueue/finished/devexists-${_name}.sh&quot;
    {
        printf '[ -e &quot;%s&quot; ] || ' $1
        printf 'warn &quot;\&quot;%s\&quot; does not exist&quot;\n' $1
    } &gt;&gt; &quot;${PREFIX}$hookdir/emergency/80-${_name}.sh&quot;

    set_systemd_timeout_for_dev $_noreload $1
}

cancel_wait_for_dev()
{
    local _name
    _name=&quot;$(str_replace &quot;$1&quot; '/' '\x2f')&quot;
    rm -f -- &quot;$hookdir/initqueue/finished/devexists-${_name}.sh&quot;
    rm -f -- &quot;$hookdir/emergency/80-${_name}.sh&quot;
    if [ -n &quot;$DRACUT_SYSTEMD&quot; ]; then
        _name=$(dev_unit_name &quot;$1&quot;)
        rm -f -- ${PREFIX}/etc/systemd/system/initrd.target.wants/${_name}.device
        rm -f -- ${PREFIX}/etc/systemd/system/${_name}.device.d/timeout.conf
        /sbin/initqueue --onetime --unique --name daemon-reload systemctl daemon-reload
    fi
}

killproc() {
    debug_off
    local _exe=&quot;$(command -v $1)&quot;
    local _sig=$2
    local _i
    [ -x &quot;$_exe&quot; ] || return 1
    for _i in /proc/[0-9]*; do
        [ &quot;$_i&quot; = &quot;/proc/1&quot; ] &amp;&amp; continue
        if [ -e &quot;$_i&quot;/_exe ] &amp;&amp; [  &quot;$_i/_exe&quot; -ef &quot;$_exe&quot; ] ; then
            kill $_sig ${_i##*/}
        fi
    done
    debug_on
}

need_shutdown() {
    &gt;/run/initramfs/.need_shutdown
}

wait_for_loginit()
{
    [ &quot;$RD_DEBUG&quot; = &quot;yes&quot; ] || return
    [ -e /run/initramfs/loginit.pipe ] || return
    debug_off
    echo &quot;DRACUT_LOG_END&quot;
    exec 0&lt;&gt;/dev/console 1&lt;&gt;/dev/console 2&lt;&gt;/dev/console
        # wait for loginit
    i=0
    while [ $i -lt 10 ]; do
        if [ ! -e /run/initramfs/loginit.pipe ]; then
            j=$(jobs)
            [ -z &quot;$j&quot; ] &amp;&amp; break
            [ -z &quot;${j##*Running*}&quot; ] || break
        fi
        sleep 0.1
        i=$(($i+1))
    done

    if [ $i -eq 10 ]; then
        kill %1 &gt;/dev/null 2&gt;&amp;1
        kill $(while read line || [ -n &quot;$line&quot; ];do echo $line;done&lt;/run/initramfs/loginit.pid)
    fi

    setdebug
    rm -f -- /run/initramfs/loginit.pipe /run/initramfs/loginit.pid
}

# pidof version for root
if ! command -v pidof &gt;/dev/null 2&gt;/dev/null; then
    pidof() {
        debug_off
        local _cmd
        local _exe
        local _rl
        local _ret=1
        local i
        _cmd=&quot;$1&quot;
        if [ -z &quot;$_cmd&quot; ]; then
            debug_on
            return 1
        fi
        _exe=$(command -v &quot;$1&quot;)
        for i in /proc/*/exe; do
            [ -e &quot;$i&quot; ] || continue
            if [ -n &quot;$_exe&quot; ]; then
                [ &quot;$i&quot; -ef &quot;$_exe&quot; ] || continue
            else
                _rl=$(readlink -f &quot;$i&quot;);
                [ &quot;${_rl%/$_cmd}&quot; != &quot;$_rl&quot; ] || continue
            fi
            i=${i%/exe}
            echo ${i##/proc/}
            _ret=0
        done
        debug_on
        return $_ret
    }
fi

_emergency_shell()
{
    local _name=&quot;$1&quot;
    if [ -n &quot;$DRACUT_SYSTEMD&quot; ]; then
        &gt; /.console_lock
        echo &quot;PS1=\&quot;$_name:\\\${PWD}# \&quot;&quot; &gt;/etc/profile
        systemctl start dracut-emergency.service
        rm -f -- /etc/profile
        rm -f -- /.console_lock
    else
        debug_off
        source_hook &quot;$hook&quot;
        echo
        /sbin/rdsosreport
        echo 'You might want to save &quot;/run/initramfs/rdsosreport.txt&quot; to a USB stick or /boot'
        echo 'after mounting them and attach it to a bug report.'
        if ! RD_DEBUG= getargbool 0 rd.debug -d -y rdinitdebug -d -y rdnetdebug; then
            echo
            echo 'To get more debug information in the report,'
            echo 'reboot with &quot;rd.debug&quot; added to the kernel command line.'
        fi
        echo
        echo 'Dropping to debug shell.'
        echo
        export PS1=&quot;$_name:\${PWD}# &quot;
        [ -e /.profile ] || &gt;/.profile

        _ctty=&quot;$(RD_DEBUG= getarg rd.ctty=)&quot; &amp;&amp; _ctty=&quot;/dev/${_ctty##*/}&quot;
        if [ -z &quot;$_ctty&quot; ]; then
            _ctty=console
            while [ -f /sys/class/tty/$_ctty/active ]; do
                _ctty=$(cat /sys/class/tty/$_ctty/active)
                _ctty=${_ctty##* } # last one in the list
            done
            _ctty=/dev/$_ctty
        fi
        [ -c &quot;$_ctty&quot; ] || _ctty=/dev/tty1
        case &quot;$(/usr/bin/setsid --help 2&gt;&amp;1)&quot; in *--ctty*) CTTY=&quot;--ctty&quot;;; esac
        setsid $CTTY /bin/sh -i -l 0&lt;&gt;$_ctty 1&lt;&gt;$_ctty 2&lt;&gt;$_ctty
    fi
}

emergency_shell()
{
    local _ctty
    set +e
    local _rdshell_name=&quot;dracut&quot; action=&quot;Boot&quot; hook=&quot;emergency&quot;
    local _emergency_action

    if [ &quot;$1&quot; = &quot;-n&quot; ]; then
        _rdshell_name=$2
        shift 2
    elif [ &quot;$1&quot; = &quot;--shutdown&quot; ]; then
        _rdshell_name=$2; action=&quot;Shutdown&quot;; hook=&quot;shutdown-emergency&quot;
        if type plymouth &gt;/dev/null 2&gt;&amp;1; then
            plymouth --hide-splash
        elif [ -x /oldroot/bin/plymouth ]; then
            /oldroot/bin/plymouth --hide-splash
        fi
        shift 2
    fi

    echo ; echo
    warn &quot;$*&quot;
    echo

    _emergency_action=$(getarg rd.emergency)
    [ -z &quot;$_emergency_action&quot; ] \
        &amp;&amp; [ -e /run/initramfs/.die ] \
        &amp;&amp; _emergency_action=halt

    if getargbool 1 rd.shell -d -y rdshell || getarg rd.break -d rdbreak; then
        _emergency_shell $_rdshell_name
    else
        source_hook &quot;$hook&quot;
        warn &quot;$action has failed. To debug this issue add \&quot;rd.shell rd.debug\&quot; to the kernel command line.&quot;
        [ -z &quot;$_emergency_action&quot; ] &amp;&amp; _emergency_action=halt
    fi

    case &quot;$_emergency_action&quot; in
        reboot)
            reboot || exit 1;;
        poweroff)
            poweroff || exit 1;;
        halt)
            halt || exit 1;;
    esac
}

# Retain the values of these variables but ensure that they are unexported
export_n() {
    local var
    local val
    for var in &quot;$@&quot;; do
        val=&quot;${!var}&quot;
        unset &quot;$var&quot;
        [ -n &quot;$val&quot; ] &amp;&amp; printf -v &quot;$var&quot; '%s' &quot;$val&quot;
    done
}

# returns OK if list1 contains all elements of list2, i.e. checks if list2 is a
# sublist of list1.  An order and a duplication doesn't matter.
#
# $1 = separator
# $2 = list1
# $3 = list2
# $4 = ignore values, separated by $1
listlist() {
    local _sep=&quot;$1&quot;
    local _list=&quot;${_sep}${2}${_sep}&quot;
    local _sublist=&quot;$3&quot;
    [ -n &quot;$4&quot; ] &amp;&amp; local _iglist=&quot;${_sep}${4}${_sep}&quot;
    local IFS=&quot;$_sep&quot;
    local _v

    [ &quot;$_list&quot; = &quot;$_sublist&quot; ] &amp;&amp; return 0

    for _v in $_sublist; do
        if [ -n &quot;$_v&quot; ] &amp;&amp; ! ( [ -n &quot;$_iglist&quot; ] &amp;&amp; strstr &quot;$_iglist&quot; &quot;$_v&quot; )
        then
            strstr &quot;$_list&quot; &quot;$_v&quot; || return 1
        fi
    done

    return 0
}

# returns OK if both lists contain the same values.  An order and a duplication
# doesn't matter.
#
# $1 = separator
# $2 = list1
# $3 = list2
# $4 = ignore values, separated by $1
are_lists_eq() {
    listlist &quot;$1&quot; &quot;$2&quot; &quot;$3&quot; &quot;$4&quot; &amp;&amp; listlist &quot;$1&quot; &quot;$3&quot; &quot;$2&quot; &quot;$4&quot;
}

setmemdebug() {
    if [ -z &quot;$DEBUG_MEM_LEVEL&quot; ]; then
        export DEBUG_MEM_LEVEL=$(getargnum 0 0 5 rd.memdebug)
    fi
}

setmemdebug

# parameters: func log_level prefix msg [trace_level:trace]...
make_trace_mem()
{
    local log_level prefix msg msg_printed
    local trace trace_level trace_in_higher_levels insert_trace

    msg=$1
    shift

    prefix='[debug_mem]'
    log_level=$DEBUG_MEM_LEVEL

    if [ -z &quot;$log_level&quot; ] || [ &quot;$log_level&quot; -le 0 ]; then
        return
    fi

    msg=$(echo $msg)

    msg_printed=0
    while [ $# -gt 0 ]; do
        trace=${1%%:*}
        trace_level=${trace%%+}
        [ &quot;$trace&quot; != &quot;$trace_level&quot; ] &amp;&amp; trace_in_higher_levels=&quot;yes&quot;
        trace=${1##*:}

        if [ -z &quot;$trace_level&quot; ]; then
            trace_level=0
        fi

        insert_trace=0
        if [ -n &quot;$trace_in_higher_levels&quot; ]; then
            if [ &quot;$log_level&quot; -ge &quot;$trace_level&quot; ]; then
                insert_trace=1
            fi
        else
            if [ &quot;$log_level&quot; -eq &quot;$trace_level&quot; ]; then
                insert_trace=1
            fi
        fi

        if [ $insert_trace -eq 1 ]; then
            if [ $msg_printed -eq 0 ]; then
                echo &quot;$prefix $msg&quot;
                msg_printed=1
            fi
            show_memstats $trace
        fi
        shift
    done
}

# parameters: type
show_memstats()
{
    case $1 in
        shortmem)
            cat /proc/meminfo  | grep -e &quot;^MemFree&quot; -e &quot;^Cached&quot; -e &quot;^Slab&quot;
            ;;
        mem)
            cat /proc/meminfo
            ;;
        slab)
            cat /proc/slabinfo
            ;;
        iomem)
            cat /proc/iomem
            ;;
    esac
}

remove_hostonly_files() {
    rm -fr /etc/cmdline /etc/cmdline.d/*.conf &quot;$hookdir/initqueue/finished&quot;
    if [ -f /lib/dracut/hostonly-files ]; then
        while read line || [ -n &quot;$line&quot; ]; do
            [ -e &quot;$line&quot; ] || [ -h &quot;$line&quot; ] || continue
            rm -f &quot;$line&quot;
        done &lt; /lib/dracut/hostonly-files
    fi
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib%2Fdracut%2Fmodules.d%2F99base'>Back to Directory</a>