kernel
/
dracut
mirror of https://git.kernel.org/pub/scm/boot/dracut/dracut.git/
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

dracut-functions: make local vars local and prefix with "_"

master
Harald Hoyer 2011-05-12 11:03:30 +02:00
parent 982e78234c
commit 29b10e65b1
25 changed files with 428 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

546
dracut-functions
View File

@ -44,25 +44,25 @@ mksubdirs() { mkdir -m 0755 -p ${1%/*}; }
# $2 = comparision op (gt, ge, eq, le, lt, ne) # $2 = comparision op (gt, ge, eq, le, lt, ne)
# $3 = version b # $3 = version b
vercmp() { vercmp() {
local n1=(${1//./ }) op=$2 n2=(${3//./ }) i res local _n1=(${1//./ }) _op=$2 _n2=(${3//./ }) _i _res


for ((i=0; ; i++)) for ((_i=0; ; _i++))
do do
if [[ ! ${n1[i]}${n2[i]} ]]; then res=0 if [[ ! ${_n1[_i]}${_n2[_i]} ]]; then _res=0
elif ((${n1[i]:-0} > ${n2[i]:-0})); then res=1 elif ((${_n1[_i]:-0} > ${_n2[_i]:-0})); then _res=1
elif ((${n1[i]:-0} < ${n2[i]:-0})); then res=2 elif ((${_n1[_i]:-0} < ${_n2[_i]:-0})); then _res=2
else continue else continue
fi fi
break break
done done


case $op in case $_op in
gt) ((res == 1));; gt) ((_res == 1));;
ge) ((res != 2));; ge) ((_res != 2));;
eq) ((res == 0));; eq) ((_res == 0));;
le) ((res != 1));; le) ((_res != 1));;
lt) ((res == 2));; lt) ((_res == 2));;
ne) ((res != 0));; ne) ((_res != 0));;
esac esac
} }


@ -73,17 +73,19 @@ is_func() {
# Function prints global variables in format name=value line by line. # Function prints global variables in format name=value line by line.
# $@ = list of global variables' name # $@ = list of global variables' name
print_vars() { print_vars() {
local var value local _var _value


for var in $@ for _var in $@
do do
value=$(eval echo \$$var) _value=$(eval echo \$$_var)
[[ ${value} ]] && echo "${var}=\"${value}\"" [[ ${_value} ]] && echo "${_var}=\"${_value}\""
done done
} }


get_fs_env() { get_fs_env() {
[[ $1 ]] || return [[ $1 ]] || return
unset ID_FS_TYPE
unset ID_FS_UUID
eval $(udevadm info --query=env --name=$1|egrep 'ID_FS_(TYPE|UUID)=') eval $(udevadm info --query=env --name=$1|egrep 'ID_FS_(TYPE|UUID)=')
[[ $ID_FS_TYPE ]] && return [[ $ID_FS_TYPE ]] && return


@ -115,38 +117,38 @@ get_fs_uuid() (


# finds the major:minor of the block device backing the root filesystem. # finds the major:minor of the block device backing the root filesystem.
find_block_device() { find_block_device() {
local x mpt majmin dev fs misc maj min local _x _mpt _majmin _dev _fs _maj _min
if [[ $use_fstab != yes ]]; then if [[ $use_fstab != yes ]]; then
while read x x majmin x mpt x x fs dev misc; do while read _x _x _majmin _x _mpt _x _x _fs _dev _x; do
[[ $fs = nfs ]] && { echo $dev; return 0;} [[ $_fs = nfs ]] && { echo $_dev; return 0;}
[[ $fs = nfs3 ]] && { echo $dev; return 0;} [[ $_fs = nfs3 ]] && { echo $_dev; return 0;}
[[ $fs = nfs4 ]] && { echo $dev; return 0;} [[ $_fs = nfs4 ]] && { echo $_dev; return 0;}
[[ $fs = btrfs ]] && { [[ $_fs = btrfs ]] && {
ls -nLl "$dev" | { ls -nLl "$_dev" | {
read x x x x maj min x read _x _x _x _x _maj _min _x
maj=${maj//,/} _maj=${_maj//,/}
echo $maj:$min echo $_maj:$_min
} && return 0 } && return 0
} }
if [[ $mpt = $1 ]] && [[ ${majmin#0:} = $majmin ]]; then if [[ $_mpt = $1 ]] && [[ ${_majmin#0:} = $_majmin ]]; then
echo $majmin echo $_majmin
return 0 # we have a winner! return 0 # we have a winner!
fi fi
done < /proc/self/mountinfo done < /proc/self/mountinfo
fi fi
# fall back to /etc/fstab # fall back to /etc/fstab
while read dev mpt fs misc; do while read _dev _mpt _fs _x; do
if [[ $mpt = $1 ]]; then if [[ $_mpt = $1 ]]; then
[[ $fs = nfs ]] && { echo $dev; return 0;} [[ $_fs = nfs ]] && { echo $_dev; return 0;}
[[ $fs = nfs3 ]] && { echo $dev; return 0;} [[ $_fs = nfs3 ]] && { echo $_dev; return 0;}
[[ $fs = nfs4 ]] && { echo $dev; return 0;} [[ $_fs = nfs4 ]] && { echo $_dev; return 0;}
[[ $dev != ${dev#UUID=} ]] && dev=/dev/disk/by-uuid/${dev#UUID=} [[ $_dev != ${_dev#UUID=} ]] && _dev=/dev/disk/by-uuid/${_dev#UUID=}
[[ $dev != ${dev#LABEL=} ]] && dev=/dev/disk/by-label/${dev#LABEL=} [[ $_dev != ${_dev#LABEL=} ]] && _dev=/dev/disk/by-label/${_dev#LABEL=}
[[ -b $dev ]] || return 1 # oops, not a block device. [[ -b $_dev ]] || return 1 # oops, not a block device.
ls -nLl "$dev" | { ls -nLl "$_dev" | {
read x x x x maj min x read _x _x _x _x _maj _min _x
maj=${maj//,/} _maj=${_maj//,/}
echo $maj:$min echo $_maj:$_min
} && return 0 } && return 0
fi fi
done < /etc/fstab done < /etc/fstab
@ -161,7 +163,7 @@ find_root_block_device() { find_block_device /; }
# $1 = function to call on every found block device # $1 = function to call on every found block device
# $2 = block device in major:minor format # $2 = block device in major:minor format
check_block_and_slaves() { check_block_and_slaves() {
local x local _x
[[ -b /dev/block/$2 ]] || return 1 # Not a block device? So sorry. [[ -b /dev/block/$2 ]] || return 1 # Not a block device? So sorry.
"$1" $2 && return "$1" $2 && return
check_vol_slaves "$@" && return 0 check_vol_slaves "$@" && return 0
@ -169,15 +171,16 @@ check_block_and_slaves() {
check_block_and_slaves $1 $(cat "/sys/dev/block/$2/../dev") && return 0 check_block_and_slaves $1 $(cat "/sys/dev/block/$2/../dev") && return 0
fi fi
[[ -d /sys/dev/block/$2/slaves ]] || return 1 [[ -d /sys/dev/block/$2/slaves ]] || return 1
for x in /sys/dev/block/$2/slaves/*/dev; do for _x in /sys/dev/block/$2/slaves/*/dev; do
[[ -f $x ]] || continue [[ -f $_x ]] || continue
check_block_and_slaves $1 $(cat "$x") && return 0 check_block_and_slaves $1 $(cat "$_x") && return 0
done done
return 1 return 1
} }


get_numeric_dev() { get_numeric_dev() {
ls -lH "$1" | { read a b c d maj min rest; printf "%d:%d" ${maj%%,} $min; } local _x _maj _min
ls -lH "$1" | { read _x _x _x _x _maj _min _x; printf "%d:%d" ${_maj%%,} $_min; }
} }


# ugly workaround for the lvm design # ugly workaround for the lvm design
@ -187,16 +190,17 @@ get_numeric_dev() {
# but you cannot create the logical volume without the volume group. # but you cannot create the logical volume without the volume group.
# And the volume group might be bigger than the devices the LV needs. # And the volume group might be bigger than the devices the LV needs.
check_vol_slaves() { check_vol_slaves() {
local _lv _vg _pv
for i in /dev/mapper/*; do for i in /dev/mapper/*; do
lv=$(get_numeric_dev $i) _lv=$(get_numeric_dev $i)
if [[ $lv = $2 ]]; then if [[ $_lv = $2 ]]; then
vg=$(lvm lvs --noheadings -o vg_name $i 2>/dev/null) _vg=$(lvm lvs --noheadings -o vg_name $i 2>/dev/null)
# strip space # strip space
vg=$(echo $vg) _vg=$(echo $_vg)
if [[ $vg ]]; then if [[ $_vg ]]; then
for pv in $(lvm vgs --noheadings -o pv_name "$vg" 2>/dev/null) for _pv in $(lvm vgs --noheadings -o pv_name "$_vg" 2>/dev/null)
do do
check_block_and_slaves $1 $(get_numeric_dev $pv) && return 0 check_block_and_slaves $1 $(get_numeric_dev $_pv) && return 0
done done
fi fi
fi fi
@ -209,27 +213,28 @@ check_vol_slaves() {
# will create ${initdir}/lib64, ${initdir}/lib64/file, # will create ${initdir}/lib64, ${initdir}/lib64/file,
# and a symlink ${initdir}/lib -> lib64. # and a symlink ${initdir}/lib -> lib64.
inst_dir() { inst_dir() {
local dir="$1" local _dir="$1"
[[ -e ${initdir}$dir ]] && return 0 local _file=""
local IFS="/"
local _part
[[ -e ${initdir}$_dir ]] && return 0


# iterate over parent directories # iterate over parent directories
local file="" for _part in $_dir; do
local IFS="/" [[ $_part ]] || continue
for part in $dir; do _file="$_file/$_part"
[[ $part ]] || continue [[ -e ${initdir}$_file ]] && continue
file="$file/$part"
[[ -e ${initdir}$file ]] && continue


if [[ -L $file ]]; then if [[ -L $_file ]]; then
# create link as the original # create link as the original
local target=$(readlink "$file") local target=$(readlink "$_file")
ln -sfn "$target" "${initdir}$file" || return 1 ln -sfn "$target" "${initdir}$_file" || return 1
# resolve relative path and recursively install destination # resolve relative path and recursively install destination
[[ $target == ${target#/} ]] && target="$(dirname "$file")/$target" [[ $target == ${target#/} ]] && target="$(dirname "$_file")/$target"
inst_dir "$target" inst_dir "$target"
else else
# create directory # create directory
mkdir -m 0755 -p "${initdir}$file" || return 1 mkdir -m 0755 -p "${initdir}$_file" || return 1
fi fi
done done
} }
@ -239,19 +244,19 @@ inst_dir() {
# Location of the image dir is assumed to be $initdir # Location of the image dir is assumed to be $initdir
# We never overwrite the target if it exists. # We never overwrite the target if it exists.
inst_simple() { inst_simple() {
local src target local _src target
[[ -f $1 ]] || return 1 [[ -f $1 ]] || return 1
src=$1 target="${2:-$1}" _src=$1 target="${2:-$1}"
if ! [[ -d ${initdir}$target ]]; then if ! [[ -d ${initdir}$target ]]; then
[[ -e ${initdir}$target ]] && return 0 [[ -e ${initdir}$target ]] && return 0
inst_dir "${target%/*}" inst_dir "${target%/*}"
fi fi
# install checksum files also # install checksum files also
if [[ -e "${src%/*}/.${src##*/}.hmac" ]]; then if [[ -e "${_src%/*}/.${_src##*/}.hmac" ]]; then
inst "${src%/*}/.${src##*/}.hmac" "${target%/*}/.${target##*/}.hmac" inst "${_src%/*}/.${_src##*/}.hmac" "${target%/*}/.${target##*/}.hmac"
fi fi
ddebug "Installing $src" ddebug "Installing $_src"
cp -pfL "$src" "${initdir}$target" cp -pfL "$_src" "${initdir}$target"
} }


# find symlinks linked to given library file # find symlinks linked to given library file
@ -283,27 +288,27 @@ rev_lib_symlinks() {
# It handles making symlinks according to how the original library # It handles making symlinks according to how the original library
# is referenced. # is referenced.
inst_library() { inst_library() {
local src=$1 dest=${2:-$1} lib reallib symlink local _src=$1 _dest=${2:-$1} _lib _reallib _symlink
[[ -e $initdir$dest ]] && return 0 [[ -e $initdir$_dest ]] && return 0
if [[ -L $src ]]; then if [[ -L $_src ]]; then
# install checksum files also # install checksum files also
if [[ -e "${src%/*}/.${src##*/}.hmac" ]]; then if [[ -e "${_src%/*}/.${_src##*/}.hmac" ]]; then
inst "${src%/*}/.${src##*/}.hmac" "${dest%/*}/.${dest##*/}.hmac" inst "${_src%/*}/.${_src##*/}.hmac" "${_dest%/*}/.${_dest##*/}.hmac"
fi fi
reallib=$(readlink -f "$src") _reallib=$(readlink -f "$_src")
lib=${src##*/} _lib=${_src##*/}
inst_simple "$reallib" "$reallib" inst_simple "$_reallib" "$_reallib"
inst_dir "${dest%/*}" inst_dir "${_dest%/*}"
(cd "${initdir}${dest%/*}" && ln -sfn "$reallib" "$lib") (cd "${initdir}${_dest%/*}" && ln -sfn "$_reallib" "$_lib")
else else
inst_simple "$src" "$dest" inst_simple "$_src" "$_dest"
fi fi


# Create additional symlinks. See rev_symlinks description. # Create additional symlinks. See rev_symlinks description.
for symlink in $(rev_lib_symlinks $src) $(rev_lib_symlinks $reallib); do for _symlink in $(rev_lib_symlinks $_src) $(rev_lib_symlinks $_reallib); do
[[ ! -e $initdir$symlink ]] && { [[ ! -e $initdir$_symlink ]] && {
ddebug "Creating extra symlink: $symlink" ddebug "Creating extra symlink: $_symlink"
inst_symlink $symlink inst_symlink $_symlink
} }
done done
} }
@ -311,15 +316,15 @@ inst_library() {
# find a binary. If we were not passed the full path directly, # find a binary. If we were not passed the full path directly,
# search in the usual places to find the binary. # search in the usual places to find the binary.
find_binary() { find_binary() {
local binpath="/bin /sbin /usr/bin /usr/sbin" p local _binpath="/bin /sbin /usr/bin /usr/sbin" _p
if [[ -z ${1##/*} ]]; then if [[ -z ${1##/*} ]]; then
if [[ -x $1 ]] || ldd $1 &>/dev/null; then if [[ -x $1 ]] || ldd $1 &>/dev/null; then
echo $1 echo $1
return 0 return 0
fi fi
fi fi
for p in $binpath; do for _p in $_binpath; do
[[ -x $p/$1 ]] && { echo "$p/$1"; return 0; } [[ -x $_p/$1 ]] && { echo "$_p/$1"; return 0; }
done done
return 1 return 1
} }
@ -327,102 +332,104 @@ find_binary() {
# Same as above, but specialized to install binary executables. # Same as above, but specialized to install binary executables.
# Install binary executable, and all shared library dependencies, if any. # Install binary executable, and all shared library dependencies, if any.
inst_binary() { inst_binary() {
local bin target f self so_regex lib_regex TLIBDIR BASE FILE local _bin _target _f _self _so_regex _lib_regex _tlibdir _base _file _line


bin=$(find_binary "$1") || return 1 _bin=$(find_binary "$1") || return 1
target=${2:-$bin} _target=${2:-$_bin}
inst_symlink $bin $target && return 0 inst_symlink $_bin $_target && return 0
[[ -e $initdir$target ]] && return 0 [[ -e $initdir$_target ]] && return 0


# If the binary being installed is also a library, add it to the loop. # If the binary being installed is also a library, add it to the loop.
so_regex='([^ ]*/lib[^/]*/[^ ]*\.so[^ ]*)' _so_regex='([^ ]*/lib[^/]*/[^ ]*\.so[^ ]*)'
[[ $bin =~ $so_regex ]] && self="\t${bin##*/} => ${bin} (0x0)\n" [[ $_bin =~ $_so_regex ]] && _self="\t${_bin##*/} => ${_bin} (0x0)\n"


lib_regex='^(/lib[^/]*).*' _lib_regex='^(/lib[^/]*).*'
# I love bash! # I love bash!
{ LC_ALL=C ldd $bin 2>/dev/null; echo -en "$self"; } | while read line; do { LC_ALL=C ldd $_bin 2>/dev/null; echo -en "$_self"; } | while read _line; do
[[ $line = 'not a dynamic executable' ]] && return 1 [[ $_line = 'not a dynamic executable' ]] && return 1
if [[ $line =~ not\ found ]]; then if [[ $_line =~ not\ found ]]; then
dfatal "Missing a shared library required by $bin." dfatal "Missing a shared library required by $_bin."
dfatal "Run \"ldd $bin\" to find out what it is." dfatal "Run \"ldd $_bin\" to find out what it is."
dfatal "dracut cannot create an initrd." dfatal "dracut cannot create an initrd."
exit 1 exit 1
fi fi
[[ $line =~ $so_regex ]] || continue [[ $_line =~ $_so_regex ]] || continue
FILE=${BASH_REMATCH[1]} _file=${BASH_REMATCH[1]}
[[ -e ${initdir}$FILE ]] && continue [[ -e ${initdir}$_file ]] && continue


# See if we are loading an optimized version of a shared lib. # See if we are loading an optimized version of a shared lib.
if [[ $FILE =~ $lib_regex ]]; then if [[ $_file =~ $_lib_regex ]]; then
TLIBDIR=${BASH_REMATCH[1]} _tlibdir=${BASH_REMATCH[1]}
BASE=${FILE##*/} _base=${_file##*/}
# Prefer nosegneg libs to unoptimized ones. # Prefer nosegneg libs to unoptimized ones.
for f in "$TLIBDIR/i686/nosegneg" "$TLIBDIR"; do for _f in "$_tlibdir/i686/nosegneg" "$_tlibdir"; do
[[ -e $f/$BASE ]] || continue [[ -e $_f/$_base ]] || continue
FILE=$f/$BASE _file=$_f/$_base
break break
done done
inst_library "$FILE" "$TLIBDIR/$BASE" inst_library "$_file" "$_tlibdir/$_base"
else else
inst_library "$FILE" inst_library "$_file"
fi fi
done done


# Install the binary if it wasn't handled in the above loop. # Install the binary if it wasn't handled in the above loop.
[[ -z $self ]] && inst_simple "$bin" "$target" [[ -z $_self ]] && inst_simple "$_bin" "$_target"
} }


# same as above, except for shell scripts. # same as above, except for shell scripts.
# If your shell script does not start with shebang, it is not a shell script. # If your shell script does not start with shebang, it is not a shell script.
inst_script() { inst_script() {
[[ -f $1 ]] || return 1 [[ -f $1 ]] || return 1
local line local _line _shebang_regex
read -r -n 80 line <"$1" read -r -n 80 _line <"$1"
# If debug is set, clean unprintable chars to prevent messing up the term # If debug is set, clean unprintable chars to prevent messing up the term
[[ $debug ]] && line=$(echo -n "$line" | tr -c -d '[:print:][:space:]') [[ $debug ]] && _line=$(echo -n "$_line" | tr -c -d '[:print:][:space:]')
shebang_regex='(#! *)(/[^ ]+).*' _shebang_regex='(#! *)(/[^ ]+).*'
[[ $line =~ $shebang_regex ]] || return 1 [[ $_line =~ $_shebang_regex ]] || return 1
inst "${BASH_REMATCH[2]}" && inst_simple "$@" inst "${BASH_REMATCH[2]}" && inst_simple "$@"
} }


# same as above, but specialized for symlinks # same as above, but specialized for symlinks
inst_symlink() { inst_symlink() {
local src=$1 target=$initdir${2:-$1} realsrc local _src=$1 _target=$initdir${2:-$1} _realsrc
[[ -L $1 ]] || return 1 [[ -L $1 ]] || return 1
[[ -L $target ]] && return 0 [[ -L $_target ]] && return 0
realsrc=$(readlink -f "$src") _realsrc=$(readlink -f "$_src")
[[ $realsrc = ${realsrc##*/} ]] && realsrc=${src%/*}/$realsrc [[ $_realsrc = ${_realsrc##*/} ]] && _realsrc=${_src%/*}/$_realsrc
inst "$realsrc" && mkdir -m 0755 -p "${target%/*}" && \ inst "$_realsrc" && mkdir -m 0755 -p "${_target%/*}" && \
ln -sfn "$realsrc" "$target" ln -sfn "$_realsrc" "$_target"
} }


# udev rules always get installed in the same place, so # udev rules always get installed in the same place, so
# create a function to install them to make life simpler. # create a function to install them to make life simpler.
inst_rules() { inst_rules() {
local target=/etc/udev/rules.d rule found local _target=/etc/udev/rules.d _rule _found


inst_dir "/lib/udev/rules.d" inst_dir "/lib/udev/rules.d"
inst_dir "$target" inst_dir "$_target"
for rule in "$@"; do for _rule in "$@"; do
for r in /lib/udev/rules.d /etc/udev/rules.d; do for r in /lib/udev/rules.d /etc/udev/rules.d; do
if [[ -f $r/$rule ]]; then if [[ -f $r/$_rule ]]; then
found="$r/$rule" _found="$r/$_rule"
inst_simple "$found" inst_simple "$_found"
fi fi
done done
for r in '' ./ $dracutbasedir/rules.d/; do for r in '' ./ $dracutbasedir/rules.d/; do
if [[ -f ${r}$rule ]]; then if [[ -f ${r}$_rule ]]; then
found="${r}$rule" _found="${r}$_rule"
inst_simple "$found" "$target/${found##*/}" inst_simple "$_found" "$_target/${_found##*/}"
fi fi
done done
[[ $found ]] || dinfo "Skipping udev rule: $rule" [[ $_found ]] || dinfo "Skipping udev rule: $_rule"
done done
} }


# general purpose installation function # general purpose installation function
# Same args as above. # Same args as above.
inst() { inst() {
local _x

case $# in case $# in
1) ;; 1) ;;
2) [[ ! $initdir && -d $2 ]] && export initdir=$2 2) [[ ! $initdir && -d $2 ]] && export initdir=$2
@ -432,8 +439,8 @@ inst() {
*) dfatal "inst only takes 1 or 2 or 3 arguments" *) dfatal "inst only takes 1 or 2 or 3 arguments"
exit 1;; exit 1;;
esac esac
for x in inst_symlink inst_script inst_binary inst_simple; do for _x in inst_symlink inst_script inst_binary inst_simple; do
$x "$@" && return 0 $_x "$@" && return 0
done done
return 1 return 1
} }
@ -460,13 +467,14 @@ inst_hook() {
} }


dracut_install() { dracut_install() {
local _optional=no
if [[ $1 = '-o' ]]; then if [[ $1 = '-o' ]]; then
local optional=yes _optional=yes
shift shift
fi fi
while (($# > 0)); do while (($# > 0)); do
if ! inst "$1" ; then if ! inst "$1" ; then
if [[ $optional = yes ]]; then if [[ $_optional = yes ]]; then
dwarn "Skipping program $1 as it cannot be found and is" \ dwarn "Skipping program $1 as it cannot be found and is" \
"flagged to be optional" "flagged to be optional"
else else
@ -484,32 +492,32 @@ dracut_install() {
# Function install targets in the same paths inside overlay but decompressed # Function install targets in the same paths inside overlay but decompressed
# and without extensions (.gz, .bz2). # and without extensions (.gz, .bz2).
inst_decompress() { inst_decompress() {
local src dst realsrc realdst cmd local _src _dst _realsrc _realdst _cmd


for src in $@ for _src in $@
do do
case ${src} in case ${_src} in
*.gz) cmd='gzip -d' ;; *.gz) _cmd='gzip -d' ;;
*.bz2) cmd='bzip2 -d' ;; *.bz2) _cmd='bzip2 -d' ;;
*) return 1 ;; *) return 1 ;;
esac esac


if [[ -L ${src} ]] if [[ -L ${_src} ]]
then then
realsrc="$(readlink -f ${src})" # symlink target with extension _realsrc="$(readlink -f ${_src})" # symlink target with extension
dst="${src%.*}" # symlink without extension _dst="${_src%.*}" # symlink without extension
realdst="${realsrc%.*}" # symlink target without extension _realdst="${_realsrc%.*}" # symlink target without extension
mksubdirs "${initdir}/${src}" mksubdirs "${initdir}/${_src}"
# Create symlink without extension to target without extension. # Create symlink without extension to target without extension.
ln -sfn "${realdst}" "${initdir}/${dst}" ln -sfn "${_realdst}" "${initdir}/${_dst}"
fi fi


# If the source is symlink we operate on its target. # If the source is symlink we operate on its target.
[[ ${realsrc} ]] && src=${realsrc} [[ ${_realsrc} ]] && _src=${_realsrc}
inst ${src} inst ${_src}
# Decompress with chosen tool. We assume that tool changes name e.g. # Decompress with chosen tool. We assume that tool changes name e.g.
# from 'name.gz' to 'name'. # from 'name.gz' to 'name'.
${cmd} "${initdir}${src}" ${_cmd} "${initdir}${_src}"
done done
} }


@ -517,174 +525,180 @@ inst_decompress() {
# install. # install.
# $@ = list of files # $@ = list of files
inst_opt_decompress() { inst_opt_decompress() {
local src local _src


for src in $@ for _src in $@
do do
inst_decompress "${src}" || inst "${src}" inst_decompress "${_src}" || inst "${_src}"
done done
} }


module_check() { module_check() {
local moddir=$(echo ${dracutbasedir}/modules.d/??${1}) local _moddir=$(echo ${dracutbasedir}/modules.d/??${1})
[[ -d $moddir ]] || return 1 local _ret
if [[ ! -f $moddir/module-setup.sh ]]; then [[ -d $_moddir ]] || return 1
if [[ ! -f $_moddir/module-setup.sh ]]; then
# if we do not have a check script, we are unconditionally included # if we do not have a check script, we are unconditionally included
[[ -x $moddir/check ]] || return 0 [[ -x $_moddir/check ]] || return 0
$moddir/check $hostonly $_moddir/check $hostonly
return $? return $?
else else
unset check depends install installkernel unset check depends install installkernel
. $moddir/module-setup.sh . $_moddir/module-setup.sh
is_func check || return 0 is_func check || return 0
check check
ret=$? _ret=$?
unset check depends install installkernel unset check depends install installkernel
return $ret return $_ret
fi fi
} }


module_depends() { module_depends() {
local moddir=$(echo ${dracutbasedir}/modules.d/??${1}) local _moddir=$(echo ${dracutbasedir}/modules.d/??${1})
[[ -d $moddir ]] || return 1 local _ret
if [[ ! -f $moddir/module-setup.sh ]]; then [[ -d $_moddir ]] || return 1
if [[ ! -f $_moddir/module-setup.sh ]]; then
# if we do not have a check script, we have no deps # if we do not have a check script, we have no deps
[[ -x $moddir/check ]] || return 0 [[ -x $_moddir/check ]] || return 0
$moddir/check -d $_moddir/check -d
return $? return $?
else else
unset check depends install installkernel unset check depends install installkernel
. $moddir/module-setup.sh . $_moddir/module-setup.sh
is_func depends || return 0 is_func depends || return 0
depends depends
ret=$? _ret=$?
unset check depends install installkernel unset check depends install installkernel
return $ret return $_ret
fi fi
} }


module_install() { module_install() {
local moddir=$(echo ${dracutbasedir}/modules.d/??${1}) local _moddir=$(echo ${dracutbasedir}/modules.d/??${1})
[[ -d $moddir ]] || return 1 local _ret
if [[ ! -f $moddir/module-setup.sh ]]; then [[ -d $_moddir ]] || return 1
[[ -x $moddir/install ]] && . "$moddir/install" if [[ ! -f $_moddir/module-setup.sh ]]; then
[[ -x $_moddir/install ]] && . "$_moddir/install"
return $? return $?
else else
unset check depends install installkernel unset check depends install installkernel
. $moddir/module-setup.sh . $_moddir/module-setup.sh
is_func install || return 0 is_func install || return 0
install install
ret=$? _ret=$?
unset check depends install installkernel unset check depends install installkernel
return $ret return $_ret
fi fi
} }


module_installkernel() { module_installkernel() {
local moddir=$(echo ${dracutbasedir}/modules.d/??${1}) local _moddir=$(echo ${dracutbasedir}/modules.d/??${1})
[[ -d $moddir ]] || return 1 local _ret
if [[ ! -f $moddir/module-setup.sh ]]; then [[ -d $_moddir ]] || return 1
[[ -x $moddir/installkernel ]] && . "$moddir/installkernel" if [[ ! -f $_moddir/module-setup.sh ]]; then
[[ -x $_moddir/installkernel ]] && . "$_moddir/installkernel"
return $? return $?
else else
unset check depends install installkernel unset check depends install installkernel
. $moddir/module-setup.sh . $_moddir/module-setup.sh
is_func installkernel || return 0 is_func installkernel || return 0
installkernel installkernel
ret=$? _ret=$?
unset check depends install installkernel unset check depends install installkernel
return $ret return $_ret
fi fi
} }


check_module() { check_module() {
local mod=$1; local _mod=$1
local moddir=$(echo ${dracutbasedir}/modules.d/??${1}) local _moddir=$(echo ${dracutbasedir}/modules.d/??${1})
local moddep; local _ret
local _moddep
# If we are already scheduled to be loaded, no need to check again. # If we are already scheduled to be loaded, no need to check again.
strstr " $mods_to_load " " $mod " && return 0 strstr " $mods_to_load " " $_mod " && return 0
strstr " $mods_checked_as_dep " " $mod " && return 1 strstr " $mods_checked_as_dep " " $_mod " && return 1


# This should never happen, but... # This should never happen, but...
[[ -d $moddir ]] || return 1 [[ -d $_moddir ]] || return 1


[[ $2 ]] || mods_checked_as_dep+=" $mod " [[ $2 ]] || mods_checked_as_dep+=" $_mod "


strstr " $omit_dracutmodules " " $mod " && return 1 strstr " $omit_dracutmodules " " $_mod " && return 1


if strstr " $dracutmodules $add_dracutmodules " " $mod "; then if strstr " $dracutmodules $add_dracutmodules " " $_mod "; then
module_check $mod; ret=$? module_check $_mod; ret=$?
# explicit module, so also accept ret=255 # explicit module, so also accept ret=255
[[ $ret = 0 || $ret = 255 ]] || return 1 [[ $ret = 0 || $ret = 255 ]] || return 1
else else
# module not in our list # module not in our list
if [[ $dracutmodules = all ]]; then if [[ $dracutmodules = all ]]; then
# check, if we can and should install this module # check, if we can and should install this module
module_check $mod || return 1 module_check $_mod || return 1
else else
# skip this module # skip this module
return 1 return 1
fi fi
fi fi


for moddep in $(module_depends $mod); do for _moddep in $(module_depends $_mod); do
# handle deps as if they were manually added # handle deps as if they were manually added
strstr " $add_dracutmodules " " $moddep " || \ strstr " $add_dracutmodules " " $_moddep " || \
add_dracutmodules+=" $moddep " add_dracutmodules+=" $_moddep "
# if a module we depend on fail, fail also # if a module we depend on fail, fail also
check_module $moddep || return 1 check_module $_moddep || return 1
done done


strstr " $mods_to_load " " $mod " || \ strstr " $mods_to_load " " $_mod " || \
mods_to_load+=" $mod " mods_to_load+=" $_mod "


return 0 return 0
} }


check_module_dir() { check_module_dir() {
local modcheck; local _modcheck
local mod; local _mod
local _moddir
mods_to_load="" mods_to_load=""
for moddir in "$dracutbasedir/modules.d"/[0-9][0-9]*; do for _moddir in "$dracutbasedir/modules.d"/[0-9][0-9]*; do
local mod=${moddir##*/}; mod=${mod#[0-9][0-9]} _mod=${_moddir##*/}; _mod=${_mod#[0-9][0-9]}
check_module $mod 1 check_module $_mod 1
done done


# Report any missing dracut modules, the user has specified # Report any missing dracut modules, the user has specified
modcheck=$add_dracutmodules _modcheck=$add_dracutmodules
[[ $dracutmodules != all ]] && modcheck="$m $dracutmodules" [[ $dracutmodules != all ]] && _modcheck="$m $dracutmodules"
for mod in $modcheck; do for _mod in $_modcheck; do
strstr "$mods_to_load" "$mod" && continue strstr "$mods_to_load" "$_mod" && continue
strstr "$omit_dracutmodules" "$mod" && continue strstr "$omit_dracutmodules" "$_mod" && continue
derror "Dracut module \"$mod\" cannot be found." derror "Dracut module \"$_mod\" cannot be found."
done done
} }


# Install a single kernel module along with any firmware it may require. # Install a single kernel module along with any firmware it may require.
# $1 = full path to kernel module to install # $1 = full path to kernel module to install
install_kmod_with_fw() { install_kmod_with_fw() {
local modname=${1##*/} fwdir found local _modname=${1##*/} _fwdir _found _fw
modname=${modname%.ko*} _modname=${_modname%.ko*}
# no need to go further if the module is already installed # no need to go further if the module is already installed
[[ -e "${initdir}/lib/modules/$kernel/${1##*/lib/modules/$kernel/}" ]] \ [[ -e "${initdir}/lib/modules/$kernel/${1##*/lib/modules/$kernel/}" ]] \
&& return 0 && return 0
inst_simple "$1" "/lib/modules/$kernel/${1##*/lib/modules/$kernel/}" \ inst_simple "$1" "/lib/modules/$kernel/${1##*/lib/modules/$kernel/}" \
|| return $? || return $?
for fw in $(modinfo -k $kernel -F firmware $1 2>/dev/null); do for _fw in $(modinfo -k $kernel -F firmware $1 2>/dev/null); do
found='' _found=''
for fwdir in $fw_dir; do for _fwdir in $fw_dir; do
if [[ -d $fwdir && -f $fwdir/$fw ]]; then if [[ -d $_fwdir && -f $_fwdir/$_fw ]]; then
inst_simple "$fwdir/$fw" "/lib/firmware/$fw" inst_simple "$_fwdir/$_fw" "/lib/firmware/$_fw"
found=yes _found=yes
fi fi
done done
if [[ $found != yes ]]; then if [[ $_found != yes ]]; then
if ! grep -qe "\<${modname//-/_}\>" /proc/modules; then if ! grep -qe "\<${_modname//-/_}\>" /proc/modules; then
dinfo "Possible missing firmware \"${fw}\" for kernel module" \ dinfo "Possible missing firmware \"${_fw}\" for kernel module" \
"\"${modname}.ko\"" "\"${_modname}.ko\""
else else
dwarn "Possible missing firmware \"${fw}\" for kernel module" \ dwarn "Possible missing firmware \"${_fw}\" for kernel module" \
"\"${modname}.ko\"" "\"${_modname}.ko\""
fi fi
fi fi
done done
@ -698,16 +712,15 @@ install_kmod_with_fw() {
# $2 = module to get dependencies for # $2 = module to get dependencies for
# rest of args = arguments to modprobe # rest of args = arguments to modprobe
for_each_kmod_dep() { for_each_kmod_dep() {
local func=$1 kmod=$2 cmd modpapth options local _func=$1 _kmod=$2 _cmd _modpath _options _found=0
shift 2 shift 2
modprobe "$@" --ignore-install --show-depends $kmod 2>/dev/null | ( modprobe "$@" --ignore-install --show-depends $_kmod 2>/dev/null | (
local found=0 while read _cmd _modpath _options; do
while read cmd modpath options; do [[ $_cmd = insmod ]] || continue
[[ $cmd = insmod ]] || continue $_func ${_modpath} || exit $?
$func ${modpath} || exit $? _found=1
found=1
done done
[[ $found -eq 0 ]] && exit 1 [[ $_found -eq 0 ]] && exit 1
exit 0 exit 0
) )
return $? return $?
@ -722,19 +735,20 @@ for_each_kmod_dep() {
# If it is not, we will look at all kernel modules # If it is not, we will look at all kernel modules
# This function returns the full filenames of modules that match $1 # This function returns the full filenames of modules that match $1
filter_kernel_modules () ( filter_kernel_modules () (
local _modname _filtercmd
if ! [[ $hostonly ]]; then if ! [[ $hostonly ]]; then
filtercmd='find "$srcmods/kernel/drivers" "$srcmods/extra"' _filtercmd='find "$srcmods/kernel/drivers" "$srcmods/extra"'
filtercmd+=' "$srcmods/weak-updates" -name "*.ko" -o -name "*.ko.gz"' _filtercmd+=' "$srcmods/weak-updates" -name "*.ko" -o -name "*.ko.gz"'
filtercmd+=' 2>/dev/null' _filtercmd+=' 2>/dev/null'
else else
filtercmd='cut -d " " -f 1 </proc/modules|xargs modinfo -F filename ' _filtercmd='cut -d " " -f 1 </proc/modules|xargs modinfo -F filename '
filtercmd+='-k $kernel 2>/dev/null' _filtercmd+='-k $kernel 2>/dev/null'
fi fi
for modname in $(eval $filtercmd); do for _modname in $(eval $_filtercmd); do
case $modname in case $_modname in
*.ko) "$1" "$modname" && echo "$modname";; *.ko) "$1" "$_modname" && echo "$_modname";;
*.ko.gz) gzip -dc "$modname" > $initdir/$$.ko *.ko.gz) gzip -dc "$_modname" > $initdir/$$.ko
$1 $initdir/$$.ko && echo "$modname" $1 $initdir/$$.ko && echo "$_modname"
rm -f $initdir/$$.ko rm -f $initdir/$$.ko
;; ;;
esac esac
@ -744,52 +758,52 @@ filter_kernel_modules () (
# install kernel modules along with all their dependencies. # install kernel modules along with all their dependencies.
instmods() { instmods() {
[[ $no_kernel = yes ]] && return [[ $no_kernel = yes ]] && return
local mod mpargs modpath modname cmd moddirname local _mod _mpargs _moddirname
local ret=0 local _ret=0
while (($# > 0)); do while (($# > 0)); do
mod=${1%.ko*} _mod=${1%.ko*}
case $mod in case $_mod in
=*) =*)
# This introduces 2 incompatible meanings for =* arguments # This introduces 2 incompatible meanings for =* arguments
# to instmods. We need to decide which one to keep. # to instmods. We need to decide which one to keep.
if [[ $mod = =ata && -f $srcmods/modules.block ]]; then if [[ $_mod = =ata && -f $srcmods/modules.block ]]; then
instmods $mpargs \ instmods $_mpargs \
$(egrep 'ata|ahci' "${srcmods}/modules.block") $(egrep 'ata|ahci' "${srcmods}/modules.block")
elif [ -f $srcmods/modules.${mod#=} ]; then elif [ -f $srcmods/modules.${_mod#=} ]; then
instmods $mpargs $(cat ${srcmods}/modules.${mod#=} ) instmods $_mpargs $(cat ${srcmods}/modules.${_mod#=} )
else else
instmods $mpargs $(find "$srcmods" -path "*/${mod#=}/*") instmods $_mpargs $(find "$srcmods" -path "*/${_mod#=}/*")
fi fi
;; ;;
--*) --*)
mod=${mod##*/} _mod=${_mod##*/}
mpargs+=" $mod";; _mpargs+=" $_mod";;
i2o_scsi) shift; continue;; # Do not load this diagnostic-only module i2o_scsi) shift; continue;; # Do not load this diagnostic-only module
*) mod=${mod##*/} *) _mod=${_mod##*/}
# if we are already installed, skip this module and go on # if we are already installed, skip this module and go on
# to the next one. # to the next one.
[[ -f $initdir/$1 ]] && { shift; continue; } [[ -f $initdir/$1 ]] && { shift; continue; }
# If we are building a host-specific initramfs and this # If we are building a host-specific initramfs and this
# module is not already loaded, move on to the next one. # module is not already loaded, move on to the next one.
[[ $hostonly ]] && ! grep -qe "\<${mod//-/_}\>" /proc/modules \ [[ $hostonly ]] && ! grep -qe "\<${_mod//-/_}\>" /proc/modules \
&& ! echo $add_drivers | grep -qe "\<${mod}\>" && { && ! echo $add_drivers | grep -qe "\<${_mod}\>" && {
shift; continue shift; continue
} }


# We use '-d' option in modprobe only if modules prefix path # We use '-d' option in modprobe only if modules prefix path
# differs from default '/'. This allows us to use Dracut with # differs from default '/'. This allows us to use Dracut with
# old version of modprobe which doesn't have '-d' option. # old version of modprobe which doesn't have '-d' option.
moddirname=${srcmods%%/lib/modules/*} _moddirname=${srcmods%%/lib/modules/*}
[[ -n ${moddirname} ]] && moddirname="-d ${moddirname}/" [[ -n ${_moddirname} ]] && _moddirname="-d ${_moddirname}/"


# ok, load the module, all its dependencies, and any firmware # ok, load the module, all its dependencies, and any firmware
# it may require # it may require
for_each_kmod_dep install_kmod_with_fw $mod \ for_each_kmod_dep install_kmod_with_fw $_mod \
--set-version $kernel ${moddirname} --set-version $kernel ${_moddirname}
((ret+=$?)) ((_ret+=$?))
;; ;;
esac esac
shift shift
done done
return $ret return $_ret
} }

24
modules.d/01fips/module-setup.sh
View File

@ -11,31 +11,33 @@ depends() {
} }


installkernel() { installkernel() {
FIPSMODULES="aead aes_generici aes-xts aes-x86_64 ansi_cprng cbc ccm chainiv ctr" local _fipsmodules _mod
FIPSMODULES="$FIPSMODULES des deflate ecb eseqiv hmac seqiv sha256 sha512" _fipsmodules="aead aes_generici aes-xts aes-x86_64 ansi_cprng cbc ccm chainiv ctr"
FIPSMODULES="$FIPSMODULES cryptomgr crypto_null tcrypt" _fipsmodules+=" des deflate ecb eseqiv hmac seqiv sha256 sha512"
_fipsmodules+=" cryptomgr crypto_null tcrypt"


mkdir -m 0755 -p "${initdir}/etc/modprobe.d" mkdir -m 0755 -p "${initdir}/etc/modprobe.d"


for mod in $FIPSMODULES; do for _mod in $_fipsmodules; do
if instmods $mod; then if instmods $_mod; then
echo $mod >> "${initdir}/etc/fipsmodules" echo $_mod >> "${initdir}/etc/fipsmodules"
echo "blacklist $mod" >> "${initdir}/etc/modprobe.d/fips.conf" echo "blacklist $_mod" >> "${initdir}/etc/modprobe.d/fips.conf"
fi fi
done done
} }


install() { install() {
local _dir
inst_hook pre-trigger 01 "$moddir/fips-boot.sh" inst_hook pre-trigger 01 "$moddir/fips-boot.sh"
inst_hook pre-pivot 01 "$moddir/fips-noboot.sh" inst_hook pre-pivot 01 "$moddir/fips-noboot.sh"
inst "$moddir/fips.sh" /sbin/fips.sh inst "$moddir/fips.sh" /sbin/fips.sh


dracut_install sha512hmac rmmod insmod mount uname umount dracut_install sha512hmac rmmod insmod mount uname umount


for dir in "$usrlibdir" "$libdir"; do for _dir in "$usrlibdir" "$libdir"; do
[[ -e $dir/libsoftokn3.so ]] && \ [[ -e $_dir/libsoftokn3.so ]] && \
dracut_install $dir/libsoftokn3.so $dir/libsoftokn3.chk \ dracut_install $_dir/libsoftokn3.so $_dir/libsoftokn3.chk \
$dir/libfreebl3.so $dir/libfreebl3.chk && \ $_dir/libfreebl3.so $_dir/libfreebl3.chk && \
break break
done done



13
modules.d/05busybox/module-setup.sh
View File

@ -13,21 +13,22 @@ depends() {
} }


install() { install() {
local _i _progs _path
inst busybox /sbin/busybox inst busybox /sbin/busybox


# List of shell programs that we use in other official dracut modules, that # List of shell programs that we use in other official dracut modules, that
# must be supported by the busybox installed on the host system # must be supported by the busybox installed on the host system
progs="echo grep usleep [ rmmod insmod mount uname umount setfont kbd_mode stty gzip bzip2 chvt readlink blkid dd losetup tr sed seq ps more cat rm free ping netstat vi ping6 fsck ip hostname basename mknod mkdir pidof sleep chroot ls cp mv dmesg mkfifo less ln modprobe" _progs="echo grep usleep [ rmmod insmod mount uname umount setfont kbd_mode stty gzip bzip2 chvt readlink blkid dd losetup tr sed seq ps more cat rm free ping netstat vi ping6 fsck ip hostname basename mknod mkdir pidof sleep chroot ls cp mv dmesg mkfifo less ln modprobe"


# FIXME: switch_root should be in the above list, but busybox version hangs # FIXME: switch_root should be in the above list, but busybox version hangs
# (using busybox-1.15.1-7.fc14.i686 at the time of writing) # (using busybox-1.15.1-7.fc14.i686 at the time of writing)


for i in $progs; do for _i in $_progs; do
path=$(find_binary "$i") _path=$(find_binary "$_i")
if [[ $path != ${path#/usr} ]]; then if [[ $_path != ${_path#/usr} ]]; then
ln -s ../../sbin/busybox "$initdir/$path" ln -s ../../sbin/busybox "$initdir/$_path"
else else
ln -s ../sbin/busybox "$initdir/$path" ln -s ../sbin/busybox "$initdir/$_path"
fi fi
done done



10
modules.d/10rpmversion/module-setup.sh
View File

@ -11,14 +11,16 @@ depends() {
} }


install() { install() {
local _line
local _dracut_rpm_version
if [ -e "$moddir/dracut-version" ]; then if [ -e "$moddir/dracut-version" ]; then
dracut_rpm_version=$(cat "$moddir/dracut-version") _dracut_rpm_version=$(cat "$moddir/dracut-version")
inst "$moddir/dracut-version" /lib/dracut/$dracut_rpm_version inst "$moddir/dracut-version" /lib/dracut/$_dracut_rpm_version
else else
if rpm -qf $(type -P $0) &>/dev/null; then if rpm -qf $(type -P $0) &>/dev/null; then
dracut_rpm_version=$(rpm -qf --qf '%{name}-%{version}-%{release}\n' $(type -P $0) | { ver="";while read line;do ver=$line;done;echo $ver;} ) _dracut_rpm_version=$(rpm -qf --qf '%{name}-%{version}-%{release}\n' $(type -P $0) | { ver="";while read _line;do ver=$_line;done;echo $ver;} )
mkdir -m 0755 -p $initdir/lib/dracut mkdir -m 0755 -p $initdir/lib/dracut
echo $dracut_rpm_version > $initdir/lib/dracut/$dracut_rpm_version echo $_dracut_rpm_version > $initdir/lib/dracut/$_dracut_rpm_version
fi fi
fi fi
inst_hook cmdline 01 "$moddir/version.sh" inst_hook cmdline 01 "$moddir/version.sh"

24
modules.d/40network/module-setup.sh
View File

@ -3,11 +3,12 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
local _program
. $dracutfunctions . $dracutfunctions


for program in ip arping dhclient ; do for _program in ip arping dhclient ; do
if ! type -P $program >/dev/null; then if ! type -P $_program >/dev/null; then
derror "Could not find program \"$program\" required by network." derror "Could not find program \"$_program\" required by network."
return 1 return 1
fi fi
done done
@ -24,11 +25,11 @@ installkernel() {
# Include wired net drivers, excluding wireless # Include wired net drivers, excluding wireless


net_module_test() { net_module_test() {
local net_drivers='eth_type_trans|register_virtio_device' local _net_drivers='eth_type_trans|register_virtio_device'
local unwanted_drivers='/(wireless|isdn|uwb)/' local _unwanted_drivers='/(wireless|isdn|uwb)/'
egrep -q $net_drivers "$1" && \ egrep -q $_net_drivers "$1" && \
egrep -qv 'iw_handler_get_spy' "$1" && \ egrep -qv 'iw_handler_get_spy' "$1" && \
[[ ! $1 =~ $unwanted_drivers ]] [[ ! $1 =~ $_unwanted_drivers ]]
} }


instmods $(filter_kernel_modules net_module_test) instmods $(filter_kernel_modules net_module_test)
@ -42,6 +43,7 @@ installkernel() {
} }


install() { install() {
local _arch _i _dir
dracut_install ip arping tr dhclient dracut_install ip arping tr dhclient
dracut_install -o brctl ifenslave dracut_install -o brctl ifenslave
inst "$moddir/ifup" "/sbin/ifup" inst "$moddir/ifup" "/sbin/ifup"
@ -57,12 +59,12 @@ install() {
inst_hook cmdline 99 "$moddir/parse-ifname.sh" inst_hook cmdline 99 "$moddir/parse-ifname.sh"
inst_hook pre-pivot 10 "$moddir/kill-dhclient.sh" inst_hook pre-pivot 10 "$moddir/kill-dhclient.sh"


arch=$(uname -m) _arch=$(uname -m)


for dir in "$usrlibdir/tls/$arch" "$usrlibdir/tls" "$usrlibdir/$arch" \ for _dir in "$usrlibdir/tls/$_arch" "$usrlibdir/tls" "$usrlibdir/$_arch" \
"$usrlibdir" "$libdir"; do "$usrlibdir" "$libdir"; do
for i in "$dir"/libnss_dns.so.* "$dir"/libnss_mdns4_minimal.so.*; do for _i in "$_dir"/libnss_dns.so.* "$_dir"/libnss_mdns4_minimal.so.*; do
[ -e "$i" ] && dracut_install "$i" [ -e "$_i" ] && dracut_install "$_i"
done done
done done



36
modules.d/50gensplash/module-setup.sh
View File

@ -13,55 +13,57 @@ depends() {
} }


install() { install() {
local _opts
local _splash_theme
local _splash_res

call_splash_geninitramfs() { call_splash_geninitramfs() {
local out ret local _out _ret


out=$(splash_geninitramfs -c "$1" ${@:2} 2>&1) _out=$(splash_geninitramfs -c "$1" ${@:2} 2>&1)
ret=$? _ret=$?


if [[ ${out} ]]; then if [[ ${_out} ]]; then
local IFS=' local IFS='
' '
for line in ${out}; do for line in ${_out}; do
if [[ ${line} =~ ^Warning ]]; then if [[ ${line} =~ ^Warning ]]; then
dwarn "${line}" dwarn "${line}"
else else
derror "${line}" derror "${line}"
(( ret == 0 )) && ret=1 (( $_ret == 0 )) && _ret=1
fi fi
done done
fi fi


return ${ret} return ${_ret}
} }



type -P splash_geninitramfs >/dev/null || return 1 type -P splash_geninitramfs >/dev/null || return 1


opts='' _opts=''

if [[ ${DRACUT_GENSPLASH_THEME} ]]; then if [[ ${DRACUT_GENSPLASH_THEME} ]]; then
# Variables from the environment # Variables from the environment
# They're supposed to be set up by e.g. Genkernel in basis of cmdline args. # They're supposed to be set up by e.g. Genkernel in basis of cmdline args.
# If user set them he/she would expect to be included only given theme # If user set them he/she would expect to be included only given theme
# rather then all even if we're building generic initramfs. # rather then all even if we're building generic initramfs.
SPLASH_THEME=${DRACUT_GENSPLASH_THEME} _splash_theme=${DRACUT_GENSPLASH_THEME}
SPLASH_RES=${DRACUT_GENSPLASH_RES} _splash_res=${DRACUT_GENSPLASH_RES}
elif [[ ${hostonly} ]]; then elif [[ ${hostonly} ]]; then
# Settings from config only in hostonly # Settings from config only in hostonly
[[ -e /etc/conf.d/splash ]] && source /etc/conf.d/splash [[ -e /etc/conf.d/splash ]] && source /etc/conf.d/splash
[[ ! ${SPLASH_THEME} ]] && SPLASH_THEME=default [[ ! ${_splash_theme} ]] && _splash_theme=default
[[ ${SPLASH_RES} ]] && opts+=" -r ${SPLASH_RES}" [[ ${_splash_res} ]] && _opts+=" -r ${_splash_res}"
else else
# generic # generic
SPLASH_THEME=--all _splash_theme=--all
fi fi


dinfo "Installing Gentoo Splash (using the ${SPLASH_THEME} theme)" dinfo "Installing Gentoo Splash (using the ${_splash_theme} theme)"


pushd "${initdir}" >/dev/null pushd "${initdir}" >/dev/null
mv dev dev.old mv dev dev.old
call_splash_geninitramfs "${initdir}" ${opts} ${SPLASH_THEME} || { call_splash_geninitramfs "${initdir}" ${_opts} ${_splash_theme} || {
derror "Could not build splash" derror "Could not build splash"
return 1 return 1
} }

5
modules.d/50plymouth/module-setup.sh
View File

@ -11,9 +11,10 @@ depends() {
} }


installkernel() { installkernel() {
local _modname
# Include KMS capable drm drivers # Include KMS capable drm drivers
for modname in $(find "$srcmods/kernel/drivers/gpu/drm" "$srcmods/extra" -name '*.ko' 2>/dev/null); do for _modname in $(find "$srcmods/kernel/drivers/gpu/drm" "$srcmods/extra" -name '*.ko' 2>/dev/null); do
grep -q drm_crtc_init $modname && instmods $modname grep -q drm_crtc_init $_modname && instmods $_modname
done done
} }



5
modules.d/60xen/module-setup.sh
View File

@ -23,11 +23,12 @@ depends() {
} }


installkernel() { installkernel() {
for i in \ local _i
for _i in \
xenbus_probe_frontend xen-pcifront \ xenbus_probe_frontend xen-pcifront \
xen-fbfront xen-kbdfront xen-blkfront xen-netfront \ xen-fbfront xen-kbdfront xen-blkfront xen-netfront \
; do ; do
modinfo -k $kernel $i >/dev/null 2>&1 && instmods $i modinfo -k $kernel $_i >/dev/null 2>&1 && instmods $_i
done done


} }

7
modules.d/90btrfs/module-setup.sh
View File

@ -3,6 +3,7 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
local _rootdev
# if we don't have btrfs installed on the host system, # if we don't have btrfs installed on the host system,
# no point in trying to support it in the initramfs. # no point in trying to support it in the initramfs.
type -P btrfs >/dev/null || return 1 type -P btrfs >/dev/null || return 1
@ -13,9 +14,9 @@ check() {
is_btrfs() { get_fs_type /dev/block/$1 | grep -q btrfs; } is_btrfs() { get_fs_type /dev/block/$1 | grep -q btrfs; }


if [[ $hostonly ]]; then if [[ $hostonly ]]; then
rootdev=$(find_root_block_device) _rootdev=$(find_root_block_device)
if [[ $rootdev ]]; then if [[ $_rootdev ]]; then
is_btrfs "$rootdev" || return 1 is_btrfs "$_rootdev" || return 1
fi fi
fi fi



7
modules.d/90crypt/module-setup.sh
View File

@ -3,6 +3,7 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
local _rootdev
# if cryptsetup is not installed, then we cannot support encrypted devices. # if cryptsetup is not installed, then we cannot support encrypted devices.
type -P cryptsetup >/dev/null || return 1 type -P cryptsetup >/dev/null || return 1


@ -11,11 +12,11 @@ check() {
is_crypt() { [[ $(get_fs_type /dev/block/$1) = crypto_LUKS ]]; } is_crypt() { [[ $(get_fs_type /dev/block/$1) = crypto_LUKS ]]; }


[[ $hostonly ]] && { [[ $hostonly ]] && {
rootdev=$(find_root_block_device) _rootdev=$(find_root_block_device)
if [[ $rootdev ]]; then if [[ $_rootdev ]]; then
# root lives on a block device, so we can be more precise about # root lives on a block device, so we can be more precise about
# hostonly checking # hostonly checking
check_block_and_slaves is_crypt "$rootdev" || return 1 check_block_and_slaves is_crypt "$_rootdev" || return 1
else else
# root is not on a block device, use the shotgun approach # root is not on a block device, use the shotgun approach
blkid | grep -q crypto\?_LUKS || return 1 blkid | grep -q crypto\?_LUKS || return 1

12
modules.d/90dmraid/module-setup.sh
View File

@ -3,6 +3,7 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
local _rootdev
# if we don't have dmraid installed on the host system, no point # if we don't have dmraid installed on the host system, no point
# in trying to support it in the initramfs. # in trying to support it in the initramfs.
type -P dmraid >/dev/null || return 1 type -P dmraid >/dev/null || return 1
@ -14,11 +15,11 @@ check() {
grep -q _raid_member; } grep -q _raid_member; }


[[ $hostonly ]] && { [[ $hostonly ]] && {
rootdev=$(find_root_block_device) _rootdev=$(find_root_block_device)
if [[ $rootdev ]]; then if [[ $_rootdev ]]; then
# root lives on a block device, so we can be more precise about # root lives on a block device, so we can be more precise about
# hostonly checking # hostonly checking
check_block_and_slaves is_dmraid "$rootdev" || return 1 check_block_and_slaves is_dmraid "$_rootdev" || return 1
else else
# root is not on a block device, use the shotgun approach # root is not on a block device, use the shotgun approach
dmraid -r | grep -q ok || return 1 dmraid -r | grep -q ok || return 1
@ -34,12 +35,13 @@ depends() {
} }


install() { install() {
local _i
dracut_install dmraid partx kpartx dracut_install dmraid partx kpartx


inst dmeventd inst dmeventd


for i in {"$libdir","$usrlibdir"}/libdmraid-events*.so; do for _i in {"$libdir","$usrlibdir"}/libdmraid-events*.so; do
[ -e "$i" ] && dracut_install "$i" [ -e "$_i" ] && dracut_install "$_i"
done done


inst_rules 10-dm.rules 13-dm-disk.rules 95-dm-notify.rules inst_rules 10-dm.rules 13-dm-disk.rules 95-dm-notify.rules

5
modules.d/90kernel-modules/module-setup.sh
View File

@ -42,6 +42,7 @@ installkernel() {
} }


install() { install() {
local _f
[ -f /etc/modprobe.conf ] && dracut_install /etc/modprobe.conf [ -f /etc/modprobe.conf ] && dracut_install /etc/modprobe.conf
dracut_install $(find /etc/modprobe.d/ -type f -name '*.conf') dracut_install $(find /etc/modprobe.d/ -type f -name '*.conf')
inst_hook cmdline 01 "$moddir/parse-kernel.sh" inst_hook cmdline 01 "$moddir/parse-kernel.sh"
@ -49,8 +50,8 @@ install() {


local f local f


for f in modules.builtin.bin modules.builtin; do for _f in modules.builtin.bin modules.builtin; do
[[ $srcmods/$f ]] && inst "$srcmods/$f" "/lib/modules/$kernel/$f" \ [[ $srcmods/$_f ]] && inst "$srcmods/$_f" "/lib/modules/$kernel/$_f" \
&& break && break
done || { done || {
dfatal "No modules.builtin.bin and modules.builtin found!" dfatal "No modules.builtin.bin and modules.builtin found!"

12
modules.d/90lvm/module-setup.sh
View File

@ -3,6 +3,7 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
local _rootdev
# No point trying to support lvm if the binaries are missing # No point trying to support lvm if the binaries are missing
type -P lvm >/dev/null || return 1 type -P lvm >/dev/null || return 1


@ -12,11 +13,11 @@ check() {
is_lvm() { [[ $(get_fs_type /dev/block/$1) = LVM2_member ]]; } is_lvm() { [[ $(get_fs_type /dev/block/$1) = LVM2_member ]]; }


[[ $hostonly ]] && { [[ $hostonly ]] && {
rootdev=$(find_root_block_device) _rootdev=$(find_root_block_device)
if [[ $rootdev ]]; then if [[ $_rootdev ]]; then
# root lives on a block device, so we can be more precise about # root lives on a block device, so we can be more precise about
# hostonly checking # hostonly checking
check_block_and_slaves is_lvm "$rootdev" || return 1 check_block_and_slaves is_lvm "$_rootdev" || return 1
else else
# root is not on a block device, use the shotgun approach # root is not on a block device, use the shotgun approach
blkid | grep -q LVM2_member || return 1 blkid | grep -q LVM2_member || return 1
@ -33,6 +34,7 @@ depends() {
} }


install() { install() {
local _i
inst lvm inst lvm


inst_rules "$moddir/64-lvm.rules" inst_rules "$moddir/64-lvm.rules"
@ -54,8 +56,8 @@ install() {
inst "$moddir/lvm_scan.sh" /sbin/lvm_scan inst "$moddir/lvm_scan.sh" /sbin/lvm_scan
inst_hook cmdline 30 "$moddir/parse-lvm.sh" inst_hook cmdline 30 "$moddir/parse-lvm.sh"


for i in {"$libdir","$usrlibdir"}/libdevmapper-event-lvm*.so; do for _i in {"$libdir","$usrlibdir"}/libdevmapper-event-lvm*.so; do
[ -e "$i" ] && dracut_install "$i" [ -e "$_i" ] && dracut_install "$_i"
done done
} }



7
modules.d/90mdraid/module-setup.sh
View File

@ -3,6 +3,7 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
local _rootdev
# No mdadm? No mdraid support. # No mdadm? No mdraid support.
type -P mdadm >/dev/null || return 1 type -P mdadm >/dev/null || return 1


@ -12,11 +13,11 @@ check() {
is_mdraid() { [[ -d "/sys/dev/block/$1/md" ]]; } is_mdraid() { [[ -d "/sys/dev/block/$1/md" ]]; }


[[ $hostonly ]] && { [[ $hostonly ]] && {
rootdev=$(find_root_block_device) _rootdev=$(find_root_block_device)
if [[ $rootdev ]]; then if [[ $_rootdev ]]; then
# root lives on a block device, so we can be more precise about # root lives on a block device, so we can be more precise about
# hostonly checking # hostonly checking
check_block_and_slaves is_mdraid "$rootdev" || return 1 check_block_and_slaves is_mdraid "$_rootdev" || return 1
else else
# root is not on a block device, use the shotgun approach # root is not on a block device, use the shotgun approach
blkid | egrep -q '(linux|isw)_raid' || return 1 blkid | egrep -q '(linux|isw)_raid' || return 1

12
modules.d/90multipath/module-setup.sh
View File

@ -3,6 +3,7 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
local _rootdev
# if there's no multipath binary, no go. # if there's no multipath binary, no go.
type -P multipath >/dev/null || return 1 type -P multipath >/dev/null || return 1


@ -16,9 +17,9 @@ check() {
} }


if [[ $hostonly ]]; then if [[ $hostonly ]]; then
rootdev=$(find_root_block_device) _rootdev=$(find_root_block_device)
if [[ $rootdev ]]; then if [[ $_rootdev ]]; then
check_block_and_slaves is_mpath "$rootdev" && return 0 check_block_and_slaves is_mpath "$_rootdev" && return 0
fi fi
return 1 return 1
fi fi
@ -41,7 +42,8 @@ installkernel() {
} }


install() { install() {
for f in \ local _f
for _f in \
/sbin/dmsetup \ /sbin/dmsetup \
/sbin/kpartx \ /sbin/kpartx \
/sbin/mpath_wait \ /sbin/mpath_wait \
@ -53,7 +55,7 @@ install() {
/etc/multipath.conf \ /etc/multipath.conf \
/etc/multipath/* \ /etc/multipath/* \
"$libdir"/libmultipath* "$libdir"/multipath/*; do "$libdir"/libmultipath* "$libdir"/multipath/*; do
[ -e "$f" ] && inst "$f" [ -e "$_f" ] && inst "$_f"
done done


inst_hook pre-trigger 02 "$moddir/multipathd.sh" inst_hook pre-trigger 02 "$moddir/multipathd.sh"

4
modules.d/95dasd/module-setup.sh
View File

@ -3,8 +3,8 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
arch=$(uname -m) local _arch=$(uname -m)
[ "$arch" = "s390" -o "$arch" = "s390x" ] || return 1 [ "$_arch" = "s390" -o "$_arch" = "s390x" ] || return 1
return 0 return 0
} }



4
modules.d/95dasd_mod/module-setup.sh
View File

@ -3,8 +3,8 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
arch=$(uname -m) local _arch=$(uname -m)
[ "$arch" = "s390" -o "$arch" = "s390x" ] || return 1 [ "$_arch" = "s390" -o "$_arch" = "s390x" ] || return 1


return 0 return 0
} }

11
modules.d/95iscsi/module-setup.sh
View File

@ -3,6 +3,7 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
local _rootdev
# If our prerequisites are not met, fail anyways. # If our prerequisites are not met, fail anyways.
type -P iscsistart hostname iscsi-iname >/dev/null || return 1 type -P iscsistart hostname iscsi-iname >/dev/null || return 1


@ -23,11 +24,11 @@ check() {
) )


[[ $hostonly ]] && { [[ $hostonly ]] && {
rootdev=$(find_root_block_device) _rootdev=$(find_root_block_device)
if [[ $rootdev ]]; then if [[ $_rootdev ]]; then
# root lives on a block device, so we can be more precise about # root lives on a block device, so we can be more precise about
# hostonly checking # hostonly checking
check_block_and_slaves is_iscsi "$rootdev" || return 1 check_block_and_slaves is_iscsi "$_rootdev" || return 1
else else
return 1 return 1
fi fi
@ -42,8 +43,8 @@ depends() {
installkernel() { installkernel() {
instmods iscsi_tcp iscsi_ibft crc32c instmods iscsi_tcp iscsi_ibft crc32c
iscsi_module_test() { iscsi_module_test() {
local iscsifuncs='iscsi_register_transport' local _iscsifuncs='iscsi_register_transport'
fgrep -q "$iscsifuncs" "$1" fgrep -q "$_iscsifuncs" "$1"
} }
instmods $(filter_kernel_modules iscsi_module_test) instmods $(filter_kernel_modules iscsi_module_test)
} }

7
modules.d/95nbd/module-setup.sh
View File

@ -3,6 +3,7 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


check() { check() {
local _rootdev
# If our prerequisites are not met, fail. # If our prerequisites are not met, fail.
type -P nbd-client >/dev/null || return 1 type -P nbd-client >/dev/null || return 1


@ -12,9 +13,9 @@ check() {
is_nbd() { [[ -b /dev/block/$1 && $1 == 43:* ]] ;} is_nbd() { [[ -b /dev/block/$1 && $1 == 43:* ]] ;}
. $dracutfunctions . $dracutfunctions


rootdev=$(find_root_block_device) _rootdev=$(find_root_block_device)
[[ -b /dev/block/$rootdev ]] || return 1 [[ -b /dev/block/$_rootdev ]] || return 1
check_block_and_slaves is_nbd "$rootdev" || return 1 check_block_and_slaves is_nbd "$_rootdev" || return 1
} }


return 0 return 0

14
modules.d/95nfs/module-setup.sh
View File

@ -23,6 +23,8 @@ installkernel() {
} }


install() { install() {
local _i
local _nsslibs
type -P portmap >/dev/null && dracut_install portmap type -P portmap >/dev/null && dracut_install portmap
type -P rpcbind >/dev/null && dracut_install rpcbind type -P rpcbind >/dev/null && dracut_install rpcbind


@ -33,18 +35,18 @@ install() {
dracut_install rpc.idmapd /etc/idmapd.conf dracut_install rpc.idmapd /etc/idmapd.conf
dracut_install sed dracut_install sed


for i in {"$libdir","$usrlibdir"}/libnfsidmap_nsswitch.so* \ for _i in {"$libdir","$usrlibdir"}/libnfsidmap_nsswitch.so* \
{"$libdir","$usrlibdir"}/libnfsidmap/*.so \ {"$libdir","$usrlibdir"}/libnfsidmap/*.so \
{"$libdir","$usrlibdir"}/libnfsidmap*.so*; do {"$libdir","$usrlibdir"}/libnfsidmap*.so*; do
[ -e "$i" ] && dracut_install "$i" [ -e "$_i" ] && dracut_install "$_i"
done done


nsslibs=$(sed -e '/^#/d' -e 's/^.*://' -e 's/\[NOTFOUND=return\]//' /etc/nsswitch.conf \ _nsslibs=$(sed -e '/^#/d' -e 's/^.*://' -e 's/\[NOTFOUND=return\]//' /etc/nsswitch.conf \
| tr -s '[:space:]' '\n' | sort -u | tr -s '[:space:]' '|') | tr -s '[:space:]' '\n' | sort -u | tr -s '[:space:]' '|')
nsslibs=${nsslibs#|} _nsslibs=${_nsslibs#|}
nsslibs=${nsslibs%|} _nsslibs=${_nsslibs%|}


dracut_install $(for i in $(ls {/usr,}$libdir/libnss*.so 2>/dev/null); do echo $i;done | egrep "$nsslibs") dracut_install $(for _i in $(ls {/usr,}$libdir/libnss*.so 2>/dev/null); do echo $_i;done | egrep "$_nsslibs")


inst_hook cmdline 90 "$moddir/parse-nfsroot.sh" inst_hook cmdline 90 "$moddir/parse-nfsroot.sh"
inst_hook pre-pivot 99 "$moddir/nfsroot-cleanup.sh" inst_hook pre-pivot 99 "$moddir/nfsroot-cleanup.sh"

7
modules.d/95resume/module-setup.sh
View File

@ -3,11 +3,12 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


install() { install() {
local _bin
# Optional uswsusp support # Optional uswsusp support
for bin in /usr/sbin/resume /usr/lib/suspend/resume for _bin in /usr/sbin/resume /usr/lib/suspend/resume
do do
[[ -x "${bin}" ]] && { [[ -x "${_bin}" ]] && {
inst "${bin}" /usr/sbin/resume inst "${_bin}" /usr/sbin/resume
[[ -f /etc/suspend.conf ]] && inst /etc/suspend.conf [[ -f /etc/suspend.conf ]] && inst /etc/suspend.conf
break break
} }

9
modules.d/95terminfo/module-setup.sh
View File

@ -3,12 +3,13 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


install() { install() {
local _terminfodir
# terminfo bits make things work better if you fall into interactive mode # terminfo bits make things work better if you fall into interactive mode
for TERMINFODIR in /lib/terminfo /etc/terminfo /usr/share/terminfo; do for _terminfodir in /lib/terminfo /etc/terminfo /usr/share/terminfo; do
[ -d ${TERMINFODIR} ] && break [ -d ${_terminfodir} ] && break
done done


[ -d ${TERMINFODIR} ] && \ [ -d ${_terminfodir} ] && \
dracut_install $(find ${TERMINFODIR} -type f) dracut_install $(find ${_terminfodir} -type f)
} }



9
modules.d/95udev-rules/module-setup.sh
View File

@ -3,6 +3,7 @@
# ex: ts=8 sw=4 sts=4 et filetype=sh # ex: ts=8 sw=4 sts=4 et filetype=sh


install() { install() {
local _i
# FIXME: would be nice if we didn't have to know which rules to grab.... # FIXME: would be nice if we didn't have to know which rules to grab....
# ultimately, /lib/initramfs/rules.d or somesuch which includes links/copies # ultimately, /lib/initramfs/rules.d or somesuch which includes links/copies
# of the rules we want so that we just copy those in would be best # of the rules we want so that we just copy those in would be best
@ -33,7 +34,7 @@ install() {
fi fi
inst_rules "$moddir/61-persistent-storage.rules" inst_rules "$moddir/61-persistent-storage.rules"


for i in \ for _i in \
ata_id \ ata_id \
cdrom_id \ cdrom_id \
create_floppy_devices \ create_floppy_devices \
@ -51,14 +52,14 @@ install() {
pcmcia-socket-startup \ pcmcia-socket-startup \
pcmcia-check-broken-cis \ pcmcia-check-broken-cis \
; do ; do
[ -e /lib/udev/$i ] && dracut_install /lib/udev/$i [ -e /lib/udev/$_i ] && dracut_install /lib/udev/$_i
done done


[ -f /etc/arch-release ] && \ [ -f /etc/arch-release ] && \
inst "$moddir/load-modules.sh" /lib/udev/load-modules.sh inst "$moddir/load-modules.sh" /lib/udev/load-modules.sh


for i in {"$libdir","$usrlibdir"}/libnss_files*; do for _i in {"$libdir","$usrlibdir"}/libnss_files*; do
[ -e "$i" ] && dracut_install "$i" [ -e "$_i" ] && dracut_install "$_i"
done done
} }



16
modules.d/98syslog/module-setup.sh
View File

@ -12,24 +12,26 @@ depends() {
} }


install() { install() {
local _i
local _installs
if type -P rsyslogd >/dev/null; then if type -P rsyslogd >/dev/null; then
installs="rsyslogd" _installs="rsyslogd"
for i in {"$libdir","$usrlibdir"}/rsyslog/lmnet.so \ for _i in {"$libdir","$usrlibdir"}/rsyslog/lmnet.so \
{"$libdir","$usrlibdir"}/rsyslog/imklog.so \ {"$libdir","$usrlibdir"}/rsyslog/imklog.so \
{"$libdir","$usrlibdir"}/rsyslog/imuxsock.so ; do {"$libdir","$usrlibdir"}/rsyslog/imuxsock.so ; do
[ -e "$i" ] && installs="$installs $i" [ -e "$_i" ] && _installs="$_installs $_i"
done done
elif type -P syslogd >/dev/null; then elif type -P syslogd >/dev/null; then
installs="syslogd" _installs="syslogd"
elif type -P syslog-ng >/dev/null; then elif type -P syslog-ng >/dev/null; then
installs="syslog-ng" _installs="syslog-ng"
else else
derror "Could not find any syslog binary although the syslogmodule" \ derror "Could not find any syslog binary although the syslogmodule" \
"is selected to be installed. Please check." "is selected to be installed. Please check."
fi fi
if [ -n "$installs" ]; then if [ -n "$_installs" ]; then
dracut_install cat dracut_install cat
dracut_install $installs dracut_install $_installs
inst_hook cmdline 90 "$moddir/parse-syslog-opts.sh" inst_hook cmdline 90 "$moddir/parse-syslog-opts.sh"
inst_hook pre-udev 61 "$moddir/syslog-genrules.sh" inst_hook pre-udev 61 "$moddir/syslog-genrules.sh"
inst_hook pre-pivot 99 "$moddir/syslog-cleanup.sh" inst_hook pre-pivot 99 "$moddir/syslog-cleanup.sh"

5
modules.d/99base/module-setup.sh
View File

@ -12,6 +12,7 @@ depends() {
} }


install() { install() {
local _d
dracut_install mount mknod mkdir modprobe pidof sleep chroot \ dracut_install mount mknod mkdir modprobe pidof sleep chroot \
sed ls flock cp mv dmesg rm ln rmmod mkfifo umount sed ls flock cp mv dmesg rm ln rmmod mkfifo umount
dracut_install -o less dracut_install -o less
@ -27,9 +28,9 @@ install() {
mkdir -m 0755 -p ${initdir}/lib mkdir -m 0755 -p ${initdir}/lib
mkdir -m 0755 -p ${initdir}/lib/dracut mkdir -m 0755 -p ${initdir}/lib/dracut
mkdir -m 0755 -p ${initdir}/lib/dracut/hooks mkdir -m 0755 -p ${initdir}/lib/dracut/hooks
for d in $hookdirs emergency \ for _d in $hookdirs emergency \
initqueue initqueue/finished initqueue/settled; do initqueue initqueue/finished initqueue/settled; do
mkdir -m 0755 -p ${initdir}/lib/dracut/hooks/$d mkdir -m 0755 -p ${initdir}/lib/dracut/hooks/$_d
done done


mkdir -p ${initdir}/tmp mkdir -p ${initdir}/tmp