# This file contains common functions used in init and in hooks # logging targets _rdlog_file=$(( 1 << 0 )) _rdlog_kmsg=$(( 1 << 1 )) _rdlog_cons=$(( 1 << 2 )) _rdlog_all=$(( (1 << 3) - 1 )) msg () { [ "${quiet}" != "y" ] && echo $@ } err () { echo "ERROR: $@" } log_kmsg() { local fmt=$1; shift printf "<31>initramfs: $fmt\n" "$@" } poll_device() { local device=$1 seconds=${2//[!0-9]} [ "${seconds:-x}" = x ] && seconds=10 deciseconds=$(( seconds * 10 )) # tenths of a second sleepinterval=1 [ -b "$device" ] && return 0 if [ "$udevd_running" -eq 1 ]; then msg "Waiting $seconds seconds for device $device ..." >&2 while [ ! -b "$device" -a "$deciseconds" -gt 0 ]; do if [ "$sleepinterval" -ge 10 ]; then sleep 1 deciseconds=$(( deciseconds - 10 )) else sleep .$sleepinterval deciseconds=$(( deciseconds - sleepinterval )) sleepinterval=$(( sleepinterval * 2 )) fi done fi [ -b "$device" ] } launch_interactive_shell() { export PS1='[rootfs \W]\$ ' # explicitly redirect to /dev/console in case we're logging. note that # anything done in the rescue shell will NOT be logged. { [ "$1" = "--exec" ] && exec sh -i sh -i } 0</dev/console 1>/dev/console 2>/dev/console } bitfield_has_bit() { [ $(( $1 & $2 )) -eq $2 ] } major_minor_to_device() { local dev [ -e "/sys/dev/block/$1:$2" ] || return 1 if dev=$(readlink -f "/sys/dev/block/$1:$2" 2>/dev/null); then echo "/dev/${dev##*/}" return 0 fi return 1 } run_hookfunctions() { local hook fn=$1 desc=$2 shift 2 for hook in "$@"; do [ -x "/hooks/$hook" ] || continue unset "$fn" . "/hooks/$hook" type "$fn" >/dev/null || continue msg ":: running $desc [$hook]" "$fn" done } set_log_option() { local opt for opt in ${1//|/ }; do case $opt in all) rd_logmask=$_rdlog_all ;; kmsg) rd_logmask=$(( rd_logmask | _rdlog_kmsg )) ;; file) rd_logmask=$(( rd_logmask | _rdlog_file )) ;; console) rd_logmask=$(( rd_logmask | _rdlog_cons )) ;; *) err "unknown rd.log parameter: '$opt'" ;; esac done } parse_cmdline() { local _w _quoted _lhs _rhs _cmdline read -r _cmdline for _w in $_cmdline; do if [ -z "$_quoted" ]; then case $_w in # ignore everything after a # in the commandline \#*) break ;; # special cases rw|ro) rwopt=$_w ;; fsck.mode=*) case ${_w#*=} in force) forcefsck=y ;; skip) fastboot=y ;; *) err "unknown fsck.mode parameter: '${_w#*=}'" ;; esac ;; rd.*) case ${_w#rd.} in debug) rd_debug=y ;; log) rd_logmask=$(( _rdlog_kmsg | _rdlog_cons )) ;; log=*) set_log_option "${_w#rd.log=}" ;; esac ;; # abide by shell variable naming rules [[:alpha:]_]*=*) _rhs=${_w#*=} _lhs=${_w%%=*} _lhs=${_lhs//[-.]/_} if [ '"' = "${_rhs:0:1}" ]; then if [ '"' = "${_rhs:$((${#_rhs}-1))}" ]; then _rhs="${_rhs:1:$((${#_rhs}-2))}" else _rhs=${_rhs:1} _quoted=1 continue fi fi eval $_lhs=\$_rhs ;; [[:alpha:]_]*) _lhs=${_w//[-.]/_} eval $_lhs=y ;; esac else if [ '"' = "${_w:$((${#_w}-1))}" ]; then _rhs="$_rhs ${_w%\"}" unset _quoted eval $_lhs=\$_rhs else _rhs="$_rhs $_w" fi fi done } fsck_device() { [ -x /sbin/fsck ] || return 255 if [ ! -b "$1" ]; then err "device '$1' not found. Skipping fsck." return 255 fi if [ -n "$fastboot" ]; then msg ":: skipping fsck on '$1'" return fi msg ":: performing fsck on '$1'" fsck -Ta -C"$FSCK_FD" "$1" -- ${forcefsck+-f} } fsck_root() { fsck_device "$root" fsckret=$? fsck_ret() { [ -z "$fsckret" ] && return 1 [ "$fsckret" -eq "$1" ] && return 0 [ "$(( fsckret & $1 ))" -eq "$1" ] } if [ "$fsckret" -ne 255 ]; then if [ "$fsckret" = '0' ] || fsck_ret 1; then echo "$fsckret" > /run/initramfs/root-fsck elif fsck_ret 4; then err "Bailing out. Run 'fsck $root' manually" printf '%s\n' \ "********** FILESYSTEM CHECK FAILED **********" \ "* *" \ "* Please run fsck manually. After leaving *" \ "* this maintenance shell, the system will *" \ "* reboot automatically. *" \ "* *" \ "*********************************************" launch_interactive_shell echo ":: Automatic reboot in progress" sleep 2 reboot -f elif fsck_ret 2; then printf '%s\n' \ "************** REBOOT REQUIRED **************" \ "* *" \ "* automatically restarting in 10 seconds *" \ "* *" \ "*********************************************" sleep 10 reboot -f elif fsck_ret 8; then err "fsck failed on '$root'" elif fsck_ret 16; then err "Failed to invoke fsck: usage or syntax error" elif fsck_ret 32; then echo ":: fsck cancelled on user request" elif fsck_ret 128; then err "fatal error invoking fsck" fi fi } resolve_device() { local major minor dev tag tagval device=$1 # attempt to resolve devices immediately. if this fails # and udev is running, fall back on lazy resolution using # /dev/disk/by-* symlinks. this is flexible enough to support # usage of tags without udev and "slow" devices like root on # USB, which might not immediately show up. case $device in UUID=*|LABEL=*|PARTUUID=*|PARTLABEL=*) dev=$(blkid -lt "$device" -o device) if [ -z "$dev" -a "$udevd_running" -eq 1 ]; then tag=$(awk -v t="${device%%=*}" 'BEGIN { print tolower(t) }') tagval=${device#*=} dev=/dev/disk/by-$tag/$tagval fi esac [ -n "$dev" ] && device=$dev case $device in # path to kernel named block device /dev/*) if poll_device "$device" "$rootdelay"; then echo "$device" return 0 fi ;; # hex encoded major/minor, such as from LILO [0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]|[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]) major=$(( 0x0$device >> 8 )) minor=$(( 0x0$device & 0xff )) ;; 0x[0-9a-fA-F][0-9a-fA-F]*) major=$(( device >> 8 )) minor=$(( device & 0xff )) ;; esac if [ -n "$major" -a -n "$minor" ]; then device=$(major_minor_to_device "$major" "$minor" || echo '/dev/root') if [ ! -b "$device" ]; then msg "Creating device node with major $major and minor $minor." >&2 mknod "$device" b "$major" "$minor" fi echo "$device" return 0 fi return 1 } default_mount_handler() { if [ ! -b "$root" ]; then err "Unable to find root device '$root'." echo "You are being dropped to a recovery shell" echo " Type 'exit' to try and continue booting" launch_interactive_shell msg "Trying to continue (this will most likely fail) ..." fi msg ":: mounting '$root' on real root" if ! mount ${fstype:+-t $fstype} -o ${rwopt:-ro}${rootflags:+,$rootflags} "$root" "$1"; then echo "You are now being dropped into an emergency shell." launch_interactive_shell msg "Trying to continue (this will most likely fail) ..." fi } rdlogger_start() { # rd.debug implies rd.log=console if rd.log(=.*)? isn't present if [ "$rd_logmask" -eq 0 ] && [ -n "$rd_debug" ]; then rd_logmask=$_rdlog_cons fi [ "$rd_logmask" -gt 0 ] || return mkfifo /run/initramfs/rdlogger.pipe rdlogger </run/initramfs/rdlogger.pipe >/dev/console 2>&1 & printf %s $! >/run/initramfs/rdlogger.pid exec >/run/initramfs/rdlogger.pipe 2>&1 [ -n "$rd_debug" ] && set -x } rdlogger_stop() { local i=0 pid [ -e /run/initramfs/rdlogger.pipe ] || return [ -n "$rd_debug" ] && { set +x; } 2>/dev/null # this nudges rdlogger to exit exec 0<>/dev/console 1<>/dev/console 2<>/dev/console # wait up to 1 second for a graceful shutdown until [ ! -e /run/initramfs/rdlogger.pipe ] || [ $i -eq 10 ]; do sleep 0.1 i=$(( i + 1 )) done if [ $i -eq 10 ]; then # racy! the logger might still go away on its own read -r pid </run/initramfs/rdlogger.pid 2>/dev/null if [ -n "$pid" ]; then kill "$pid" 2>/dev/null fi fi } rdlogger() { local line # establish logging FDs. Either redirect to an appropriate target or to # /dev/null. This way, log methods can simply write and the associated FD # will Do The Right Thing™. # rd.log=console if [ -z "$quiet" ] && bitfield_has_bit "$rd_logmask" "$_rdlog_cons"; then exec 4>/dev/console else exec 4>/dev/null fi # rd.log=kmsg if [ -c /dev/kmsg ] && bitfield_has_bit "$rd_logmask" "$_rdlog_kmsg"; then exec 5>/dev/kmsg else exec 5>/dev/null fi # rd.log=file if bitfield_has_bit "$rd_logmask" "$_rdlog_file"; then exec 6>/run/initramfs/init.log else exec 6>/dev/null fi while read -r line; do # rd.log=console printf '%s\n' "$line" >&4 # rd.log=kmsg log_kmsg '%s' "$line" >&5 # rd.log=file printf '%s\n' "$line" >&6 done # EOF, shutting down... exec 4>&- 5>&- 6>&- rm -f /run/initramfs/rdlogger.pipe /run/initramfs/rdlogger.pid } # vim: set ft=sh ts=4 sw=4 et: