test/test-functions

   1 #!/bin/bash
   2 # -*- mode: shell-script; indent-tabs-mode: nil; sh-basic-offset: 4; -*-
   3 # ex: ts=8 sw=4 sts=4 et filetype=sh
   4 PATH=/sbin:/bin:/usr/sbin:/usr/bin
   5 export PATH
   6
   7 KERNEL_VER=${KERNEL_VER-$(uname -r)}
   8 KERNEL_MODS="/lib/modules/$KERNEL_VER/"
   9
  10 if ! ROOTLIBDIR=$(pkg-config --variable=systemdutildir systemd); then
  11     echo "WARNING! Cannot determine rootlibdir from pkg-config, assuming /usr/lib/systemd" >&2
  12     ROOTLIBDIR=/usr/lib/systemd
  13 fi
  14
  15 BASICTOOLS="sh bash setsid loadkeys setfont login sulogin gzip sleep echo mount umount cryptsetup date dmsetup modprobe"
  16 DEBUGTOOLS="df free ls stty cat ps ln ip route dmesg dhclient mkdir cp ping dhclient strace less grep id tty touch du sort hostname"
  17
  18 function find_qemu_bin() {
  19     # SUSE and Red Hat call the binary qemu-kvm
  20     # Debian and Gentoo call it kvm
  21     [ "$QEMU_BIN" ] || QEMU_BIN=$(which -a kvm qemu-kvm 2>/dev/null | grep '^/' -m1)
  22
  23     [ "$ARCH" ] || ARCH=$(uname -m)
  24     case $ARCH in
  25     x86_64)
  26         # QEMU's own build system calls it qemu-system-x86_64
  27         [ "$QEMU_BIN" ] || QEMU_BIN=$(which -a qemu-system-x86_64 2>/dev/null | grep '^/' -m1)
  28         ;;
  29     i*86)
  30         # new i386 version of QEMU
  31         [ "$QEMU_BIN" ] || QEMU_BIN=$(which -a qemu-system-i386 2>/dev/null | grep '^/' -m1)
  32
  33         # i386 version of QEMU
  34         [ "$QEMU_BIN" ] || QEMU_BIN=$(which -a qemu 2>/dev/null | grep '^/' -m1)
  35         ;;
  36     esac
  37
  38     if [ ! -e "$QEMU_BIN" ]; then
  39         echo "Could not find a suitable QEMU binary" >&2
  40         return 1
  41     fi
  42 }
  43
  44 run_qemu() {
  45     if [ -f /etc/machine-id ]; then
  46         read MACHINE_ID < /etc/machine-id
  47         [ -z "$INITRD" ] && [ -e "/boot/$MACHINE_ID/$KERNEL_VER/initrd" ] \
  48             && INITRD="/boot/$MACHINE_ID/$KERNEL_VER/initrd"
  49         [ -z "$KERNEL_BIN" ] && [ -e "/boot/$MACHINE_ID/$KERNEL_VER/linux" ] \
  50             && KERNEL_BIN="/boot/$MACHINE_ID/$KERNEL_VER/linux"
  51     fi
  52
  53     [ "$KERNEL_BIN" ] || KERNEL_BIN=/boot/vmlinuz-$KERNEL_VER
  54     [ "$INITRD" ]     || INITRD=/boot/initramfs-${KERNEL_VER}.img
  55     [ "$QEMU_SMP" ]   || QEMU_SMP=1
  56
  57     find_qemu_bin || return 1
  58
  59     KERNEL_APPEND="root=/dev/sda1 \
  60 systemd.log_level=debug \
  61 raid=noautodetect \
  62 loglevel=2 \
  63 init=$ROOTLIBDIR/systemd \
  64 ro \
  65 console=ttyS0 \
  66 selinux=0 \
  67 $KERNEL_APPEND \
  68 "
  69
  70     QEMU_OPTIONS="-machine accel=kvm:tcg \
  71 -smp $QEMU_SMP \
  72 -net none \
  73 -m 512M \
  74 -nographic \
  75 -kernel $KERNEL_BIN \
  76 "
  77
  78     if [ "$INITRD" ]; then
  79         QEMU_OPTIONS="$QEMU_OPTIONS -initrd $INITRD"
  80     fi
  81
  82     ( set -x
  83       $QEMU_BIN $QEMU_OPTIONS -append "$KERNEL_APPEND" $TESTDIR/rootdisk.img ) || return 1
  84 }
  85
  86 run_nspawn() {
  87     set -x
  88     ../../systemd-nspawn --boot --directory=$TESTDIR/nspawn-root $ROOTLIBDIR/systemd $KERNEL_APPEND
  89 }
  90
  91 setup_basic_environment() {
  92     # create the basic filesystem layout
  93     setup_basic_dirs
  94
  95     install_systemd
  96     install_missing_libraries
  97     install_config_files
  98     create_rc_local
  99     install_basic_tools
 100     install_libnss
 101     install_pam
 102     install_dbus
 103     install_fonts
 104     install_keymaps
 105     install_terminfo
 106     install_execs
 107     install_plymouth
 108     install_debug_tools
 109     install_ld_so_conf
 110     strip_binaries
 111     install_depmod_files
 112     generate_module_dependencies
 113     # softlink mtab
 114     ln -fs /proc/self/mounts $initdir/etc/mtab
 115 }
 116
 117 install_dmevent() {
 118     instmods dm_crypt =crypto
 119     type -P dmeventd >/dev/null && dracut_install dmeventd
 120     inst_libdir_file "libdevmapper-event.so*"
 121     inst_rules 10-dm.rules 13-dm-disk.rules 95-dm-notify.rules
 122 }
 123
 124 install_systemd() {
 125     # install compiled files
 126     (cd $TEST_BASE_DIR/..; set -x; make DESTDIR=$initdir install)
 127     # remove unneeded documentation
 128     rm -fr $initdir/usr/share/{man,doc,gtk-doc}
 129     # we strip binaries since debug symbols increase binaries size a lot
 130     # and it could fill the available space
 131     strip_binaries
 132 }
 133
 134 install_missing_libraries() {
 135     # install possible missing libraries
 136     for i in $initdir/{sbin,bin}/* $initdir/lib/systemd/*; do
 137         inst_libs $i
 138     done
 139 }
 140
 141 create_empty_image() {
 142     rm -f "$TESTDIR/rootdisk.img"
 143     # Create the blank file to use as a root filesystem
 144     dd if=/dev/null of="$TESTDIR/rootdisk.img" bs=1M seek=300
 145     LOOPDEV=$(losetup --show -P -f $TESTDIR/rootdisk.img)
 146     [ -b "$LOOPDEV" ] || return 1
 147     echo "LOOPDEV=$LOOPDEV" >> $STATEFILE
 148     sfdisk "$LOOPDEV" <<EOF
 149 ,290M
 150 ,
 151 EOF
 152
 153     mkfs.ext3 -L systemd "${LOOPDEV}p1"
 154 }
 155
 156 check_result_nspawn() {
 157     ret=1
 158     [[ -e $TESTDIR/nspawn-root/testok ]] && ret=0
 159     [[ -f $TESTDIR/nspawn-root/failed ]] && cp -a $TESTDIR/nspawn-root/failed $TESTDIR
 160     cp -a $TESTDIR/nspawn-root/var/log/journal $TESTDIR
 161     [[ -f $TESTDIR/failed ]] && cat $TESTDIR/failed
 162     ls -l $TESTDIR/journal/*/*.journal
 163     test -s $TESTDIR/failed && ret=$(($ret+1))
 164     return $ret
 165 }
 166
 167 strip_binaries() {
 168     ddebug "Strip binaries"
 169     find "$initdir" -executable -not -path '*/lib/modules/*.ko' -type f | xargs strip --strip-unneeded | ddebug
 170 }
 171
 172 create_rc_local() {
 173     mkdir -p $initdir/etc/rc.d
 174     cat >$initdir/etc/rc.d/rc.local <<EOF
 175 #!/bin/bash
 176 exit 0
 177 EOF
 178     chmod 0755 $initdir/etc/rc.d/rc.local
 179 }
 180
 181 install_execs() {
 182     # install any Execs from the service files
 183     egrep -ho '^Exec[^ ]*=[^ ]+' $initdir/lib/systemd/system/*.service \
 184         | while read i; do
 185         i=${i##Exec*=}; i=${i##-}
 186         inst $i
 187     done
 188 }
 189
 190 generate_module_dependencies() {
 191     if [[ -d $initdir/lib/modules/$KERNEL_VER ]] && \
 192         ! depmod -a -b "$initdir" $KERNEL_VER; then
 193             dfatal "\"depmod -a $KERNEL_VER\" failed."
 194             exit 1
 195     fi
 196 }
 197
 198 install_depmod_files() {
 199     inst /lib/modules/$KERNEL_VER/modules.order
 200     inst /lib/modules/$KERNEL_VER/modules.builtin
 201 }
 202
 203 install_plymouth() {
 204     # install plymouth, if found... else remove plymouth service files
 205     # if [ -x /usr/libexec/plymouth/plymouth-populate-initrd ]; then
 206     #     PLYMOUTH_POPULATE_SOURCE_FUNCTIONS="$TEST_BASE_DIR/test-functions" \
 207     #         /usr/libexec/plymouth/plymouth-populate-initrd -t $initdir
 208     #         dracut_install plymouth plymouthd
 209     # else
 210         rm -f $initdir/{usr/lib,etc}/systemd/system/plymouth* $initdir/{usr/lib,etc}/systemd/system/*/plymouth*
 211     # fi
 212 }
 213
 214 install_ld_so_conf() {
 215     cp -a /etc/ld.so.conf* $initdir/etc
 216     ldconfig -r "$initdir"
 217 }
 218
 219 install_config_files() {
 220     inst /etc/sysconfig/init
 221     inst /etc/passwd
 222     inst /etc/shadow
 223     inst /etc/group
 224     inst /etc/shells
 225     inst /etc/nsswitch.conf
 226     inst /etc/pam.conf
 227     inst /etc/securetty
 228     inst /etc/os-release
 229     inst /etc/localtime
 230     # we want an empty environment
 231     > $initdir/etc/environment
 232     > $initdir/etc/machine-id
 233     # set the hostname
 234     echo systemd-testsuite > $initdir/etc/hostname
 235     # fstab
 236     cat >$initdir/etc/fstab <<EOF
 237 LABEL=systemd           /       ext3    rw 0 1
 238 EOF
 239 }
 240
 241 install_basic_tools() {
 242     [[ $BASICTOOLS ]] && dracut_install $BASICTOOLS
 243     dracut_install -o sushell
 244     # in Debian ldconfig is just a shell script wrapper around ldconfig.real
 245     dracut_install -o ldconfig.real
 246 }
 247
 248 install_debug_tools() {
 249     [[ $DEBUGTOOLS ]] && dracut_install $DEBUGTOOLS
 250 }
 251
 252 install_libnss() {
 253     # install libnss_files for login
 254     NSS_LIBS=$(LD_DEBUG=files getent passwd 2>&1 >/dev/null |sed -n '/calling init: .*libnss_/ {s!^.* /!/!; p}')
 255     dracut_install $NSS_LIBS
 256 }
 257
 258 install_dbus() {
 259     inst $ROOTLIBDIR/system/dbus.socket
 260     inst $ROOTLIBDIR/system/dbus.service
 261
 262     find \
 263         /etc/dbus-1 -xtype f \
 264         | while read file; do
 265         inst $file
 266     done
 267 }
 268
 269 install_pam() {
 270     find \
 271         /etc/pam.d \
 272         /etc/security \
 273         /lib64/security \
 274         /lib/security -xtype f \
 275         | while read file; do
 276         inst $file
 277     done
 278 }
 279
 280 install_keymaps() {
 281     for i in \
 282         /usr/lib/kbd/keymaps/include/* \
 283         /usr/lib/kbd/keymaps/i386/include/* \
 284         /usr/lib/kbd/keymaps/i386/qwerty/us.*; do
 285             [[ -f $i ]] || continue
 286             inst $i
 287     done
 288 }
 289
 290 install_fonts() {
 291     for i in \
 292         /usr/lib/kbd/consolefonts/eurlatgr* \
 293         /usr/lib/kbd/consolefonts/latarcyrheb-sun16*; do
 294             [[ -f $i ]] || continue
 295             inst $i
 296     done
 297 }
 298
 299 install_terminfo() {
 300     for _terminfodir in /lib/terminfo /etc/terminfo /usr/share/terminfo; do
 301         [ -f ${_terminfodir}/l/linux ] && break
 302     done
 303     dracut_install -o ${_terminfodir}/l/linux
 304 }
 305
 306 setup_testsuite() {
 307     cp $TEST_BASE_DIR/testsuite.target $initdir/etc/systemd/system/
 308     sed "s#@SYSTEMCTL@#$(type -P systemctl)#g" $TEST_BASE_DIR/end.service.in > $initdir/etc/systemd/system/end.service
 309
 310     mkdir -p $initdir/etc/systemd/system/testsuite.target.wants
 311     ln -fs $TEST_BASE_DIR/testsuite.service $initdir/etc/systemd/system/testsuite.target.wants/testsuite.service
 312     ln -fs $TEST_BASE_DIR/end.service $initdir/etc/systemd/system/testsuite.target.wants/end.service
 313
 314     # make the testsuite the default target
 315     ln -fs testsuite.target $initdir/etc/systemd/system/default.target
 316 }
 317
 318 setup_nspawn_root() {
 319     rm -fr $TESTDIR/nspawn-root
 320     ddebug "cp -ar $initdir $TESTDIR/nspawn-root"
 321     cp -ar $initdir $TESTDIR/nspawn-root
 322     # we don't mount in the nspawn root
 323     rm -f $TESTDIR/nspawn-root/etc/fstab
 324 }
 325
 326 setup_basic_dirs() {
 327     mkdir -p $initdir/run
 328     mkdir -p $initdir/etc/systemd/system
 329     mkdir -p $initdir/var/log/journal
 330
 331     for d in usr/bin usr/sbin bin etc lib "$libdir" sbin tmp usr var var/log dev proc sys sysroot root run run/lock run/initramfs; do
 332         if [ -L "/$d" ]; then
 333             inst_symlink "/$d"
 334         else
 335             inst_dir "/$d"
 336         fi
 337     done
 338
 339     ln -sfn /run "$initdir/var/run"
 340     ln -sfn /run/lock "$initdir/var/lock"
 341 }
 342
 343 inst_libs() {
 344     local _bin=$1
 345     local _so_regex='([^ ]*/lib[^/]*/[^ ]*\.so[^ ]*)'
 346     local _file _line
 347
 348     LC_ALL=C ldd "$_bin" 2>/dev/null | while read _line; do
 349         [[ $_line = 'not a dynamic executable' ]] && break
 350
 351         if [[ $_line =~ $_so_regex ]]; then
 352             _file=${BASH_REMATCH[1]}
 353             [[ -e ${initdir}/$_file ]] && continue
 354             inst_library "$_file"
 355             continue
 356         fi
 357
 358         if [[ $_line =~ not\ found ]]; then
 359             dfatal "Missing a shared library required by $_bin."
 360             dfatal "Run \"ldd $_bin\" to find out what it is."
 361             dfatal "$_line"
 362             dfatal "dracut cannot create an initrd."
 363             exit 1
 364         fi
 365     done
 366 }
 367
 368 import_testdir() {
 369     STATEFILE=".testdir"
 370     [[ -e $STATEFILE ]] && . $STATEFILE
 371     if [[ -z "$TESTDIR" ]] || [[ ! -d "$TESTDIR" ]]; then
 372         TESTDIR=$(mktemp --tmpdir=/var/tmp -d -t systemd-test.XXXXXX)
 373         echo "TESTDIR=\"$TESTDIR\"" > $STATEFILE
 374         export TESTDIR
 375     fi
 376 }
 377
 378 import_initdir() {
 379     initdir=$TESTDIR/root
 380     export initdir
 381 }
 382
 383 ## @brief Converts numeric logging level to the first letter of level name.
 384 #
 385 # @param lvl Numeric logging level in range from 1 to 6.
 386 # @retval 1 if @a lvl is out of range.
 387 # @retval 0 if @a lvl is correct.
 388 # @result Echoes first letter of level name.
 389 _lvl2char() {
 390     case "$1" in
 391         1) echo F;;
 392         2) echo E;;
 393         3) echo W;;
 394         4) echo I;;
 395         5) echo D;;
 396         6) echo T;;
 397         *) return 1;;
 398     esac
 399 }
 400
 401 ## @brief Internal helper function for _do_dlog()
 402 #
 403 # @param lvl Numeric logging level.
 404 # @param msg Message.
 405 # @retval 0 It's always returned, even if logging failed.
 406 #
 407 # @note This function is not supposed to be called manually. Please use
 408 # dtrace(), ddebug(), or others instead which wrap this one.
 409 #
 410 # This function calls _do_dlog() either with parameter msg, or if
 411 # none is given, it will read standard input and will use every line as
 412 # a message.
 413 #
 414 # This enables:
 415 # dwarn "This is a warning"
 416 # echo "This is a warning" | dwarn
 417 LOG_LEVEL=4
 418
 419 dlog() {
 420     [ -z "$LOG_LEVEL" ] && return 0
 421     [ $1 -le $LOG_LEVEL ] || return 0
 422     local lvl="$1"; shift
 423     local lvlc=$(_lvl2char "$lvl") || return 0
 424
 425     if [ $# -ge 1 ]; then
 426         echo "$lvlc: $*"
 427     else
 428         while read line; do
 429             echo "$lvlc: " "$line"
 430         done
 431     fi
 432 }
 433
 434 ## @brief Logs message at TRACE level (6)
 435 #
 436 # @param msg Message.
 437 # @retval 0 It's always returned, even if logging failed.
 438 dtrace() {
 439     set +x
 440     dlog 6 "$@"
 441     [ -n "$debug" ] && set -x || :
 442 }
 443
 444 ## @brief Logs message at DEBUG level (5)
 445 #
 446 # @param msg Message.
 447 # @retval 0 It's always returned, even if logging failed.
 448 ddebug() {
 449 #    set +x
 450     dlog 5 "$@"
 451 #    [ -n "$debug" ] && set -x || :
 452 }
 453
 454 ## @brief Logs message at INFO level (4)
 455 #
 456 # @param msg Message.
 457 # @retval 0 It's always returned, even if logging failed.
 458 dinfo() {
 459     set +x
 460     dlog 4 "$@"
 461     [ -n "$debug" ] && set -x || :
 462 }
 463
 464 ## @brief Logs message at WARN level (3)
 465 #
 466 # @param msg Message.
 467 # @retval 0 It's always returned, even if logging failed.
 468 dwarn() {
 469     set +x
 470     dlog 3 "$@"
 471     [ -n "$debug" ] && set -x || :
 472 }
 473
 474 ## @brief Logs message at ERROR level (2)
 475 #
 476 # @param msg Message.
 477 # @retval 0 It's always returned, even if logging failed.
 478 derror() {
 479 #    set +x
 480     dlog 2 "$@"
 481 #    [ -n "$debug" ] && set -x || :
 482 }
 483
 484 ## @brief Logs message at FATAL level (1)
 485 #
 486 # @param msg Message.
 487 # @retval 0 It's always returned, even if logging failed.
 488 dfatal() {
 489     set +x
 490     dlog 1 "$@"
 491     [ -n "$debug" ] && set -x || :
 492 }
 493
 494
 495 # Generic substring function.  If $2 is in $1, return 0.
 496 strstr() { [ "${1#*$2*}" != "$1" ]; }
 497
 498 # normalize_path <path>
 499 # Prints the normalized path, where it removes any duplicated
 500 # and trailing slashes.
 501 # Example:
 502 # $ normalize_path ///test/test//
 503 # /test/test
 504 normalize_path() {
 505     shopt -q -s extglob
 506     set -- "${1//+(\/)//}"
 507     shopt -q -u extglob
 508     echo "${1%/}"
 509 }
 510
 511 # convert_abs_rel <from> <to>
 512 # Prints the relative path, when creating a symlink to <to> from <from>.
 513 # Example:
 514 # $ convert_abs_rel /usr/bin/test /bin/test-2
 515 # ../../bin/test-2
 516 # $ ln -s $(convert_abs_rel /usr/bin/test /bin/test-2) /usr/bin/test
 517 convert_abs_rel() {
 518     local __current __absolute __abssize __cursize __newpath
 519     local -i __i __level
 520
 521     set -- "$(normalize_path "$1")" "$(normalize_path "$2")"
 522
 523     # corner case #1 - self looping link
 524     [[ "$1" == "$2" ]] && { echo "${1##*/}"; return; }
 525
 526     # corner case #2 - own dir link
 527     [[ "${1%/*}" == "$2" ]] && { echo "."; return; }
 528
 529     IFS="/" __current=($1)
 530     IFS="/" __absolute=($2)
 531
 532     __abssize=${#__absolute[@]}
 533     __cursize=${#__current[@]}
 534
 535     while [[ ${__absolute[__level]} == ${__current[__level]} ]]
 536     do
 537         (( __level++ ))
 538         if (( __level > __abssize || __level > __cursize ))
 539         then
 540             break
 541         fi
 542     done
 543
 544     for ((__i = __level; __i < __cursize-1; __i++))
 545     do
 546         if ((__i > __level))
 547         then
 548             __newpath=$__newpath"/"
 549         fi
 550         __newpath=$__newpath".."
 551     done
 552
 553     for ((__i = __level; __i < __abssize; __i++))
 554     do
 555         if [[ -n $__newpath ]]
 556         then
 557             __newpath=$__newpath"/"
 558         fi
 559         __newpath=$__newpath${__absolute[__i]}
 560     done
 561
 562     echo "$__newpath"
 563 }
 564
 565
 566 # Install a directory, keeping symlinks as on the original system.
 567 # Example: if /lib points to /lib64 on the host, "inst_dir /lib/file"
 568 # will create ${initdir}/lib64, ${initdir}/lib64/file,
 569 # and a symlink ${initdir}/lib -> lib64.
 570 inst_dir() {
 571     [[ -e ${initdir}/"$1" ]] && return 0  # already there
 572
 573     local _dir="$1" _part="${1%/*}" _file
 574     while [[ "$_part" != "${_part%/*}" ]] && ! [[ -e "${initdir}/${_part}" ]]; do
 575         _dir="$_part $_dir"
 576         _part=${_part%/*}
 577     done
 578
 579     # iterate over parent directories
 580     for _file in $_dir; do
 581         [[ -e "${initdir}/$_file" ]] && continue
 582         if [[ -L $_file ]]; then
 583             inst_symlink "$_file"
 584         else
 585             # create directory
 586             mkdir -m 0755 -p "${initdir}/$_file" || return 1
 587             [[ -e "$_file" ]] && chmod --reference="$_file" "${initdir}/$_file"
 588             chmod u+w "${initdir}/$_file"
 589         fi
 590     done
 591 }
 592
 593 # $1 = file to copy to ramdisk
 594 # $2 (optional) Name for the file on the ramdisk
 595 # Location of the image dir is assumed to be $initdir
 596 # We never overwrite the target if it exists.
 597 inst_simple() {
 598     [[ -f "$1" ]] || return 1
 599     strstr "$1" "/" || return 1
 600
 601     local _src=$1 target="${2:-$1}"
 602     if ! [[ -d ${initdir}/$target ]]; then
 603         [[ -e ${initdir}/$target ]] && return 0
 604         [[ -L ${initdir}/$target ]] && return 0
 605         [[ -d "${initdir}/${target%/*}" ]] || inst_dir "${target%/*}"
 606     fi
 607     # install checksum files also
 608     if [[ -e "${_src%/*}/.${_src##*/}.hmac" ]]; then
 609         inst "${_src%/*}/.${_src##*/}.hmac" "${target%/*}/.${target##*/}.hmac"
 610     fi
 611     ddebug "Installing $_src"
 612     cp --sparse=always -pfL "$_src" "${initdir}/$target"
 613 }
 614
 615 # find symlinks linked to given library file
 616 # $1 = library file
 617 # Function searches for symlinks by stripping version numbers appended to
 618 # library filename, checks if it points to the same target and finally
 619 # prints the list of symlinks to stdout.
 620 #
 621 # Example:
 622 # rev_lib_symlinks libfoo.so.8.1
 623 # output: libfoo.so.8 libfoo.so
 624 # (Only if libfoo.so.8 and libfoo.so exists on host system.)
 625 rev_lib_symlinks() {
 626     [[ ! $1 ]] && return 0
 627
 628     local fn="$1" orig="$(readlink -f "$1")" links=''
 629
 630     [[ ${fn} =~ .*\.so\..* ]] || return 1
 631
 632     until [[ ${fn##*.} == so ]]; do
 633         fn="${fn%.*}"
 634         [[ -L ${fn} && $(readlink -f "${fn}") == ${orig} ]] && links+=" ${fn}"
 635     done
 636
 637     echo "${links}"
 638 }
 639
 640 # Same as above, but specialized to handle dynamic libraries.
 641 # It handles making symlinks according to how the original library
 642 # is referenced.
 643 inst_library() {
 644     local _src="$1" _dest=${2:-$1} _lib _reallib _symlink
 645     strstr "$1" "/" || return 1
 646     [[ -e $initdir/$_dest ]] && return 0
 647     if [[ -L $_src ]]; then
 648         # install checksum files also
 649         if [[ -e "${_src%/*}/.${_src##*/}.hmac" ]]; then
 650             inst "${_src%/*}/.${_src##*/}.hmac" "${_dest%/*}/.${_dest##*/}.hmac"
 651         fi
 652         _reallib=$(readlink -f "$_src")
 653         inst_simple "$_reallib" "$_reallib"
 654         inst_dir "${_dest%/*}"
 655         [[ -d "${_dest%/*}" ]] && _dest=$(readlink -f "${_dest%/*}")/${_dest##*/}
 656         ln -sfn $(convert_abs_rel "${_dest}" "${_reallib}") "${initdir}/${_dest}"
 657     else
 658         inst_simple "$_src" "$_dest"
 659     fi
 660
 661     # Create additional symlinks.  See rev_symlinks description.
 662     for _symlink in $(rev_lib_symlinks $_src) $(rev_lib_symlinks $_reallib); do
 663         [[ ! -e $initdir/$_symlink ]] && {
 664             ddebug "Creating extra symlink: $_symlink"
 665             inst_symlink $_symlink
 666         }
 667     done
 668 }
 669
 670 # find a binary.  If we were not passed the full path directly,
 671 # search in the usual places to find the binary.
 672 find_binary() {
 673     if [[ -z ${1##/*} ]]; then
 674         if [[ -x $1 ]] || { strstr "$1" ".so" && ldd $1 &>/dev/null; };  then
 675             echo $1
 676             return 0
 677         fi
 678     fi
 679
 680     type -P $1
 681 }
 682
 683 # Same as above, but specialized to install binary executables.
 684 # Install binary executable, and all shared library dependencies, if any.
 685 inst_binary() {
 686     local _bin _target
 687     _bin=$(find_binary "$1") || return 1
 688     _target=${2:-$_bin}
 689     [[ -e $initdir/$_target ]] && return 0
 690     [[ -L $_bin ]] && inst_symlink $_bin $_target && return 0
 691     local _file _line
 692     local _so_regex='([^ ]*/lib[^/]*/[^ ]*\.so[^ ]*)'
 693     # I love bash!
 694     LC_ALL=C ldd "$_bin" 2>/dev/null | while read _line; do
 695         [[ $_line = 'not a dynamic executable' ]] && break
 696
 697         if [[ $_line =~ $_so_regex ]]; then
 698             _file=${BASH_REMATCH[1]}
 699             [[ -e ${initdir}/$_file ]] && continue
 700             inst_library "$_file"
 701             continue
 702         fi
 703
 704         if [[ $_line =~ not\ found ]]; then
 705             dfatal "Missing a shared library required by $_bin."
 706             dfatal "Run \"ldd $_bin\" to find out what it is."
 707             dfatal "$_line"
 708             dfatal "dracut cannot create an initrd."
 709             exit 1
 710         fi
 711     done
 712     inst_simple "$_bin" "$_target"
 713 }
 714
 715 # same as above, except for shell scripts.
 716 # If your shell script does not start with shebang, it is not a shell script.
 717 inst_script() {
 718     local _bin
 719     _bin=$(find_binary "$1") || return 1
 720     shift
 721     local _line _shebang_regex
 722     read -r -n 80 _line <"$_bin"
 723     # If debug is set, clean unprintable chars to prevent messing up the term
 724     [[ $debug ]] && _line=$(echo -n "$_line" | tr -c -d '[:print:][:space:]')
 725     _shebang_regex='(#! *)(/[^ ]+).*'
 726     [[ $_line =~ $_shebang_regex ]] || return 1
 727     inst "${BASH_REMATCH[2]}" && inst_simple "$_bin" "$@"
 728 }
 729
 730 # same as above, but specialized for symlinks
 731 inst_symlink() {
 732     local _src=$1 _target=${2:-$1} _realsrc
 733     strstr "$1" "/" || return 1
 734     [[ -L $1 ]] || return 1
 735     [[ -L $initdir/$_target ]] && return 0
 736     _realsrc=$(readlink -f "$_src")
 737     if ! [[ -e $initdir/$_realsrc ]]; then
 738         if [[ -d $_realsrc ]]; then
 739             inst_dir "$_realsrc"
 740         else
 741             inst "$_realsrc"
 742         fi
 743     fi
 744     [[ ! -e $initdir/${_target%/*} ]] && inst_dir "${_target%/*}"
 745     [[ -d ${_target%/*} ]] && _target=$(readlink -f ${_target%/*})/${_target##*/}
 746     ln -sfn $(convert_abs_rel "${_target}" "${_realsrc}") "$initdir/$_target"
 747 }
 748
 749 # attempt to install any programs specified in a udev rule
 750 inst_rule_programs() {
 751     local _prog _bin
 752
 753     if grep -qE 'PROGRAM==?"[^ "]+' "$1"; then
 754         for _prog in $(grep -E 'PROGRAM==?"[^ "]+' "$1" | sed -r 's/.*PROGRAM==?"([^ "]+).*/\1/'); do
 755             if [ -x /lib/udev/$_prog ]; then
 756                 _bin=/lib/udev/$_prog
 757             else
 758                 _bin=$(find_binary "$_prog") || {
 759                     dinfo "Skipping program $_prog using in udev rule $(basename $1) as it cannot be found"
 760                     continue;
 761                 }
 762             fi
 763
 764             #dinfo "Installing $_bin due to it's use in the udev rule $(basename $1)"
 765             dracut_install "$_bin"
 766         done
 767     fi
 768 }
 769
 770 # udev rules always get installed in the same place, so
 771 # create a function to install them to make life simpler.
 772 inst_rules() {
 773     local _target=/etc/udev/rules.d _rule _found
 774
 775     inst_dir "/lib/udev/rules.d"
 776     inst_dir "$_target"
 777     for _rule in "$@"; do
 778         if [ "${rule#/}" = "$rule" ]; then
 779             for r in /lib/udev/rules.d /etc/udev/rules.d; do
 780                 if [[ -f $r/$_rule ]]; then
 781                     _found="$r/$_rule"
 782                     inst_simple "$_found"
 783                     inst_rule_programs "$_found"
 784                 fi
 785             done
 786         fi
 787         for r in '' ./ $dracutbasedir/rules.d/; do
 788             if [[ -f ${r}$_rule ]]; then
 789                 _found="${r}$_rule"
 790                 inst_simple "$_found" "$_target/${_found##*/}"
 791                 inst_rule_programs "$_found"
 792             fi
 793         done
 794         [[ $_found ]] || dinfo "Skipping udev rule: $_rule"
 795     done
 796 }
 797
 798 # general purpose installation function
 799 # Same args as above.
 800 inst() {
 801     local _x
 802
 803     case $# in
 804         1) ;;
 805         2) [[ ! $initdir && -d $2 ]] && export initdir=$2
 806             [[ $initdir = $2 ]] && set $1;;
 807         3) [[ -z $initdir ]] && export initdir=$2
 808             set $1 $3;;
 809         *) dfatal "inst only takes 1 or 2 or 3 arguments"
 810             exit 1;;
 811     esac
 812     for _x in inst_symlink inst_script inst_binary inst_simple; do
 813         $_x "$@" && return 0
 814     done
 815     return 1
 816 }
 817
 818 # install any of listed files
 819 #
 820 # If first argument is '-d' and second some destination path, first accessible
 821 # source is installed into this path, otherwise it will installed in the same
 822 # path as source.  If none of listed files was installed, function return 1.
 823 # On first successful installation it returns with 0 status.
 824 #
 825 # Example:
 826 #
 827 # inst_any -d /bin/foo /bin/bar /bin/baz
 828 #
 829 # Lets assume that /bin/baz exists, so it will be installed as /bin/foo in
 830 # initramfs.
 831 inst_any() {
 832     local to f
 833
 834     [[ $1 = '-d' ]] && to="$2" && shift 2
 835
 836     for f in "$@"; do
 837         if [[ -e $f ]]; then
 838             [[ $to ]] && inst "$f" "$to" && return 0
 839             inst "$f" && return 0
 840         fi
 841     done
 842
 843     return 1
 844 }
 845
 846 # dracut_install [-o ] <file> [<file> ... ]
 847 # Install <file> to the initramfs image
 848 # -o optionally install the <file> and don't fail, if it is not there
 849 dracut_install() {
 850     local _optional=no
 851     if [[ $1 = '-o' ]]; then
 852         _optional=yes
 853         shift
 854     fi
 855     while (($# > 0)); do
 856         if ! inst "$1" ; then
 857             if [[ $_optional = yes ]]; then
 858                 dinfo "Skipping program $1 as it cannot be found and is" \
 859                     "flagged to be optional"
 860             else
 861                 dfatal "Failed to install $1"
 862                 exit 1
 863             fi
 864         fi
 865         shift
 866     done
 867 }
 868
 869 # Install a single kernel module along with any firmware it may require.
 870 # $1 = full path to kernel module to install
 871 install_kmod_with_fw() {
 872     # no need to go further if the module is already installed
 873
 874     [[ -e "${initdir}/lib/modules/$KERNEL_VER/${1##*/lib/modules/$KERNEL_VER/}" ]] \
 875         && return 0
 876
 877     [[ -e "$initdir/.kernelmodseen/${1##*/}" ]] && return 0
 878
 879     if [[ $omit_drivers ]]; then
 880         local _kmod=${1##*/}
 881         _kmod=${_kmod%.ko}
 882         _kmod=${_kmod/-/_}
 883         if [[ "$_kmod" =~ $omit_drivers ]]; then
 884             dinfo "Omitting driver $_kmod"
 885             return 1
 886         fi
 887         if [[ "${1##*/lib/modules/$KERNEL_VER/}" =~ $omit_drivers ]]; then
 888             dinfo "Omitting driver $_kmod"
 889             return 1
 890         fi
 891     fi
 892
 893     [ -d "$initdir/.kernelmodseen" ] && \
 894         > "$initdir/.kernelmodseen/${1##*/}"
 895
 896     inst_simple "$1" "/lib/modules/$KERNEL_VER/${1##*/lib/modules/$KERNEL_VER/}" \
 897         || return $?
 898
 899     local _modname=${1##*/} _fwdir _found _fw
 900     _modname=${_modname%.ko*}
 901     for _fw in $(modinfo -k $KERNEL_VER -F firmware $1 2>/dev/null); do
 902         _found=''
 903         for _fwdir in $fw_dir; do
 904             if [[ -d $_fwdir && -f $_fwdir/$_fw ]]; then
 905                 inst_simple "$_fwdir/$_fw" "/lib/firmware/$_fw"
 906                 _found=yes
 907             fi
 908         done
 909         if [[ $_found != yes ]]; then
 910             if ! grep -qe "\<${_modname//-/_}\>" /proc/modules; then
 911                 dinfo "Possible missing firmware \"${_fw}\" for kernel module" \
 912                     "\"${_modname}.ko\""
 913             else
 914                 dwarn "Possible missing firmware \"${_fw}\" for kernel module" \
 915                     "\"${_modname}.ko\""
 916             fi
 917         fi
 918     done
 919     return 0
 920 }
 921
 922 # Do something with all the dependencies of a kernel module.
 923 # Note that kernel modules depend on themselves using the technique we use
 924 # $1 = function to call for each dependency we find
 925 #      It will be passed the full path to the found kernel module
 926 # $2 = module to get dependencies for
 927 # rest of args = arguments to modprobe
 928 # _fderr specifies FD passed from surrounding scope
 929 for_each_kmod_dep() {
 930     local _func=$1 _kmod=$2 _cmd _modpath _options _found=0
 931     shift 2
 932     modprobe "$@" --ignore-install --show-depends $_kmod 2>&${_fderr} | (
 933         while read _cmd _modpath _options; do
 934             [[ $_cmd = insmod ]] || continue
 935             $_func ${_modpath} || exit $?
 936             _found=1
 937         done
 938         [[ $_found -eq 0 ]] && exit 1
 939         exit 0
 940     )
 941 }
 942
 943 # filter kernel modules to install certain modules that meet specific
 944 # requirements.
 945 # $1 = search only in subdirectory of /kernel/$1
 946 # $2 = function to call with module name to filter.
 947 #      This function will be passed the full path to the module to test.
 948 # The behavior of this function can vary depending on whether $hostonly is set.
 949 # If it is, we will only look at modules that are already in memory.
 950 # If it is not, we will look at all kernel modules
 951 # This function returns the full filenames of modules that match $1
 952 filter_kernel_modules_by_path () (
 953     local _modname _filtercmd
 954     if ! [[ $hostonly ]]; then
 955         _filtercmd='find "$KERNEL_MODS/kernel/$1" "$KERNEL_MODS/extra"'
 956         _filtercmd+=' "$KERNEL_MODS/weak-updates" -name "*.ko" -o -name "*.ko.gz"'
 957         _filtercmd+=' -o -name "*.ko.xz"'
 958         _filtercmd+=' 2>/dev/null'
 959     else
 960         _filtercmd='cut -d " " -f 1 </proc/modules|xargs modinfo -F filename '
 961         _filtercmd+='-k $KERNEL_VER 2>/dev/null'
 962     fi
 963     for _modname in $(eval $_filtercmd); do
 964         case $_modname in
 965             *.ko) "$2" "$_modname" && echo "$_modname";;
 966             *.ko.gz) gzip -dc "$_modname" > $initdir/$$.ko
 967                 $2 $initdir/$$.ko && echo "$_modname"
 968                 rm -f $initdir/$$.ko
 969                 ;;
 970             *.ko.xz) xz -dc "$_modname" > $initdir/$$.ko
 971                 $2 $initdir/$$.ko && echo "$_modname"
 972                 rm -f $initdir/$$.ko
 973                 ;;
 974         esac
 975     done
 976 )
 977 find_kernel_modules_by_path () (
 978     if ! [[ $hostonly ]]; then
 979         find "$KERNEL_MODS/kernel/$1" "$KERNEL_MODS/extra" "$KERNEL_MODS/weak-updates" \
 980           -name "*.ko" -o -name "*.ko.gz" -o -name "*.ko.xz" 2>/dev/null
 981     else
 982         cut -d " " -f 1 </proc/modules \
 983         | xargs modinfo -F filename -k $KERNEL_VER 2>/dev/null
 984     fi
 985 )
 986
 987 filter_kernel_modules () {
 988     filter_kernel_modules_by_path  drivers  "$1"
 989 }
 990
 991 find_kernel_modules () {
 992     find_kernel_modules_by_path  drivers
 993 }
 994
 995 # instmods [-c] <kernel module> [<kernel module> ... ]
 996 # instmods [-c] <kernel subsystem>
 997 # install kernel modules along with all their dependencies.
 998 # <kernel subsystem> can be e.g. "=block" or "=drivers/usb/storage"
 999 instmods() {
1000     [[ $no_kernel = yes ]] && return
1001     # called [sub]functions inherit _fderr
1002     local _fderr=9
1003     local _check=no
1004     if [[ $1 = '-c' ]]; then
1005         _check=yes
1006         shift
1007     fi
1008
1009     function inst1mod() {
1010         local _ret=0 _mod="$1"
1011         case $_mod in
1012             =*)
1013                 if [ -f $KERNEL_MODS/modules.${_mod#=} ]; then
1014                     ( [[ "$_mpargs" ]] && echo $_mpargs
1015                       cat "${KERNEL_MODS}/modules.${_mod#=}" ) \
1016                     | instmods
1017                 else
1018                     ( [[ "$_mpargs" ]] && echo $_mpargs
1019                       find "$KERNEL_MODS" -path "*/${_mod#=}/*" -printf '%f\n' ) \
1020                     | instmods
1021                 fi
1022                 ;;
1023             --*) _mpargs+=" $_mod" ;;
1024             i2o_scsi) return ;; # Do not load this diagnostic-only module
1025             *)
1026                 _mod=${_mod##*/}
1027                 # if we are already installed, skip this module and go on
1028                 # to the next one.
1029                 [[ -f "$initdir/.kernelmodseen/${_mod%.ko}.ko" ]] && return
1030
1031                 if [[ $omit_drivers ]] && [[ "$1" =~ $omit_drivers ]]; then
1032                     dinfo "Omitting driver ${_mod##$KERNEL_MODS}"
1033                     return
1034                 fi
1035                 # If we are building a host-specific initramfs and this
1036                 # module is not already loaded, move on to the next one.
1037                 [[ $hostonly ]] && ! grep -qe "\<${_mod//-/_}\>" /proc/modules \
1038                     && ! echo $add_drivers | grep -qe "\<${_mod}\>" \
1039                     && return
1040
1041                 # We use '-d' option in modprobe only if modules prefix path
1042                 # differs from default '/'.  This allows us to use Dracut with
1043                 # old version of modprobe which doesn't have '-d' option.
1044                 local _moddirname=${KERNEL_MODS%%/lib/modules/*}
1045                 [[ -n ${_moddirname} ]] && _moddirname="-d ${_moddirname}/"
1046
1047                 # ok, load the module, all its dependencies, and any firmware
1048                 # it may require
1049                 for_each_kmod_dep install_kmod_with_fw $_mod \
1050                     --set-version $KERNEL_VER ${_moddirname} $_mpargs
1051                 ((_ret+=$?))
1052                 ;;
1053         esac
1054         return $_ret
1055     }
1056
1057     function instmods_1() {
1058         local _mod _mpargs
1059         if (($# == 0)); then  # filenames from stdin
1060             while read _mod; do
1061                 inst1mod "${_mod%.ko*}" || {
1062                     if [ "$_check" = "yes" ]; then
1063                         dfatal "Failed to install $_mod"
1064                         return 1
1065                     fi
1066                 }
1067             done
1068         fi
1069         while (($# > 0)); do  # filenames as arguments
1070             inst1mod ${1%.ko*} || {
1071                 if [ "$_check" = "yes" ]; then
1072                     dfatal "Failed to install $1"
1073                     return 1
1074                 fi
1075             }
1076             shift
1077         done
1078         return 0
1079     }
1080
1081     local _ret _filter_not_found='FATAL: Module .* not found.'
1082     set -o pipefail
1083     # Capture all stderr from modprobe to _fderr. We could use {var}>...
1084     # redirections, but that would make dracut require bash4 at least.
1085     eval "( instmods_1 \"\$@\" ) ${_fderr}>&1" \
1086     | while read line; do [[ "$line" =~ $_filter_not_found ]] && echo $line || echo $line >&2 ;done | derror
1087     _ret=$?
1088     set +o pipefail
1089     return $_ret
1090 }
1091
1092 # inst_libdir_file [-n <pattern>] <file> [<file>...]
1093 # Install a <file> located on a lib directory to the initramfs image
1094 # -n <pattern> install non-matching files
1095 inst_libdir_file() {
1096     if [[ "$1" == "-n" ]]; then
1097         local _pattern=$1
1098         shift 2
1099         for _dir in $libdirs; do
1100             for _i in "$@"; do
1101                 for _f in "$_dir"/$_i; do
1102                     [[ "$_i" =~ $_pattern ]] || continue
1103                     [[ -e "$_i" ]] && dracut_install "$_i"
1104                 done
1105             done
1106         done
1107     else
1108         for _dir in $libdirs; do
1109             for _i in "$@"; do
1110                 for _f in "$_dir"/$_i; do
1111                     [[ -e "$_f" ]] && dracut_install "$_f"
1112                 done
1113             done
1114         done
1115     fi
1116 }
1117
1118 check_nspawn() {
1119     [[ -d /sys/fs/cgroup/systemd ]]
1120 }
1121
1122
1123 do_test() {
1124     if [[ $UID != "0" ]]; then
1125         echo "TEST: $TEST_DESCRIPTION [SKIPPED]: not root" >&2
1126         exit 0
1127     fi
1128
1129 # Detect lib paths
1130     [[ $libdir ]] || for libdir in /lib64 /lib; do
1131         [[ -d $libdir ]] && libdirs+=" $libdir" && break
1132     done
1133
1134     [[ $usrlibdir ]] || for usrlibdir in /usr/lib64 /usr/lib; do
1135         [[ -d $usrlibdir ]] && libdirs+=" $usrlibdir" && break
1136     done
1137
1138     import_testdir
1139     import_initdir
1140
1141     while (($# > 0)); do
1142         case $1 in
1143             --run)
1144                 echo "TEST RUN: $TEST_DESCRIPTION"
1145                 test_run
1146                 ret=$?
1147                 if [ $ret -eq 0 ]; then
1148                     echo "TEST RUN: $TEST_DESCRIPTION [OK]"
1149                 else
1150                     echo "TEST RUN: $TEST_DESCRIPTION [FAILED]"
1151                 fi
1152                 exit $ret;;
1153             --setup)
1154                 echo "TEST SETUP: $TEST_DESCRIPTION"
1155                 test_setup
1156                 exit $?;;
1157             --clean)
1158                 echo "TEST CLEANUP: $TEST_DESCRIPTION"
1159                 test_cleanup
1160                 rm -fr "$TESTDIR"
1161                 rm -f .testdir
1162                 exit $?;;
1163             --all)
1164                 echo -n "TEST: $TEST_DESCRIPTION ";
1165                 (
1166                     test_setup && test_run
1167                     ret=$?
1168                     test_cleanup
1169                     rm -fr "$TESTDIR"
1170                     rm -f .testdir
1171                     exit $ret
1172                 ) </dev/null >test.log 2>&1
1173                 ret=$?
1174                 if [ $ret -eq 0 ]; then
1175                     rm test.log
1176                     echo "[OK]"
1177                 else
1178                     echo "[FAILED]"
1179                     echo "see $(pwd)/test.log"
1180                 fi
1181                 exit $ret;;
1182             *) break ;;
1183         esac
1184         shift
1185     done
1186 }