dracut-init.sh

   1 #!/bin/bash
   2 #
   3 # functions used only by dracut and dracut modules
   4 #
   5 # Copyright 2005-2009 Red Hat, Inc.  All rights reserved.
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 2 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 export LC_MESSAGES=C
  21
  22 if [[ $EUID == "0" ]] && ! [[ $DRACUT_NO_XATTR ]]; then
  23     export DRACUT_CP="cp --reflink=auto --sparse=auto --preserve=mode,timestamps,xattr,links -dfr"
  24 else
  25     export DRACUT_CP="cp --reflink=auto --sparse=auto --preserve=mode,timestamps,links -dfr"
  26 fi
  27
  28 # is_func <command>
  29 # Check whether $1 is a function.
  30 is_func() {
  31     [[ "$(type -t "$1")" == "function" ]]
  32 }
  33
  34 if ! [[ $dracutbasedir ]]; then
  35     dracutbasedir=${BASH_SOURCE[0]%/*}
  36     [[ $dracutbasedir == dracut-functions* ]] && dracutbasedir="."
  37     [[ $dracutbasedir ]] || dracutbasedir="."
  38     dracutbasedir="$(readlink -f $dracutbasedir)"
  39 fi
  40
  41 if ! is_func dinfo > /dev/null 2>&1; then
  42     # shellcheck source=./dracut-logger.sh
  43     . "$dracutbasedir/dracut-logger.sh"
  44     dlog_init
  45 fi
  46
  47 # shellcheck disable=SC2154
  48 if ! [[ $initdir ]]; then
  49     dfatal "initdir not set"
  50     exit 1
  51 fi
  52
  53 if ! [[ -d $initdir ]]; then
  54     mkdir -p "$initdir"
  55 fi
  56
  57 if ! [[ $kernel ]]; then
  58     kernel=$(uname -r)
  59     export kernel
  60 fi
  61
  62 # shellcheck disable=SC2154
  63 srcmods="$dracutsysrootdir/lib/modules/$kernel/"
  64
  65 # shellcheck disable=SC2154
  66 [[ $drivers_dir ]] && {
  67     if ! command -v kmod &> /dev/null && vercmp "$(modprobe --version | cut -d' ' -f3)" lt 3.7; then
  68         dfatal 'To use --kmoddir option module-init-tools >= 3.7 is required.'
  69         exit 1
  70     fi
  71     srcmods="$drivers_dir"
  72 }
  73 export srcmods
  74
  75 # export standard hookdirs
  76 [[ $hookdirs ]] || {
  77     hookdirs="cmdline pre-udev pre-trigger netroot "
  78     hookdirs+="initqueue initqueue/settled initqueue/online initqueue/finished initqueue/timeout "
  79     hookdirs+="pre-mount pre-pivot cleanup mount "
  80     hookdirs+="emergency shutdown-emergency pre-shutdown shutdown "
  81     export hookdirs
  82 }
  83
  84 DRACUT_LDD=${DRACUT_LDD:-ldd}
  85 DRACUT_TESTBIN=${DRACUT_TESTBIN:-/bin/sh}
  86 DRACUT_LDCONFIG=${DRACUT_LDCONFIG:-ldconfig}
  87
  88 # shellcheck source=./dracut-functions.sh
  89 . "$dracutbasedir"/dracut-functions.sh
  90
  91 # Detect lib paths
  92 if ! [[ $libdirs ]]; then
  93     if [[ $("$DRACUT_LDD" "$dracutsysrootdir$DRACUT_TESTBIN") == */lib64/* ]] &> /dev/null \
  94         && [[ -d $dracutsysrootdir/lib64 ]]; then
  95         libdirs+=" /lib64"
  96         [[ -d $dracutsysrootdir/usr/lib64 ]] && libdirs+=" /usr/lib64"
  97     else
  98         libdirs+=" /lib"
  99         [[ -d $dracutsysrootdir/usr/lib ]] && libdirs+=" /usr/lib"
 100     fi
 101
 102     libdirs+=" $(ldconfig_paths)"
 103
 104     export libdirs
 105 fi
 106
 107 # helper function for check() in module-setup.sh
 108 # to check for required installed binaries
 109 # issues a standardized warning message
 110 require_binaries() {
 111     # shellcheck disable=SC2154
 112     local _module_name="${moddir##*/}"
 113     local _ret=0
 114
 115     if [[ $1 == "-m" ]]; then
 116         _module_name="$2"
 117         shift 2
 118     fi
 119
 120     for cmd in "$@"; do
 121         if ! find_binary "$cmd" &> /dev/null; then
 122             dinfo "Module '${_module_name#[0-9][0-9]}' will not be installed, because command '$cmd' could not be found!"
 123             ((_ret++))
 124         fi
 125     done
 126     return "$_ret"
 127 }
 128
 129 require_any_binary() {
 130     local _module_name="${moddir##*/}"
 131     local _ret=1
 132
 133     if [[ $1 == "-m" ]]; then
 134         _module_name="$2"
 135         shift 2
 136     fi
 137
 138     for cmd in "$@"; do
 139         if find_binary "$cmd" &> /dev/null; then
 140             _ret=0
 141             break
 142         fi
 143     done
 144
 145     if ((_ret != 0)); then
 146         dinfo "$_module_name: Could not find any command of '$*'!"
 147         return 1
 148     fi
 149
 150     return 0
 151 }
 152
 153 # helper function for check() in module-setup.sh
 154 # to check for required kernel modules
 155 # issues a standardized warning message
 156 require_kernel_modules() {
 157     # shellcheck disable=SC2154
 158     local _module_name="${moddir##*/}"
 159     local _ret=0
 160
 161     # Ignore kernel module requirement for no-kernel build
 162     [[ $no_kernel == yes ]] && return 0
 163
 164     if [[ $1 == "-m" ]]; then
 165         _module_name="$2"
 166         shift 2
 167     fi
 168
 169     for mod in "$@"; do
 170         if ! check_kernel_module "$mod" &> /dev/null; then
 171             dinfo "Module '${_module_name#[0-9][0-9]}' will not be installed, because kernel module '$mod' is not available!"
 172             ((_ret++))
 173         fi
 174     done
 175     return "$_ret"
 176 }
 177
 178 dracut_need_initqueue() {
 179     : > "$initdir/lib/dracut/need-initqueue"
 180 }
 181
 182 dracut_module_included() {
 183     # shellcheck disable=SC2154
 184     [[ " $mods_to_load $modules_loaded " == *\ $*\ * ]]
 185 }
 186
 187 dracut_no_switch_root() {
 188     : > "$initdir/lib/dracut/no-switch-root"
 189 }
 190
 191 dracut_module_path() {
 192     local _dir
 193
 194     # shellcheck disable=SC2231
 195     for _dir in "${dracutbasedir}"/modules.d/??${1}; do
 196         echo "$_dir"
 197         return 0
 198     done
 199     return 1
 200 }
 201
 202 if ! [[ $DRACUT_INSTALL ]]; then
 203     DRACUT_INSTALL=$(find_binary dracut-install)
 204 fi
 205
 206 if ! [[ $DRACUT_INSTALL ]] && [[ -x $dracutbasedir/dracut-install ]]; then
 207     DRACUT_INSTALL=$dracutbasedir/dracut-install
 208 elif ! [[ $DRACUT_INSTALL ]] && [[ -x $dracutbasedir/src/install/dracut-install ]]; then
 209     DRACUT_INSTALL=$dracutbasedir/src/install/dracut-install
 210 fi
 211
 212 # Test if dracut-install is a standalone executable with no options.
 213 # E.g. DRACUT_INSTALL may be set externally as:
 214 # DRACUT_INSTALL="valgrind dracut-install"
 215 # or
 216 # DRACUT_INSTALL="dracut-install --debug"
 217 # in which case the string cannot be tested for being executable.
 218 DRINSTALLPARTS=0
 219 for i in $DRACUT_INSTALL; do
 220     DRINSTALLPARTS=$((DRINSTALLPARTS + 1))
 221 done
 222
 223 if [[ $DRINSTALLPARTS == 1 ]] && ! command -v "$DRACUT_INSTALL" > /dev/null 2>&1; then
 224     dfatal "dracut-install not found!"
 225     exit 10
 226 fi
 227
 228 if [[ $hostonly == "-h" ]]; then
 229     if ! [[ $DRACUT_KERNEL_MODALIASES ]] || ! [[ -f $DRACUT_KERNEL_MODALIASES ]]; then
 230         export DRACUT_KERNEL_MODALIASES="${DRACUT_TMPDIR}/modaliases"
 231         $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${srcmods:+--kerneldir "$srcmods"} --modalias > "$DRACUT_KERNEL_MODALIASES"
 232     fi
 233 fi
 234
 235 [[ $DRACUT_RESOLVE_LAZY ]] || export DRACUT_RESOLVE_DEPS=1
 236 inst_dir() {
 237     local _ret
 238     [[ -e ${initdir}/"$1" ]] && return 0 # already there
 239     if $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} -d "$@"; then
 240         return 0
 241     else
 242         _ret=$?
 243         derror FAILED: "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} -d "$@"
 244         return $_ret
 245     fi
 246 }
 247
 248 inst() {
 249     local _ret _hostonly_install
 250     if [[ $1 == "-H" ]]; then
 251         _hostonly_install="-H"
 252         shift
 253     fi
 254     [[ -e ${initdir}/"${2:-$1}" ]] && return 0 # already there
 255     if $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} ${_hostonly_install:+-H} "$@"; then
 256         return 0
 257     else
 258         _ret=$?
 259         derror FAILED: "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} ${_hostonly_install:+-H} "$@"
 260         return $_ret
 261     fi
 262 }
 263
 264 inst_simple() {
 265     local _ret _hostonly_install
 266     if [[ $1 == "-H" ]]; then
 267         _hostonly_install="-H"
 268         shift
 269     fi
 270     [[ -e ${initdir}/"${2:-$1}" ]] && return 0 # already there
 271     [[ -e $1 ]] || return 1                    # no source
 272     if $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${_hostonly_install:+-H} "$@"; then
 273         return 0
 274     else
 275         _ret=$?
 276         derror FAILED: "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${_hostonly_install:+-H} "$@"
 277         return $_ret
 278     fi
 279 }
 280
 281 inst_symlink() {
 282     local _ret _hostonly_install
 283     if [[ $1 == "-H" ]]; then
 284         _hostonly_install="-H"
 285         shift
 286     fi
 287     [[ -e ${initdir}/"${2:-$1}" ]] && return 0 # already there
 288     [[ -L $1 ]] || return 1
 289     if $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} ${_hostonly_install:+-H} "$@"; then
 290         return 0
 291     else
 292         _ret=$?
 293         derror FAILED: "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} ${_hostonly_install:+-H} "$@"
 294         return $_ret
 295     fi
 296 }
 297
 298 inst_multiple() {
 299     local _ret _hostonly_install
 300     if [[ $1 == "-H" ]]; then
 301         _hostonly_install="-H"
 302         shift
 303     fi
 304     if $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} -a ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} ${_hostonly_install:+-H} "$@"; then
 305         return 0
 306     else
 307         _ret=$?
 308         derror FAILED: "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} -a ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} ${_hostonly_install:+-H} "$@"
 309         return $_ret
 310     fi
 311 }
 312
 313 dracut_install() {
 314     inst_multiple "$@"
 315 }
 316
 317 dracut_instmods() {
 318     local _ret _silent=0
 319     local i
 320     # shellcheck disable=SC2154
 321     [[ $no_kernel == yes ]] && return
 322     for i in "$@"; do
 323         [[ $i == "--silent" ]] && _silent=1
 324     done
 325
 326     if $DRACUT_INSTALL \
 327         ${dracutsysrootdir:+-r "$dracutsysrootdir"} \
 328         ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${hostonly:+-H} ${omit_drivers:+-N "$omit_drivers"} ${srcmods:+--kerneldir "$srcmods"} -m "$@"; then
 329         return 0
 330     else
 331         _ret=$?
 332         if ((_silent == 0)); then
 333             derror FAILED: "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${hostonly:+-H} ${omit_drivers:+-N "$omit_drivers"} ${srcmods:+--kerneldir "$srcmods"} -m "$@"
 334         fi
 335         return $_ret
 336     fi
 337 }
 338
 339 inst_library() {
 340     local _ret _hostonly_install
 341     if [[ $1 == "-H" ]]; then
 342         _hostonly_install="-H"
 343         shift
 344     fi
 345     [[ -e ${initdir}/"${2:-$1}" ]] && return 0 # already there
 346     [[ -e $1 ]] || return 1                    # no source
 347     if $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} ${_hostonly_install:+-H} "$@"; then
 348         return 0
 349     else
 350         _ret=$?
 351         derror FAILED: "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} ${_hostonly_install:+-H} "$@"
 352         return $_ret
 353     fi
 354 }
 355
 356 inst_binary() {
 357     local _ret
 358     if $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} "$@"; then
 359         return 0
 360     else
 361         _ret=$?
 362         derror FAILED: "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} "$@"
 363         return $_ret
 364     fi
 365 }
 366
 367 inst_script() {
 368     local _ret
 369     if $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} "$@"; then
 370         return 0
 371     else
 372         _ret=$?
 373         derror FAILED: "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} "$@"
 374         return $_ret
 375     fi
 376 }
 377
 378 inst_fsck_help() {
 379     local _ret _helper="/run/dracut/fsck/fsck_help_$1.txt"
 380     if $DRACUT_INSTALL ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} "$2" "$_helper"; then
 381         return 0
 382     else
 383         _ret=$?
 384         derror "$DRACUT_INSTALL" ${dracutsysrootdir:+-r "$dracutsysrootdir"} ${initdir:+-D "$initdir"} ${loginstall:+-L "$loginstall"} ${DRACUT_RESOLVE_DEPS:+-l} ${DRACUT_FIPS_MODE:+-f} "$2" "$_helper"
 385         return $_ret
 386     fi
 387 }
 388
 389 # Use with form hostonly="$(optional_hostonly)" inst_xxxx <args>
 390 # If hostonly mode is set to "strict", hostonly restrictions will still
 391 # be applied, else will ignore hostonly mode and try to install all
 392 # given modules.
 393 optional_hostonly() {
 394     # shellcheck disable=SC2154
 395     if [[ $hostonly_mode == "strict" ]]; then
 396         printf -- "%s" "$hostonly"
 397     else
 398         printf ""
 399     fi
 400 }
 401
 402 mark_hostonly() {
 403     for i in "$@"; do
 404         echo "$i" >> "$initdir/lib/dracut/hostonly-files"
 405     done
 406 }
 407
 408 # find symlinks linked to given library file
 409 # $1 = library file
 410 # Function searches for symlinks by stripping version numbers appended to
 411 # library filename, checks if it points to the same target and finally
 412 # prints the list of symlinks to stdout.
 413 #
 414 # Example:
 415 # rev_lib_symlinks libfoo.so.8.1
 416 # output: libfoo.so.8 libfoo.so
 417 # (Only if libfoo.so.8 and libfoo.so exists on host system.)
 418 rev_lib_symlinks() {
 419     local _fn
 420     local _orig
 421     local _links
 422
 423     [[ ! $1 ]] && return 0
 424
 425     _fn="$1"
 426     _orig="$(readlink -f "$1")"
 427     _links=()
 428
 429     [[ ${_fn} == *.so.* ]] || return 1
 430
 431     until [[ ${_fn##*.} == so ]]; do
 432         _fn="${_fn%.*}"
 433         [[ -L ${_fn} ]] && [[ $(readlink -f "${_fn}") == "${_orig}" ]] && _links+=("${_fn}")
 434     done
 435
 436     echo "${_links[*]}}"
 437 }
 438
 439 # attempt to install any programs specified in a udev rule
 440 inst_rule_programs() {
 441     local _prog _bin
 442
 443     # shellcheck disable=SC2013
 444     for _prog in $(sed -nr 's/.*PROGRAM==?"([^ "]+).*/\1/p' "$1"); do
 445         _bin=""
 446         # shellcheck disable=SC2154
 447         if [[ -x ${udevdir}/$_prog ]]; then
 448             _bin="${udevdir}"/$_prog
 449         elif [[ ${_prog/\$env\{/} == "$_prog" ]]; then
 450             _bin=$(find_binary "$_prog") || {
 451                 dinfo "Skipping program $_prog using in udev rule ${1##*/} as it cannot be found"
 452                 continue
 453             }
 454         fi
 455
 456         [[ $_bin ]] && inst_binary "$_bin"
 457     done
 458
 459     # shellcheck disable=SC2013
 460     for _prog in $(sed -nr 's/.*RUN[+=]=?"([^ "]+).*/\1/p' "$1"); do
 461         _bin=""
 462         if [[ -x ${udevdir}/$_prog ]]; then
 463             _bin=${udevdir}/$_prog
 464         elif [[ ${_prog/\$env\{/} == "$_prog" ]] && [[ ${_prog} != "/sbin/initqueue" ]]; then
 465             _bin=$(find_binary "$_prog") || {
 466                 dinfo "Skipping program $_prog using in udev rule ${1##*/} as it cannot be found"
 467                 continue
 468             }
 469         fi
 470
 471         [[ $_bin ]] && inst_binary "$_bin"
 472     done
 473
 474     # shellcheck disable=SC2013
 475     for _prog in $(sed -nr 's/.*IMPORT\{program\}==?"([^ "]+).*/\1/p' "$1"); do
 476         _bin=""
 477         if [[ -x ${udevdir}/$_prog ]]; then
 478             _bin=${udevdir}/$_prog
 479         elif [[ ${_prog/\$env\{/} == "$_prog" ]]; then
 480             _bin=$(find_binary "$_prog") || {
 481                 dinfo "Skipping program $_prog using in udev rule ${1##*/} as it cannot be found"
 482                 continue
 483             }
 484         fi
 485
 486         [[ $_bin ]] && dracut_install "$_bin"
 487     done
 488 }
 489
 490 # attempt to create any groups and users specified in a udev rule
 491 inst_rule_group_owner() {
 492     local i
 493
 494     # shellcheck disable=SC2013
 495     for i in $(sed -nr 's/.*OWNER=?"([^ "]+).*/\1/p' "$1"); do
 496         if ! grep -Eq "^$i:" "$initdir/etc/passwd" 2> /dev/null; then
 497             grep -E "^$i:" "$dracutsysrootdir"/etc/passwd 2> /dev/null >> "$initdir/etc/passwd"
 498         fi
 499     done
 500
 501     # shellcheck disable=SC2013
 502     for i in $(sed -nr 's/.*GROUP=?"([^ "]+).*/\1/p' "$1"); do
 503         if ! grep -Eq "^$i:" "$initdir/etc/group" 2> /dev/null; then
 504             grep -E "^$i:" "$dracutsysrootdir"/etc/group 2> /dev/null >> "$initdir/etc/group"
 505         fi
 506     done
 507 }
 508
 509 inst_rule_initqueue() {
 510     if grep -q -F initqueue "$1"; then
 511         dracut_need_initqueue
 512     fi
 513 }
 514
 515 # udev rules always get installed in the same place, so
 516 # create a function to install them to make life simpler.
 517 inst_rules() {
 518     local _target=/etc/udev/rules.d _rule _found
 519
 520     inst_dir "${udevdir}/rules.d"
 521     inst_dir "$_target"
 522     for _rule in "$@"; do
 523         if [ "${_rule#/}" = "$_rule" ]; then
 524             for r in "$dracutsysrootdir${udevdir}/rules.d" ${hostonly:+"$dracutsysrootdir"/etc/udev/rules.d}; do
 525                 [[ -e $r/$_rule ]] || continue
 526                 _found="$r/$_rule"
 527                 inst_rule_programs "$_found"
 528                 inst_rule_group_owner "$_found"
 529                 inst_rule_initqueue "$_found"
 530                 inst_simple "$_found"
 531             done
 532         fi
 533         for r in '' "$dracutsysrootdir$dracutbasedir/rules.d/"; do
 534             # skip rules without an absolute path
 535             [[ "${r}$_rule" != /* ]] && continue
 536             [[ -f ${r}$_rule ]] || continue
 537             _found="${r}$_rule"
 538             inst_rule_programs "$_found"
 539             inst_rule_group_owner "$_found"
 540             inst_rule_initqueue "$_found"
 541             inst_simple "$_found" "$_target/${_found##*/}"
 542         done
 543         [[ $_found ]] || ddebug "Skipping udev rule: $_rule"
 544     done
 545 }
 546
 547 inst_rules_wildcard() {
 548     local _target=/etc/udev/rules.d _rule _found
 549
 550     inst_dir "${udevdir}/rules.d"
 551     inst_dir "$_target"
 552     for _rule in ${udevdir}/rules.d/$1 ${dracutbasedir}/rules.d/$1; do
 553         [[ -e $_rule ]] || continue
 554         inst_rule_programs "$_rule"
 555         inst_rule_group_owner "$_rule"
 556         inst_rule_initqueue "$_rule"
 557         inst_simple "$_rule"
 558         _found=$_rule
 559     done
 560     if [[ -n ${hostonly} ]]; then
 561         for _rule in ${_target}/$1; do
 562             [[ -f $_rule ]] || continue
 563             inst_rule_programs "$_rule"
 564             inst_rule_group_owner "$_rule"
 565             inst_rule_initqueue "$_rule"
 566             inst_simple "$_rule"
 567             _found=$_rule
 568         done
 569     fi
 570     [[ $_found ]] || ddebug "Skipping udev rule: $_rule"
 571 }
 572
 573 # make sure that library links are correct and up to date
 574 build_ld_cache() {
 575     for f in "$dracutsysrootdir"/etc/ld.so.conf "$dracutsysrootdir"/etc/ld.so.conf.d/*; do
 576         [[ -f $f ]] && inst_simple "${f#"$dracutsysrootdir"}"
 577     done
 578     if ! $DRACUT_LDCONFIG -r "$initdir" -f /etc/ld.so.conf; then
 579         if [[ $EUID == 0 ]]; then
 580             derror "ldconfig exited ungracefully"
 581         else
 582             derror "ldconfig might need uid=0 (root) for chroot()"
 583         fi
 584     fi
 585 }
 586
 587 prepare_udev_rules() {
 588     dwarn "prepare_udev_rules: deprecated and will be removed"
 589
 590     if [ -z "$UDEVVERSION" ]; then
 591         UDEVVERSION=$(udevadm --version)
 592         export UDEVVERSION
 593     fi
 594
 595     if [ -z "$UDEVVERSION" ]; then
 596         derror "Failed to detect udev version!"
 597         return 1
 598     fi
 599     if [ -z "${UDEVVERSION##*[!0-9]*}" ]; then
 600         derror "udevadm --version did not report an integer, udev version cannot be determined!"
 601         return 1
 602     fi
 603
 604     for f in "$@"; do
 605         f="${initdir}/etc/udev/rules.d/$f"
 606         [ -e "$f" ] || continue
 607         while read -r line || [ -n "$line" ]; do
 608             if [ "${line%%IMPORT PATH_ID}" != "$line" ]; then
 609                 if ((UDEVVERSION >= 174)); then
 610                     printf '%sIMPORT{builtin}="path_id"\n' "${line%%IMPORT PATH_ID}"
 611                 else
 612                     printf '%sIMPORT{program}="path_id %%p"\n' "${line%%IMPORT PATH_ID}"
 613                 fi
 614             elif [ "${line%%IMPORT BLKID}" != "$line" ]; then
 615                 if ((UDEVVERSION >= 176)); then
 616                     printf '%sIMPORT{builtin}="blkid"\n' "${line%%IMPORT BLKID}"
 617                 else
 618                     # shellcheck disable=SC2016
 619                     printf '%sIMPORT{program}="/sbin/blkid -o udev -p $tempnode"\n' "${line%%IMPORT BLKID}"
 620                 fi
 621             else
 622                 echo "$line"
 623             fi
 624         done < "${f}" > "${f}.new"
 625         mv "${f}.new" "$f"
 626     done
 627 }
 628
 629 # install function specialized for hooks
 630 # $1 = type of hook, $2 = hook priority (lower runs first), $3 = hook
 631 # All hooks should be POSIX/SuS compliant, they will be sourced by init.
 632 inst_hook() {
 633     local hook
 634     if ! [[ -f $3 ]]; then
 635         dfatal "Cannot install a hook ($3) that does not exist."
 636         dfatal "Aborting initrd creation."
 637         exit 1
 638     elif ! [[ $hookdirs == *$1* ]]; then
 639         dfatal "No such hook type $1. Aborting initrd creation."
 640         exit 1
 641     fi
 642     hook="/lib/dracut/hooks/${1}/${2}-${3##*/}"
 643     inst_simple "$3" "$hook"
 644     chmod u+x "$initdir/$hook"
 645 }
 646
 647 # install any of listed files
 648 #
 649 # If first argument is '-d' and second some destination path, first accessible
 650 # source is installed into this path, otherwise it will installed in the same
 651 # path as source.  If none of listed files was installed, function return 1.
 652 # On first successful installation it returns with 0 status.
 653 #
 654 # Example:
 655 #
 656 # inst_any -d /bin/foo /bin/bar /bin/baz
 657 #
 658 # Lets assume that /bin/baz exists, so it will be installed as /bin/foo in
 659 # initramfs.
 660 inst_any() {
 661     local to f
 662
 663     [[ $1 == '-d' ]] && to="$2" && shift 2
 664
 665     for f in "$@"; do
 666         [[ -e $f ]] || continue
 667         [[ $to ]] && inst "$f" "$to" && return 0
 668         inst "$f" && return 0
 669     done
 670
 671     return 1
 672 }
 673
 674 # inst_libdir_dir <dir> [<dir>...]
 675 # Install a <dir> located on a lib directory to the initramfs image
 676 inst_libdir_dir() {
 677     local -a _dirs
 678     for _dir in $libdirs; do
 679         for _i in "$@"; do
 680             for _d in "$dracutsysrootdir$_dir"/$_i; do
 681                 [[ -d $_d ]] && _dirs+=("${_d#"$dracutsysrootdir"}")
 682             done
 683         done
 684     done
 685     for _dir in "${_dirs[@]}"; do
 686         inst_dir "$_dir"
 687     done
 688 }
 689
 690 # inst_libdir_file [-n <pattern>] <file> [<file>...]
 691 # Install a <file> located on a lib directory to the initramfs image
 692 # -n <pattern> install matching files
 693 inst_libdir_file() {
 694     local -a _files
 695     if [[ $1 == "-n" ]]; then
 696         local _pattern=$2
 697         shift 2
 698         for _dir in $libdirs; do
 699             for _i in "$@"; do
 700                 for _f in "$dracutsysrootdir$_dir"/$_i; do
 701                     [[ ${_f#"$dracutsysrootdir"} =~ $_pattern ]] || continue
 702                     [[ -e $_f ]] && _files+=("${_f#"$dracutsysrootdir"}")
 703                 done
 704             done
 705         done
 706     else
 707         for _dir in $libdirs; do
 708             for _i in "$@"; do
 709                 for _f in "$dracutsysrootdir$_dir"/$_i; do
 710                     [[ -e $_f ]] && _files+=("${_f#"$dracutsysrootdir"}")
 711                 done
 712             done
 713         done
 714     fi
 715     [[ ${#_files[@]} -gt 0 ]] && inst_multiple "${_files[@]}"
 716 }
 717
 718 # get a command to decompress the given file
 719 get_decompress_cmd() {
 720     case "$1" in
 721         *.gz) echo 'gzip -f -d' ;;
 722         *.bz2) echo 'bzip2 -d' ;;
 723         *.xz) echo 'xz -f -d' ;;
 724         *.zst) echo 'zstd -f -d ' ;;
 725     esac
 726 }
 727
 728 # install function decompressing the target and handling symlinks
 729 # $@ = list of compressed (gz or bz2) files or symlinks pointing to such files
 730 #
 731 # Function install targets in the same paths inside overlay but decompressed
 732 # and without extensions (.gz, .bz2).
 733 inst_decompress() {
 734     local _src _cmd
 735
 736     for _src in "$@"; do
 737         _cmd=$(get_decompress_cmd "${_src}")
 738         [[ -z ${_cmd} ]] && return 1
 739         inst_simple "${_src}"
 740         # Decompress with chosen tool.  We assume that tool changes name e.g.
 741         # from 'name.gz' to 'name'.
 742         ${_cmd} "${initdir}${_src}"
 743     done
 744 }
 745
 746 # It's similar to above, but if file is not compressed, performs standard
 747 # install.
 748 # $@ = list of files
 749 inst_opt_decompress() {
 750     local _src
 751
 752     for _src in "$@"; do
 753         inst_decompress "${_src}" || inst "${_src}"
 754     done
 755 }
 756
 757 # module_check <dracut module> [<forced>] [<module path>]
 758 # execute the check() function of module-setup.sh of <dracut module>
 759 # or the "check" script, if module-setup.sh is not found
 760 # "check $hostonly" is called
 761 module_check() {
 762     local _moddir=$3
 763     local _ret
 764     local _forced=0
 765     local _hostonly=$hostonly
 766     [[ -z $_moddir ]] && _moddir=$(dracut_module_path "$1")
 767     [ $# -ge 2 ] && _forced=$2
 768     [[ -f $_moddir/module-setup.sh ]] || return 1
 769     unset check depends cmdline install installkernel
 770     check() { true; }
 771     # shellcheck disable=SC1090
 772     . "$_moddir"/module-setup.sh
 773     is_func check || return 0
 774     [[ $_forced != 0 ]] && unset hostonly
 775     # don't quote $hostonly to leave argument empty
 776     # shellcheck disable=SC2086
 777     moddir="$_moddir" check $hostonly
 778     _ret=$?
 779     unset check depends cmdline install installkernel
 780     hostonly=$_hostonly
 781     return $_ret
 782 }
 783
 784 # module_check_mount <dracut module> [<module path>]
 785 # execute the check() function of module-setup.sh of <dracut module>
 786 # or the "check" script, if module-setup.sh is not found
 787 # "mount_needs=1 check 0" is called
 788 module_check_mount() {
 789     local _moddir=$2
 790     local _ret
 791     export mount_needs=1
 792     [[ -z $_moddir ]] && _moddir=$(dracut_module_path "$1")
 793     [[ -f $_moddir/module-setup.sh ]] || return 1
 794     unset check depends cmdline install installkernel
 795     check() { false; }
 796     # shellcheck disable=SC1090
 797     . "$_moddir"/module-setup.sh
 798     moddir=$_moddir check 0
 799     _ret=$?
 800     unset check depends cmdline install installkernel
 801     unset mount_needs
 802     return "$_ret"
 803 }
 804
 805 # module_depends <dracut module> [<module path>]
 806 # execute the depends() function of module-setup.sh of <dracut module>
 807 # or the "depends" script, if module-setup.sh is not found
 808 module_depends() {
 809     local _moddir=$2
 810     local _ret
 811     [[ -z $_moddir ]] && _moddir=$(dracut_module_path "$1")
 812     [[ -f $_moddir/module-setup.sh ]] || return 1
 813     unset check depends cmdline install installkernel
 814     depends() { true; }
 815     # shellcheck disable=SC1090
 816     . "$_moddir"/module-setup.sh
 817     moddir=$_moddir depends
 818     _ret=$?
 819     unset check depends cmdline install installkernel
 820     return $_ret
 821 }
 822
 823 # module_cmdline <dracut module> [<module path>]
 824 # execute the cmdline() function of module-setup.sh of <dracut module>
 825 # or the "cmdline" script, if module-setup.sh is not found
 826 module_cmdline() {
 827     local _moddir=$2
 828     local _ret
 829     [[ -z $_moddir ]] && _moddir=$(dracut_module_path "$1")
 830     [[ -f $_moddir/module-setup.sh ]] || return 1
 831     unset check depends cmdline install installkernel
 832     cmdline() { true; }
 833     # shellcheck disable=SC1090
 834     . "$_moddir"/module-setup.sh
 835     moddir="$_moddir" cmdline
 836     _ret=$?
 837     unset check depends cmdline install installkernel
 838     return $_ret
 839 }
 840
 841 # module_install <dracut module> [<module path>]
 842 # execute the install() function of module-setup.sh of <dracut module>
 843 # or the "install" script, if module-setup.sh is not found
 844 module_install() {
 845     local _moddir=$2
 846     local _ret
 847     [[ -z $_moddir ]] && _moddir=$(dracut_module_path "$1")
 848     [[ -f $_moddir/module-setup.sh ]] || return 1
 849     unset check depends cmdline install installkernel
 850     install() { true; }
 851     # shellcheck disable=SC1090
 852     . "$_moddir"/module-setup.sh
 853     moddir="$_moddir" install
 854     _ret=$?
 855     unset check depends cmdline install installkernel
 856     return $_ret
 857 }
 858
 859 # module_installkernel <dracut module> [<module path>]
 860 # execute the installkernel() function of module-setup.sh of <dracut module>
 861 # or the "installkernel" script, if module-setup.sh is not found
 862 module_installkernel() {
 863     local _moddir=$2
 864     local _ret
 865     [[ -z $_moddir ]] && _moddir=$(dracut_module_path "$1")
 866     [[ -f $_moddir/module-setup.sh ]] || return 1
 867     unset check depends cmdline install installkernel
 868     installkernel() { true; }
 869     # shellcheck disable=SC1090
 870     . "$_moddir"/module-setup.sh
 871     moddir="$_moddir" installkernel
 872     _ret=$?
 873     unset check depends cmdline install installkernel
 874     return $_ret
 875 }
 876
 877 # check_mount <dracut module> [<use_as_dep>] [<module path>]
 878 # check_mount checks, if a dracut module is needed for the given
 879 # device and filesystem types in "${host_fs_types[@]}"
 880 check_mount() {
 881     local _mod=$1
 882     local _moddir=$3
 883     local _ret
 884     local _moddep
 885
 886     [[ -z $_moddir ]] && _moddir=$(dracut_module_path "$1")
 887     # shellcheck disable=SC2154
 888     [ "${#host_fs_types[@]}" -le 0 ] && return 1
 889
 890     # If we are already scheduled to be loaded, no need to check again.
 891     [[ " $mods_to_load " == *\ $_mod\ * ]] && return 0
 892     [[ " $mods_checked_as_dep " == *\ $_mod\ * ]] && return 1
 893
 894     # This should never happen, but...
 895     [[ -d $_moddir ]] || return 1
 896
 897     [[ $2 ]] || mods_checked_as_dep+=" $_mod "
 898
 899     # shellcheck disable=SC2154
 900     if [[ " $omit_dracutmodules " == *\ $_mod\ * ]]; then
 901         return 1
 902     fi
 903
 904     if [[ " $dracutmodules $add_dracutmodules $force_add_dracutmodules" == *\ $_mod\ * ]]; then
 905         module_check_mount "$_mod" "$_moddir"
 906         _ret=$?
 907
 908         # explicit module, so also accept _ret=255
 909         [[ $_ret == 0 || $_ret == 255 ]] || return 1
 910     else
 911         # module not in our list
 912         if [[ $dracutmodules == all ]]; then
 913             # check, if we can and should install this module
 914             module_check_mount "$_mod" "$_moddir" || return 1
 915         else
 916             # skip this module
 917             return 1
 918         fi
 919     fi
 920
 921     for _moddep in $(module_depends "$_mod" "$_moddir"); do
 922         # handle deps as if they were manually added
 923         [[ " $dracutmodules " == *\ $_mod\ * ]] \
 924             && [[ " $dracutmodules " != *\ $_moddep\ * ]] \
 925             && dracutmodules+=" $_moddep "
 926         [[ " $add_dracutmodules " == *\ $_mod\ * ]] \
 927             && [[ " $add_dracutmodules " != *\ $_moddep\ * ]] \
 928             && add_dracutmodules+=" $_moddep "
 929         [[ " $force_add_dracutmodules " == *\ $_mod\ * ]] \
 930             && [[ " $force_add_dracutmodules " != *\ $_moddep\ * ]] \
 931             && force_add_dracutmodules+=" $_moddep "
 932         # if a module we depend on fail, fail also
 933         if ! check_module "$_moddep"; then
 934             derror "Module '$_mod' depends on '$_moddep', which can't be installed"
 935             return 1
 936         fi
 937     done
 938
 939     [[ " $mods_to_load " == *\ $_mod\ * ]] \
 940         || mods_to_load+=" $_mod "
 941
 942     return 0
 943 }
 944
 945 # check_module <dracut module> [<use_as_dep>] [<module path>]
 946 # check if a dracut module is to be used in the initramfs process
 947 # if <use_as_dep> is set, then the process also keeps track
 948 # that the modules were checked for the dependency tracking process
 949 check_module() {
 950     local _mod=$1
 951     local _moddir=$3
 952     local _ret
 953     local _moddep
 954
 955     [[ -z $_moddir ]] && _moddir=$(dracut_module_path "$1")
 956     # If we are already scheduled to be loaded, no need to check again.
 957     [[ " $mods_to_load " == *\ $_mod\ * ]] && return 0
 958     [[ " $mods_checked_as_dep " == *\ $_mod\ * ]] && return 1
 959
 960     # This should never happen, but...
 961     [[ -d $_moddir ]] || return 1
 962
 963     [[ $2 ]] || mods_checked_as_dep+=" $_mod "
 964
 965     if [[ " $omit_dracutmodules " == *\ $_mod\ * ]]; then
 966         ddebug "Module '$_mod' will not be installed, because it's in the list to be omitted!"
 967         return 1
 968     fi
 969
 970     if [[ " $dracutmodules $add_dracutmodules $force_add_dracutmodules" == *\ $_mod\ * ]]; then
 971         if [[ " $dracutmodules $force_add_dracutmodules " == *\ $_mod\ * ]]; then
 972             module_check "$_mod" 1 "$_moddir"
 973             _ret=$?
 974         else
 975             module_check "$_mod" 0 "$_moddir"
 976             _ret=$?
 977         fi
 978         # explicit module, so also accept _ret=255
 979         [[ $_ret == 0 || $_ret == 255 ]] || return 1
 980     else
 981         # module not in our list
 982         if [[ $dracutmodules == all ]]; then
 983             # check, if we can and should install this module
 984             module_check "$_mod" 0 "$_moddir"
 985             _ret=$?
 986             if [[ $_ret != 0 ]]; then
 987                 [[ $2 ]] && return 1
 988                 [[ $_ret != 255 ]] && return 1
 989             fi
 990         else
 991             # skip this module
 992             return 1
 993         fi
 994     fi
 995
 996     for _moddep in $(module_depends "$_mod" "$_moddir"); do
 997         # handle deps as if they were manually added
 998         [[ " $dracutmodules " == *\ $_mod\ * ]] \
 999             && [[ " $dracutmodules " != *\ $_moddep\ * ]] \
1000             && dracutmodules+=" $_moddep "
1001         [[ " $add_dracutmodules " == *\ $_mod\ * ]] \
1002             && [[ " $add_dracutmodules " != *\ $_moddep\ * ]] \
1003             && add_dracutmodules+=" $_moddep "
1004         [[ " $force_add_dracutmodules " == *\ $_mod\ * ]] \
1005             && [[ " $force_add_dracutmodules " != *\ $_moddep\ * ]] \
1006             && force_add_dracutmodules+=" $_moddep "
1007         # if a module we depend on fail, fail also
1008         if ! check_module "$_moddep"; then
1009             derror "Module '$_mod' depends on '$_moddep', which can't be installed"
1010             return 1
1011         fi
1012     done
1013
1014     [[ " $mods_to_load " == *\ $_mod\ * ]] \
1015         || mods_to_load+=" $_mod "
1016
1017     return 0
1018 }
1019
1020 # for_each_module_dir <func>
1021 # execute "<func> <dracut module> 1 <module path>"
1022 for_each_module_dir() {
1023     local _modcheck
1024     local _mod
1025     local _moddir
1026     local _func
1027     local _reason
1028     _func=$1
1029     for _moddir in "$dracutbasedir/modules.d"/[0-9][0-9]*; do
1030         [[ -e $_moddir/module-setup.sh ]] || continue
1031         _mod=${_moddir##*/}
1032         _mod=${_mod#[0-9][0-9]}
1033         $_func "$_mod" 1 "$_moddir"
1034     done
1035
1036     # Report any missing dracut modules, the user has specified
1037     _modcheck="$add_dracutmodules $force_add_dracutmodules"
1038     [[ $dracutmodules != all ]] && _modcheck="$_modcheck $dracutmodules"
1039     for _mod in $_modcheck; do
1040         [[ " $mods_to_load " == *\ $_mod\ * ]] && continue
1041
1042         [[ " $force_add_dracutmodules " != *\ $_mod\ * ]] \
1043             && [[ " $dracutmodules " != *\ $_mod\ * ]] \
1044             && [[ " $omit_dracutmodules " == *\ $_mod\ * ]] \
1045             && continue
1046
1047         [[ -d $(echo "$dracutbasedir/modules.d"/[0-9][0-9]"$_mod") ]] \
1048             && _reason="installed" \
1049             || _reason="found"
1050         derror "Module '$_mod' cannot be $_reason."
1051         [[ " $force_add_dracutmodules " == *\ $_mod\ * ]] && exit 1
1052         [[ " $dracutmodules " == *\ $_mod\ * ]] && exit 1
1053         [[ " $add_dracutmodules " == *\ $_mod\ * ]] && exit 1
1054     done
1055 }
1056
1057 dracut_kernel_post() {
1058     for _f in modules.builtin modules.builtin.alias modules.builtin.modinfo modules.order; do
1059         [[ -e $srcmods/$_f ]] && inst_simple "$srcmods/$_f" "/lib/modules/$kernel/$_f"
1060     done
1061
1062     # generate module dependencies for the initrd
1063     if [[ -d $initdir/lib/modules/$kernel ]] \
1064         && ! depmod -a -b "$initdir" "$kernel"; then
1065         dfatal "\"depmod -a $kernel\" failed."
1066         exit 1
1067     fi
1068
1069 }
1070
1071 instmods() {
1072     # instmods [-c [-s]] <kernel module> [<kernel module> ... ]
1073     # instmods [-c [-s]] <kernel subsystem>
1074     # install kernel modules along with all their dependencies.
1075     # <kernel subsystem> can be e.g. "=block" or "=drivers/usb/storage"
1076     # -c check
1077     # -s silent
1078     local _optional="-o"
1079     local _silent
1080     local _ret
1081
1082     [[ $no_kernel == yes ]] && return
1083
1084     if [[ $1 == '-c' ]]; then
1085         unset _optional
1086         shift
1087     fi
1088     if [[ $1 == '-s' ]]; then
1089         _silent=1
1090         shift
1091     fi
1092
1093     if (($# == 0)); then
1094         read -r -d '' -a args
1095         set -- "${args[@]}"
1096     fi
1097
1098     if (($# == 0)); then
1099         return 0
1100     fi
1101
1102     $DRACUT_INSTALL \
1103         ${initdir:+-D "$initdir"} \
1104         ${dracutsysrootdir:+-r "$dracutsysrootdir"} \
1105         ${loginstall:+-L "$loginstall"} \
1106         ${hostonly:+-H} \
1107         ${omit_drivers:+-N "$omit_drivers"} \
1108         ${srcmods:+--kerneldir "$srcmods"} \
1109         ${_optional:+-o} \
1110         ${_silent:+--silent} \
1111         -m "$@"
1112     _ret=$?
1113
1114     if ((_ret != 0)) && [[ -z $_silent ]]; then
1115         derror "FAILED: " \
1116             "$DRACUT_INSTALL" \
1117             ${initdir:+-D "$initdir"} \
1118             ${dracutsysrootdir:+-r "$dracutsysrootdir"} \
1119             ${loginstall:+-L "$loginstall"} \
1120             ${hostonly:+-H} \
1121             ${omit_drivers:+-N "$omit_drivers"} \
1122             ${srcmods:+--kerneldir "$srcmods"} \
1123             ${_optional:+-o} \
1124             ${_silent:+--silent} \
1125             -m "$@"
1126     fi
1127
1128     [[ "$_optional" ]] && return 0
1129     return $_ret
1130 }
1131
1132 if [[ "$(ln --help)" == *--relative* ]]; then
1133     ln_r() {
1134         ln -sfnr "${initdir}/$1" "${initdir}/$2"
1135     }
1136 else
1137     ln_r() {
1138         local _source=$1
1139         local _dest=$2
1140         [[ -d ${_dest%/*} ]] && _dest=$(readlink -f "${_dest%/*}")/${_dest##*/}
1141         ln -sfn -- "$(convert_abs_rel "${_dest}" "${_source}")" "${initdir}/${_dest}"
1142     }
1143 fi
1144
1145 is_qemu_virtualized() {
1146     # 0 if a virt environment was detected
1147     # 1 if a virt environment could not be detected
1148     # 255 if any error was encountered
1149     if type -P systemd-detect-virt > /dev/null 2>&1; then
1150         if ! vm=$(systemd-detect-virt --vm 2> /dev/null); then
1151             return 255
1152         fi
1153         [[ $vm == "qemu" ]] && return 0
1154         [[ $vm == "kvm" ]] && return 0
1155         [[ $vm == "bochs" ]] && return 0
1156     fi
1157
1158     for i in /sys/class/dmi/id/*_vendor; do
1159         [[ -f $i ]] || continue
1160         read -r vendor < "$i"
1161         [[ $vendor == "QEMU" ]] && return 0
1162         [[ $vendor == "Red Hat" ]] && return 0
1163         [[ $vendor == "Bochs" ]] && return 0
1164     done
1165     return 1
1166 }