| Current Path : /usr/sbin/ |
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 |
| Current File : //usr/sbin/weak-modules |
#!/bin/bash
#
# weak-modules - determine which modules are kABI compatible with installed
# kernels and set up the symlinks in /lib/*/weak-updates.
#
unset LANG LC_ALL LC_COLLATE
tmpdir=$(mktemp -td ${0##*/}.XXXXXX)
trap "rm -rf $tmpdir" EXIT
unset ${!changed_modules_*} ${!changed_initramfs_*}
unset BASEDIR
unset CHECK_INITRAMFS
weak_updates_dir_override=""
default_initramfs_prefix="/boot" # will be combined with BASEDIR
dracut="/sbin/dracut"
depmod="/sbin/depmod"
depmod_orig="$depmod"
declare -a modules
declare -A module_krels
declare -A weak_modules_before
declare -A groups
declare -A grouped_modules
# output of validate_weak_links, one iteration
# short_name -> path
declare -A compatible_modules
# state for update_modules_for_krel (needed for add_kernel case)
# short_name -> path
declare -A installed_modules
# doit:
# A wrapper used whenever we're going to perform a real operation.
doit() {
[ -n "$verbose" ] && echo "$@"
[ -n "$dry_run" ] || "$@"
}
# pr_verbose:
# print verbose -- wrapper used to print extra messages if required
pr_verbose() {
[ -n "$verbose" ] && echo "$@"
}
# pr_warning:
# print warning
pr_warning() {
echo "WARNING: $*"
}
# rpmsort: The sort in coreutils can't sort the RPM list how we want it so we
# instead transform the list into a form it will sort correctly, then sort.
rpmsort() {
local IFS=$' '
REVERSE=""
rpmlist=($(cat))
if [ "-r" == "$1" ];
then
REVERSE="-r"
fi
echo ${rpmlist[@]} | \
sed -e 's/-/../g' | \
sort ${REVERSE} -n -t"." -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 -k6,6 -k7,7 \
-k8,8 -k9,9 -k10,10 | \
sed -e 's/\.\./-/g'
}
# krel_of_module:
# Compute the kernel release of a module.
krel_of_module() {
local module="$1"
if [ x"${module_krels[$module]+set}" = x"set" ]; then
# version cached in the array already
echo "${module_krels[$module]}"
elif [ -f "$module" ]; then
krel_of_module_modinfo "$module"
else
# Try to extract the kernel release from the path
# delete case, the .ko already deleted
set -- "${module#*/lib/modules/}"
echo "${1%%/*}"
fi
}
# krel_of_module_modinfo:
# Fetches module version from internal module info
krel_of_module_modinfo() {
local module="$1"
/sbin/modinfo -F vermagic "$module" | awk '{print $1}'
}
# weak_updates_dir:
# gives the root directory for the weak-updates
# We need some flexibility here because of dry-run.
weak_updates_dir() {
local krel="$1"
if [[ -z "$weak_updates_dir_override" ]]; then
echo "$BASEDIR/lib/modules/$krel/weak-updates"
else
echo "$weak_updates_dir_override"
fi
}
# read_modules_list:
# Read in a list of modules from standard input. Convert the filenames into
# absolute paths and compute the kernel release for each module (either using
# the modinfo section or through the absolute path.
# If used with input redirect, should be used as read_module_list < input,
# not input | read_modules_list, the latter spawns a subshell
# and the arrays are not seen in the caller
read_modules_list() {
local IFS=$'\n'
modules=($(cat))
for ((n = 0; n < ${#modules[@]}; n++)); do
if [ ${modules[n]:0:1} != '/' ]; then
modules[n]="$PWD/${modules[n]}"
fi
module_krels["${modules[n]}"]=$(krel_of_module ${modules[n]})
done
}
decompress_initramfs() {
local input=$1
local output=$2
# First, check if this is compressed at all
if cpio -i -t < "$input" > /dev/null 2>/dev/null; then
# If this archive contains a file early_cpio, it's a trick. Strip off
# the early cpio archive and try again.
if cpio -i -t < "$input" 2>/dev/null | grep -q '^early_cpio$' ; then
/usr/lib/dracut/skipcpio "$input" > "${tmpdir}/post_early_cpio.img"
decompress_initramfs "${tmpdir}/post_early_cpio.img" "$output"
retval="$?"
rm -f "${tmpdir}/post_early_cpio.img"
return $retval
fi
cp "$input" "$output"
return 0
fi
# Try gzip
if gzip -cd < "$input" > "$output" 2>/dev/null ; then
return 0
fi
# Next try xz
if xz -cd < "$input" > "$output" 2>/dev/null ; then
return 0
fi
echo "Unable to decompress $input: Unknown format" >&2
return 1
}
# List all module files and modprobe configuration that could require a new
# initramfs. The current directory must be the root of the uncompressed
# initramfs. The unsorted list of files is output to stdout.
list_module_files() {
find . -iname \*.ko -o -iname '*.ko.xz' -o -iname '*.ko.gz' 2>/dev/null
find etc/modprobe.d usr/lib/modprobe.d -name \*.conf 2>/dev/null
}
# read_old_initramfs:
compare_initramfs_modules() {
local old_initramfs=$1
local new_initramfs=$2
rm -rf "$tmpdir/old_initramfs"
rm -rf "$tmpdir/new_initramfs"
mkdir "$tmpdir/old_initramfs"
mkdir "$tmpdir/new_initramfs"
decompress_initramfs "$old_initramfs" "$tmpdir/old_initramfs.img"
pushd "$tmpdir/old_initramfs" >/dev/null
cpio -i < "$tmpdir/old_initramfs.img" 2>/dev/null
rm "$tmpdir/old_initramfs.img"
n=0; for i in `list_module_files|sort`; do
old_initramfs_modules[n]="$i"
n=$((n+1))
done
popd >/dev/null
decompress_initramfs "$new_initramfs" "$tmpdir/new_initramfs.img"
pushd "$tmpdir/new_initramfs" >/dev/null
cpio -i < "$tmpdir/new_initramfs.img" 2>/dev/null
rm "$tmpdir/new_initramfs.img"
n=0; for i in `list_module_files|sort`; do
new_initramfs_modules[n]="$i"
n=$((n+1))
done
popd >/dev/null
# Compare the length and contents of the arrays
if [ "${#old_initramfs_modules[@]}" == "${#new_initramfs_modules[@]}" -a \
"${old_initramfs_modules[*]}" == "${new_initramfs_modules[*]}" ];
then
# If the file lists are the same, compare each file to find any that changed
for ((n = 0; n < ${#old_initramfs_modules[@]}; n++)); do
if ! cmp "$tmpdir/old_initramfs/${old_initramfs_modules[n]}" \
"$tmpdir/new_initramfs/${new_initramfs_modules[n]}" \
>/dev/null 2>&1
then
return 1
fi
done
else
return 1
fi
return 0
}
# check_initramfs:
# check and possibly also update the initramfs for changed kernels
check_initramfs() {
local kernel=$1
# If there is no initramfs already we will not make one here.
if [ -e "$initramfs_prefix/initramfs-$kernel.img" ];
then
old_initramfs="$initramfs_prefix/initramfs-$kernel.img"
tmp_initramfs="$initramfs_prefix/initramfs-$kernel.tmp"
new_initramfs="$initramfs_prefix/initramfs-$kernel.img"
$dracut -f "$tmp_initramfs" "$kernel"
if ! compare_initramfs_modules "$old_initramfs" "$tmp_initramfs";
then
doit mv "$tmp_initramfs" "$new_initramfs"
else
rm -f "$tmp_initramfs"
fi
fi
}
usage() {
echo "Usage: ${0##*/} [options] {--add-modules|--remove-modules}"
echo "${0##*/} [options] {--add-kernel|--remove-kernel} {kernel-release}"
cat <<'EOF'
--add-modules
Add a list of modules read from standard input. Create
symlinks in compatible kernel's weak-updates/ directory.
The list of modules is read from standard input.
--remove-modules
Remove compatibility symlinks from weak-updates/ directories
for a list of modules. The list of modules is read from
standard input. Note: it doesn't attempt to locate any
compatible modules to replace those being removed.
--add-kernel
Add compatibility symlinks for all compatible modules to the
specified or running kernel.
--remove-kernel
Remove all compatibility symlinks for the specified or current
kernel.
--no-initramfs
Do not generate an initramfs.
--verbose
Print the commands executed.
--dry-run
Do not create/remove any files.
EOF
exit $1
}
# module_has_changed:
# Mark if an actual change occured that we need to deal with later by calling
# depmod or mkinitramfs against the affected kernel.
module_has_changed() {
declare module=$1 krel=$2
declare orig_module=$module
module=${module%.ko}
[[ $module == $orig_module ]] && module=${module%.ko.xz}
[[ $module == $orig_module ]] && module=${module%.ko.gz}
module=${module##*/}
eval "changed_modules_${krel//[^a-zA-Z0-9]/_}=$krel"
eval "changed_initramfs_${krel//[^a-zA-Z0-9]/_}=$krel"
}
# module_weak_link:
# Generate a weak link path for the module.
# Takes module file name and the target kernel release as arguments
# The way of generation intentionally left from the initial version
module_weak_link() {
local module="$1"
local krel="$2"
local module_krel
local subpath
module_krel="$(krel_of_module "$module")"
subpath=$(echo $module | sed -nre "s:$BASEDIR(/usr)?/lib/modules/$module_krel/([^/]*)/(.*):\3:p")
if [[ -z $subpath ]]; then
# module is not in /lib/modules/$krel?
# It's possible for example for Oracle ACFS compatibility check
# Install it with its full path as a /lib/modules subpath
subpath="$module"
fi
echo "$(weak_updates_dir $krel)/${subpath#/}"
}
# module_short_name:
# 'basename' version purely in bash, cuts off path from the filename
module_short_name() {
echo "${1##*/}"
}
#### Helper predicates
# is_weak_for_module_valid:
# Takes real module filename and target kernel as arguments.
# Calculates weak symlink filename for the corresponding module
# for the target kernel,
# returns 'true' if the symlink filename is a symlink
# and the symlink points to a readable file
# EVEN if it points to a different filename
is_weak_for_module_valid() {
local module="$1"
local krel="$2"
local weak_link
weak_link="$(module_weak_link $module $krel)"
[[ -L "$weak_link" ]] && [[ -r "$weak_link" ]]
}
# is_weak_link:
# Takes a filename and a kernel release.
# 'true' if the filename is symlink under weak-updates/ for the kernel.
# It doesn't matter, if it's a valid symlink (points to a real file) or not.
is_weak_link() {
local link="$1"
local krel="$2"
echo $link | grep -q "$(weak_updates_dir $krel)" || return 1
[[ -L $link ]]
}
# is_extra_exists:
# Takes a module filename, the module's kernel release and target kernel release.
# The module filename should be a real, not a symlink, filename (i.e. in extra/).
# Returns 'true' if the same module exists for the target kernel.
is_extra_exists() {
local module="$1"
local module_krel="$2"
local krel="$3"
local subpath="${module#*/lib/modules/$module_krel/extra/}"
[[ -f $BASEDIR/lib/modules/$krel/extra/$subpath ]]
}
is_kernel_installed() {
local krel="$1"
[[ -f "$BASEDIR/boot/symvers-$krel.gz" ]]
}
is_empty_file() {
local file="$1"
[[ "$(wc -l "$file" | cut -f 1 -d ' ')" == 0 ]]
}
#### Helpers
# find_modules:
# Takes kernel release and a list of subdirectories.
# Produces list of module files in the subdirectories for the kernel
find_modules() {
local krel="$1"
shift
local dirs="$*"
for dir in $dirs; do
find $BASEDIR/lib/modules/$krel/$dir \
-name '*.ko' -o -name '*.ko.xz' -o -name '*.ko.gz' \
2>/dev/null
done
}
# find_modules_dirs:
# Takes a list of directories.
# Produces list of module files in the subdirectories
find_modules_dirs() {
local dirs="$*"
for dir in $dirs; do
find $dir -name '*.ko' -o -name '*.ko.xz' -o -name '*.ko.gz' \
2>/dev/null
done
}
# find_installed_kernels:
# Produces list of kernels, which modules are still installed
find_installed_kernels() {
ls $BASEDIR/lib/modules/
}
# find_kernels_with_extra:
# Produces list of kernels, where exists extra/ directory
find_kernels_with_extra() {
local krel
local extra_dir
for krel in $(find_installed_kernels); do
extra_dir="$BASEDIR/lib/modules/$krel/extra"
[[ -d "$extra_dir" ]] || continue
echo "$krel"
done
}
# remove_weak_link_quiet:
# Takes symlink filename and target kernel release.
# Removes the symlink and the directory tree
# if it was the last file in the tree
remove_weak_link_quiet() {
local link="$1"
local krel="$2"
local subpath="${link#*$(weak_updates_dir $krel)}"
rm -f $link
( cd "$(weak_updates_dir $krel)" && \
rmdir --parents --ignore-fail-on-non-empty "$(dirname "${subpath#/}")" 2>/dev/null )
}
# prepare_sandbox:
# Takes kernel release, creates temporary weak-modules directory for it
# and depmod config to operate on it.
# Sets the global state accordingly
prepare_sandbox() {
local krel="$1"
local orig_dir
local dir
local conf="$tmpdir/depmod.conf"
#directory
orig_dir=$(weak_updates_dir $krel)
dir="$tmpdir/$krel/weak-updates"
mkdir -p "$dir"
# the orig_dir can be empty
cp -R "$orig_dir"/* "$dir" 2>/dev/null
weak_updates_dir_override="$dir"
#config
echo "search external extra built-in weak-updates" >"$conf"
echo "external * $dir" >>"$conf"
depmod="$depmod_orig -C $conf"
}
# finish_sandbox:
# restore global state after sandboxing
# copy configuration to the kernel directory if not dry run
finish_sandbox() {
local krel="$1"
local override="$weak_updates_dir_override"
local wa_dir
weak_updates_dir_override=""
depmod="$depmod_orig"
[[ -n "$dry_run" ]] && return
wa_dir="$(weak_updates_dir $krel)"
rm -rf "$wa_dir"
mkdir -p "$wa_dir"
cp -R "${override}"/* "$wa_dir" 2>/dev/null
}
# discard_installed:
# remove installed_modules[] from modules[]
discard_installed()
{
local short_name
for m in "${!modules[@]}"; do
short_name="$(module_short_name "${modules[$m]}")"
[[ -z "${installed_modules[$short_name]}" ]] && continue
unset "modules[$m]"
done
}
# update_installed:
# add compatible_modules[] to installed_modules[]
update_installed()
{
for m in "${!compatible_modules[@]}"; do
installed_modules[$m]="${compatible_modules[$m]}"
done
}
#### Main logic
# update_modules_for_krel:
# Takes kernel release and "action" function name.
# Skips kernel without symvers,
# otherwise triggers the main logic of modules installing/removing
# for the given kernel, which is:
# - save current state of weak modules symlinks
# - install/remove the symlinks for the given (via stdin) list of modules
# - validate the state and remove invalid symlinks
# (for the modules, which are not compatible (became incompatible) for
# the given kernel)
# - check the state after validation to produce needed messages
# and trigger initrd regeneration if the list changed.
#
update_modules_for_krel() {
local krel="$1"
local func="$2"
local force_update="$3"
[[ -r "$BASEDIR/boot/symvers-$krel.gz" ]] || return
prepare_sandbox $krel
global_link_state_save $krel
# remove already installed from modules[]
discard_installed
# do not run heavy validation procedure if no modules to install
if [[ "${#modules[@]}" -eq 0 ]]; then
finish_sandbox $krel
return
fi
$func $krel
if ! validate_weak_links $krel && [[ -z "$force_update" ]]; then
global_link_state_restore $krel
fi
# add compatible to installed
update_installed
global_link_state_announce_changes $krel
finish_sandbox $krel
}
# update_modules:
# Common entry point for add/remove modules command
# Takes the "action" function, the module list is supplied via stdin.
# Reads the module list and triggers modules update for all installed
# kernels.
# Triggers initrd rebuild for the kernels, which modules are installed.
update_modules() {
local func="$1"
local force_update="$2"
local module_krel
declare -a saved_modules
read_modules_list || exit 1
[[ ${#modules[@]} -gt 0 ]] || return
saved_modules=("${modules[@]}")
for krel in $(find_installed_kernels); do
update_modules_for_krel $krel $func $force_update
modules=("${saved_modules[@]}")
installed_modules=()
done
for module in "${modules[@]}"; do
# Module was built against this kernel, update initramfs.
module_krel="${module_krels[$module]}"
module_has_changed $module $module_krel
done
}
# add_weak_links:
# Action function for the "add-modules" command
# Takes the kernel release, where the modules are added
# and the modules[] and module_krels[] global arrays.
# Install symlinks for the kernel with minimal checks
# (just filename checks, no symbol checks)
add_weak_links() {
local krel="$1"
local module_krel
local weak_link
for module in "${modules[@]}"; do
module_krel="$(krel_of_module $module)"
case "$module" in
$BASEDIR/lib/modules/$krel/*)
# Module already installed to the current kernel
continue ;;
esac
if is_extra_exists $module $module_krel $krel; then
pr_verbose "found $(module_short_name $module) for $krel while installing for $module_krel, update case?"
fi
if is_weak_for_module_valid $module $krel; then
pr_verbose "weak module for $(module_short_name $module) already exists for kernel $krel, update case?"
# we should update initrd in update case,
# the change is not seen by the symlink detector
# (global_link_state_announce_changes())
module_has_changed $module $krel
fi
weak_link="$(module_weak_link $module $krel)"
mkdir -p "$(dirname $weak_link)"
ln -sf $module $weak_link
done
}
# remove_weak_links:
# Action function for the "remove-modules" command
# Takes the kernel release, where the modules are removed
# and the modules[] and module_krels[] global arrays.
# Removes symlinks from the given kernel if they are installed
# for the modules in the list.
remove_weak_links() {
local krel="$1"
local weak_link
local target
local module_krel
for module in "${modules[@]}"; do
module_krel="$(krel_of_module $module)"
weak_link="$(module_weak_link $module $krel)"
target="$(readlink $weak_link)"
if [[ "$module" != "$target" ]]; then
pr_verbose "Skipping symlink $weak_link"
continue
fi
# In update case the --remove-modules call is performed
# after --add-modules (from postuninstall).
# So, we shouldn't really remove the symlink in this case.
# But in the remove case the actual target already removed.
if ! is_weak_for_module_valid "$module" "$krel"; then
remove_weak_link_quiet "$weak_link" "$krel"
fi
done
}
# validate_weak_links:
# Takes kernel release.
# Checks if all the weak symlinks are suitable for the given kernel.
# Uses depmod to perform the actual symbol checks and parses the output.
# Since depmod internally creates the module list in the beginning of its work
# accroding to the priority list in its configuration, but without symbol
# check and doesn't amend the list during the check, the function runs it
# in a loop in which it removes discovered incompatible symlinks
#
# Returns 0 (success) if proposal is fine or
# 1 (false) if some incompatible symlinks were removed
# initializes global hashmap compatible_modules with all the valid ones
validate_weak_links() {
local krel="$1"
local basedir=${BASEDIR:+-b $BASEDIR}
local tmp
declare -A symbols
local is_updates_changed=1
local module
local module_krel
local target
local modpath
local symbol
local weak_link
# to return to caller that original proposal is not valid
# here 0 is true, 1 is false, since it will be the return code
local is_configuration_valid=0
tmp=$(mktemp -p $tmpdir)
compatible_modules=()
if ! [[ -e $tmpdir/symvers-$krel ]]; then
[[ -e $BASEDIR/boot/symvers-$krel.gz ]] || return
zcat $BASEDIR/boot/symvers-$krel.gz > $tmpdir/symvers-$krel
fi
while ((is_updates_changed)); do
is_updates_changed=0
# again $tmp because of subshell, see read_modules_list() comment
# create incompatibility report by depmod
# Shorcut if depmod finds a lot of incompatible modules elsewhere,
# we care only about weak-updates
$depmod $basedir -naeE $tmpdir/symvers-$krel $krel 2>&1 1>/dev/null | \
grep "$(weak_updates_dir $krel)" 2>/dev/null >$tmp
# parse it into symbols[] associative array in form a-la
# symbols["/path/to/the/module"]="list of bad symbols"
while read line; do
set -- $(echo $line | awk '/needs unknown symbol/{print $3 " " $NF}')
modpath=$1
symbol=$2
if [[ -n "$modpath" ]]; then
symbols[$modpath]="${symbols[$modpath]} $symbol"
continue
fi
set -- $(echo $line | awk '/disagrees about version of symbol/{print $3 " " $NF}')
modpath=$1
symbol=$2
if [[ -n "$modpath" ]]; then
symbols[$modpath]="${symbols[$modpath]} $symbol"
continue
fi
done < $tmp
# loop through all the weak links from the list of incompatible
# modules and remove them. Skips non-weak incompatibilities
for modpath in "${!symbols[@]}"; do
is_weak_link $modpath $krel || continue
target=$(readlink $modpath)
module_krel=$(krel_of_module $target)
remove_weak_link_quiet "$modpath" "$krel"
pr_verbose "Module $(module_short_name $modpath) from kernel $module_krel is not compatible with kernel $krel in symbols: ${symbols[$modpath]}"
is_updates_changed=1
is_configuration_valid=1 # inversed value
done
done
rm -f $tmp
# this loop is just to produce verbose compatibility messages
# for the compatible modules
for module in "${modules[@]}"; do
is_weak_for_module_valid $module $krel || continue
weak_link="$(module_weak_link $module $krel)"
target="$(readlink $weak_link)"
module_krel=$(krel_of_module $target)
if [[ "$module" == "$target" ]]; then
short_name="$(module_short_name "$module")"
compatible_modules+=([$short_name]="$module")
pr_verbose "Module ${module##*/} from kernel $module_krel is compatible with kernel $krel"
fi
done
return $is_configuration_valid
}
# global_link_state_save:
# Takes kernel release
# Saves the given kernel's weak symlinks state into the global array
# weak_modules_before[] for later processing
global_link_state_save() {
local krel="$1"
local link
local target
weak_modules_before=()
for link in $(find_modules_dirs $(weak_updates_dir $krel) | xargs); do
target=$(readlink $link)
weak_modules_before[$link]=$target
done
}
# global_link_state_restore:
# Takes kernel release
# Restores the previous weak links state
# (for example, if incompatible modules were installed)
global_link_state_restore() {
local krel="$1"
local link
local target
pr_verbose "Falling back weak-modules state for kernel $krel"
( cd "$(weak_updates_dir $krel)" 2>/dev/null && rm -rf * )
for link in "${!weak_modules_before[@]}"; do
target=${weak_modules_before[$link]}
mkdir -p "$(dirname $link)"
ln -sf $target $link
done
}
# global_link_state_announce_changes:
# Takes kernel release
# Reads the given kernel's weak symlinks state, compares to the saved,
# triggers initrd rebuild if there were changes
# and produces message on symlink removal
global_link_state_announce_changes() {
local krel="$1"
local link
local target
local new_target
declare -A weak_modules_after
for link in $(find_modules_dirs $(weak_updates_dir $krel) | xargs); do
target=${weak_modules_before[$link]}
new_target=$(readlink $link)
weak_modules_after[$link]=$new_target
# report change of existing link and appearing of a new link
[[ "$target" == "$new_target" ]] || module_has_changed $new_target $krel
done
for link in "${!weak_modules_before[@]}"; do
target=${weak_modules_before[$link]}
new_target=${weak_modules_after[$link]}
# report change of existing link and disappearing of an old link
[[ "$target" == "$new_target" ]] && continue
module_has_changed $target $krel
[[ -n "$new_target" ]] ||
pr_verbose "Removing compatible module $(module_short_name $target) from kernel $krel"
done
}
# remove_modules:
# Read in a list of modules from stdinput and process them for removal.
# Parameter (noreplace) is deprecated, acts always as "noreplace".
# There is no sense in the "replace" functionality since according
# to the current requirements RPM will track existing of only one version
# of extra/ module (no same extra/ modules for different kernels).
remove_modules() {
update_modules remove_weak_links force_update
}
# add_modules:
# Read in a list of modules from stdinput and process them for compatibility
# with installed kernels under /lib/modules.
add_modules() {
no_force_update=""
update_modules add_weak_links $no_force_update
}
# do_make_groups:
# Takes tmp file which contains preprocessed modules.dep
# output (or modules.dep)
#
# reads modules.dep format information from stdin
# produces groups associative array
# the group is a maximum subset of modules having at least a link
#
# more fine tuned extra filtering.
do_make_groups()
{
local tmp="$1"
local group_name
local mod
declare -a mods
while read i; do
mods=($i)
echo "${mods[0]}" |grep -q "extra/" || continue
# if the module already met, then its dependencies already counted
module_group="${grouped_modules[${mods[0]}]}"
[[ -n $module_group ]] && continue
# new group
group_name="${mods[0]}"
for mod in "${mods[@]}"; do
echo "$mod" |grep -q "extra/" || continue
# if there is already such group,
# it is a subset of the one being created
# due to depmod output
unset groups[$mod]
# extra space doesn't matter, since later (in add_kernel())
# it is expanded without quotes
groups[$group_name]+=" $mod"
grouped_modules[$mod]=$group_name
done
done < $tmp # avoid subshell
}
# filter_depmod_deps:
# preprocess output for make_groups
# depmod -n produces also aliases, so it cuts them off
# also it removes colon after the first module
cut_depmod_deps()
{
awk 'BEGIN { pr = 1 } /^#/{ pr = 0 } pr == 1 {sub(":",""); print $0}'
}
# filter_extra_absoluted:
# Takes kernel version
# makes full path from the relative module path
# (produced by depmod for in-kernel-dir modules)
# filter only extra/ modules
filter_extra_absoluted()
{
local kver="$1"
local mod
declare -a mods
while read i; do
# skip non-extra. The check is not perfect, but ok
# to speed up handling in general cases
echo "$i" |grep -q "extra/" || continue
mods=($i)
for j in "${!mods[@]}"; do
mod="${mods[$j]}"
[[ ${mod:0:1} == "/" ]] || mod="$BASEDIR/lib/modules/$kver/$mod"
mods[$j]="$mod"
done
echo "${mods[@]}"
done
}
# make_groups:
# takes k -- kernel version, we are installing extras from
# prepares and feeds to do_make_groups
# to create the module groups (global)
make_groups()
{
local k="$1"
local tmp2=$(mktemp -p $tmpdir)
local basedir=${BASEDIR:+-b $BASEDIR}
groups=()
grouped_modules=()
$depmod -n $basedir $k 2>/dev/null |
cut_depmod_deps | filter_extra_absoluted $k > $tmp2
do_make_groups $tmp2
rm -f $tmp2
}
add_kernel() {
local krel=${1:-$(uname -r)}
local tmp
local no_force_update=""
local num
tmp=$(mktemp -p $tmpdir)
if [ ! -e "$BASEDIR/boot/symvers-$krel.gz" ]; then
echo "Symvers dump file $BASEDIR/boot/symvers-$krel.gz" \
"not found" >&2
exit 1
fi
for k in $(find_kernels_with_extra | rpmsort -r); do
[[ "$krel" == "$k" ]] && continue
find_modules $k extra > $tmp
is_empty_file "$tmp" || make_groups $k
# reuse tmp
# optimization, check independent modules in one run.
# first try groups with one element in each.
# it means independent modules, so we can safely remove
# incompatible links
# some cut and paste here
echo > $tmp
for g in "${groups[@]}"; do
num="$(echo "$g" | wc -w)"
[ "$num" -gt 1 ] && continue
printf '%s\n' $g >> $tmp
done
# to avoid subshell, see the read_modules_list comment
read_modules_list < $tmp
update_modules_for_krel $krel add_weak_links force_update
for g in "${groups[@]}"; do
num="$(echo "$g" | wc -w)"
[ "$num" -eq 1 ] && continue
printf '%s\n' $g > $tmp
read_modules_list < $tmp
update_modules_for_krel $krel add_weak_links $no_force_update
done
done
rm -f $tmp
}
remove_kernel() {
remove_krel=${1:-$(uname -r)}
weak_modules="$(weak_updates_dir $remove_krel)"
module_has_changed $weak_modules $remove_krel
# Remove everything beneath the weak-updates directory
( cd "$weak_modules" && doit rm -rf * )
}
################################################################################
################################## MAIN GUTS ###################################
################################################################################
options=`getopt -o h --long help,add-modules,remove-modules \
--long add-kernel,remove-kernel \
--long dry-run,no-initramfs,verbose,delete-modules \
--long basedir:,dracut:,check-initramfs-prog: -- "$@"`
[ $? -eq 0 ] || usage 1
eval set -- "$options"
while :; do
case "$1" in
--add-modules)
do_add_modules=1
;;
--remove-modules)
do_remove_modules=1
;;
--add-kernel)
do_add_kernel=1
;;
--remove-kernel)
do_remove_kernel=1
;;
--dry-run)
dry_run=1
# --dry-run option is not pure dry run anymore,
# because of depmod used internally.
# For add/remove modules we have to add/remove the symlinks
# and just restore the original configuration afterwards.
;;
--no-initramfs)
no_initramfs=1
;;
--verbose)
verbose=1
;;
--delete-modules)
pr_warning "--delete-modules is deprecated, no effect"
;;
--basedir)
BASEDIR="$2"
shift
;;
--dracut)
dracut="$2"
shift
;;
--check-initramfs-prog)
CHECK_INITRAMFS="$2"
shift
;;
-h|--help)
usage 0
;;
--)
shift
break
;;
esac
shift
done
if [ ! -x "$dracut" ]
then
echo "weak-modules: this tool requires a dracut-enabled kernel"
exit 1
fi
initramfs_prefix="$BASEDIR/${default_initramfs_prefix#/}"
if [ -n "$do_add_modules" ]; then
add_modules
elif [ -n "$do_remove_modules" ]; then
remove_modules
elif [ -n "$do_add_kernel" ]; then
kernel=${1:-$(uname -r)}
add_kernel $kernel
elif [ -n "$do_remove_kernel" ]; then
kernel=${1:-$(uname -r)}
remove_kernel $kernel
exit 0
else
usage 1
fi
################################################################################
###################### CLEANUP POST ADD/REMOVE MODULE/KERNEL ###################
################################################################################
# run depmod and dracut as needed
for krel in ${!changed_modules_*}; do
krel=${!krel}
basedir=${BASEDIR:+-b $BASEDIR}
if is_kernel_installed $krel; then
doit $depmod $basedir -ae -F $BASEDIR/boot/System.map-$krel $krel
else
pr_verbose "Skipping depmod for non-installed kernel $krel"
fi
done
for krel in ${!changed_initramfs_*}; do
krel=${!krel}
if [ ! -n "$no_initramfs" ]; then
${CHECK_INITRAMFS:-check_initramfs} $krel
fi
done