powerel7
/
base
2
0
Fork 0
Code Issues Pull Requests Releases Activity

added kmod package 

Signed-off-by: basebuilder_pel7ppc64bebuilder0 <basebuilder@powerel.org>
master
basebuilder_pel7ppc64bebuilder0 2018-03-21 10:16:00 +01:00
parent 9e9c2c0278
commit d00af4a641
6 changed files with 1326 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
SOURCES/depmod.conf.dist Normal file
View File

@ -0,0 +1,6 @@
#
# depmod.conf
#

# override default search ordering for kmod packaging
search updates extra built-in weak-updates

43
SOURCES/kmod-0001-depmod-Don-t-fall-back-to-uname-on-bad-version.patch Normal file
View File

@ -0,0 +1,43 @@
From 1f5010924500a4fd83047584d1fbdba5517dffa2 Mon Sep 17 00:00:00 2001
From: Tony Camuso <tcamuso@redhat.com>
Date: Fri, 24 Jun 2016 12:37:48 -0400
Subject: [RHEL-7.3 PATCH 1/3] depmod: Don't fall back to uname on bad version

Cherry-picked without conflicts from the following upstream commit.

commit f3f62f5ec3b23823b2ce02e37bc707dc85c56461
Author: Laura Abbott <labbott@fedoraproject.org>
Date: Mon Sep 28 15:39:14 2015 -0700

depmod: Don't fall back to uname on bad version

Currently, if a value that doesn't match a kernel version
("%u.%u") is passed in, depmod silently falls back to
using uname. Rather than try and work around the caller passing
bad data, just exit out instead.

Signed-off-by: Tony Camuso <tcamuso@redhat.com>
---
tools/depmod.c | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tools/depmod.c b/tools/depmod.c
index 231b9ab..8d5c671 100644
--- a/tools/depmod.c
+++ b/tools/depmod.c
@@ -2475,7 +2475,11 @@ static int do_depmod(int argc, char *argv[])
}
}
- if (optind < argc && is_version_number(argv[optind])) {
+ if (optind < argc) {
+ if (!is_version_number(argv[optind])) {
+ ERR("Bad version passed %s\n", argv[optind]);
+ goto cmdline_failed;
+ }
cfg.kversion = argv[optind];
optind++;
} else {
--
1.8.3.1

40
SOURCES/kmod-0002-depmod-Ignore-PowerPC64-ABIv2-.TOC.-symbol.patch Normal file
View File

@ -0,0 +1,40 @@
From 6708fbf7d26c6241cc37614c632bba1ce4ef1a4e Mon Sep 17 00:00:00 2001
From: Tony Camuso <tcamuso@redhat.com>
Date: Fri, 24 Jun 2016 12:38:25 -0400
Subject: [RHEL-7.3 PATCH 2/3] depmod: Ignore PowerPC64 ABIv2 .TOC. symbol

Cherry-picked without conflicts from the following upstream commit.

commit d46136bb59c46609ee8050636f0681f2831d2225
Author: Anton Blanchard <anton@samba.org>
Date: Fri Jun 10 15:24:30 2016 +1000

depmod: Ignore PowerPC64 ABIv2 .TOC. symbol

The .TOC. symbol on the PowerPC64 ABIv2 identifies the GOT
pointer, similar to how other architectures use _GLOBAL_OFFSET_TABLE_.

This is not a symbol that needs relocation, and should be ignored
by depmod.

Signed-off-by: Tony Camuso <tcamuso@redhat.com>
---
tools/depmod.c | 2 ++
1 file changed, 2 insertions(+)

diff --git a/tools/depmod.c b/tools/depmod.c
index 8d5c671..7b95832 100644
--- a/tools/depmod.c
+++ b/tools/depmod.c
@@ -2149,6 +2149,8 @@ static void depmod_add_fake_syms(struct depmod *depmod)
depmod_symbol_add(depmod, "__this_module", true, 0, NULL);
/* On S390, this is faked up too */
depmod_symbol_add(depmod, "_GLOBAL_OFFSET_TABLE_", true, 0, NULL);
+ /* On PowerPC64 ABIv2, .TOC. is more or less _GLOBAL_OFFSET_TABLE_ */
+ depmod_symbol_add(depmod, "TOC.", true, 0, NULL);
}
static int depmod_load_symvers(struct depmod *depmod, const char *filename)
--
1.8.3.1

89
SOURCES/kmod-0003-libkmod-Handle-long-lines-in-proc-modules.patch Normal file
View File

@ -0,0 +1,89 @@
From 22dadafa9fa961fa70cc616679b8b24689382348 Mon Sep 17 00:00:00 2001
From: Tony Camuso <tcamuso@redhat.com>
Date: Fri, 24 Jun 2016 12:38:52 -0400
Subject: [RHEL-7.3 PATCH 3/3] libkmod: Handle long lines in /proc/modules

Cherry-picked without conflicts from the following upstream commit.

commit 2206d7f763a1c9cf88f77d0ab19e410d17749361
Author: Michal Marek <mmarek@suse.cz>
Date: Fri Jun 17 16:04:15 2016 +0200

libkmod: Handle long lines in /proc/modules

kmod_module_new_from_loaded() calls fgets with a 4k buffer. When a
module such as usbcore is used by too many modules, the rest of the line
is considered a beginning of another lines and we eventually get errors
like these from lsmod:

libkmod: kmod_module_get_holders: could not open '/sys/module/100,/holders': No such file or directory

together with bogus entries in the output. In kmod_module_get_size, the
problem does not affect functionality, but the line numbers in error
messages will be wrong.

Signed-off-by: Michal Marek <mmarek@suse.com>

Signed-off-by: Tony Camuso <tcamuso@redhat.com>
---
libkmod/libkmod-module.c | 12 ++++++++++--
1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/libkmod/libkmod-module.c b/libkmod/libkmod-module.c
index 366308f..47bb880 100644
--- a/libkmod/libkmod-module.c
+++ b/libkmod/libkmod-module.c
@@ -1660,13 +1660,14 @@ KMOD_EXPORT int kmod_module_new_from_loaded(struct kmod_ctx *ctx,
struct kmod_module *m;
struct kmod_list *node;
int err;
+ size_t len = strlen(line);
char *saveptr, *name = strtok_r(line, " \t", &saveptr);
err = kmod_module_new_from_name(ctx, name, &m);
if (err < 0) {
ERR(ctx, "could not get module from name '%s': %s\n",
name, strerror(-err));
- continue;
+ goto eat_line;
}
node = kmod_list_append(l, m);
@@ -1676,6 +1677,9 @@ KMOD_EXPORT int kmod_module_new_from_loaded(struct kmod_ctx *ctx,
ERR(ctx, "out of memory\n");
kmod_module_unref(m);
}
+eat_line:
+ while (line[len - 1] != '\n' && fgets(line, sizeof(line), fp))
+ len = strlen(line);
}
fclose(fp);
@@ -1825,12 +1829,13 @@ KMOD_EXPORT long kmod_module_get_size(const struct kmod_module *mod)
}
while (fgets(line, sizeof(line), fp)) {
+ size_t len = strlen(line);
char *saveptr, *endptr, *tok = strtok_r(line, " \t", &saveptr);
long value;
lineno++;
if (tok == NULL || !streq(tok, mod->name))
- continue;
+ goto eat_line;
tok = strtok_r(NULL, " \t", &saveptr);
if (tok == NULL) {
@@ -1848,6 +1853,9 @@ KMOD_EXPORT long kmod_module_get_size(const struct kmod_module *mod)
size = value;
break;
+eat_line:
+ while (line[len - 1] != '\n' && fgets(line, sizeof(line), fp))
+ len = strlen(line);
}
fclose(fp);
--
1.8.3.1

810
SOURCES/weak-modules Normal file
View File

@ -0,0 +1,810 @@
#!/bin/bash
#
# weak-modules - determine which modules are kABI compatible with installed
# kernels and set up the symlinks in /lib/*/weak-updates.
#
# This is an updated version of the script which doesn't support
# multiple installation of the same out-of-tree module (stored in the
# 'extra' subdirectory) for multiple kernels. This assumption is
# supposed to be verified at the rpm level of the packages delivering
# these modules. There are some checks for this assumption, however we
# really don't solve this situation. This limitation allows for a much
# simpler version of the script. Previous version tried to work in this
# case but was incorrect in some cases.

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
default_initramfs_prefix="/boot" # will be combined with BASEDIR
dracut="/sbin/dracut"
declare -a modules
declare -A module_krels
declare -A weak_modules_before

# 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}'
}

# 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 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

module=${module%.ko}
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")

echo "$BASEDIR/lib/modules/$krel/weak-updates/${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 "lib/modules/$krel/weak-updates" || 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" ]]
}

#### 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' 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#*/lib/modules/$krel/weak-updates}"

doit rm -f $link
( cd "$BASEDIR/lib/modules/$krel/weak-updates" && \
doit rmdir --parents --ignore-fail-on-non-empty "$(dirname "${subpath#/}")" 2>/dev/null )
}

#### 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"

[[ -r "$BASEDIR/boot/symvers-$krel.gz" ]] || return

global_link_state_save $krel
$func $krel
validate_weak_links $krel
global_link_state_announce_changes $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 module_krel

read_modules_list || exit 1
[[ ${#modules[@]} -gt 0 ]] || return

for krel in $(find_installed_kernels); do
update_modules_for_krel $krel $func
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)"

[[ "$module_krel" == "$krel" ]] && continue

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)"

doit mkdir -p "$(dirname $weak_link)"
doit 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)"

[[ "$module_krel" == "$krel" ]] && continue

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
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

tmp=$(mktemp -p $tmpdir)

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
/sbin/depmod $basedir -aeE $tmpdir/symvers-$krel -e $krel >$tmp 2>&1
# 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
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
pr_verbose "Module ${module##*/} from kernel $module_krel is compatible with kernel $krel"
fi
done
}

# 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 $krel weak-updates | xargs); do
target=$(readlink $link)
weak_modules_before[$link]=$target
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 $krel weak-updates | 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
}

# add_modules:
# Read in a list of modules from stdinput and process them for compatibility
# with installed kernels under /lib/modules.
add_modules() {
update_modules add_weak_links
}

add_kernel() {
local krel=${1:-$(uname -r)}
local tmp

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
done

# to avoid subshell, see the read_modules_list comment
read_modules_list < $tmp
rm -f $tmp

update_modules_for_krel $krel add_weak_links
}

remove_kernel() {
remove_krel=${1:-$(uname -r)}
weak_modules="$BASEDIR/lib/modules/$remove_krel/weak-updates"
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
;;
--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 /sbin/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

338
SPECS/kmod.spec Normal file
View File

@ -0,0 +1,338 @@
Name: kmod
Version: 20
Release: 15%{?dist}
Summary: Linux kernel module management utilities

Group: System Environment/Kernel
License: GPLv2+
URL: http://git.kernel.org/?p=utils/kernel/kmod/kmod.git;a=summary
Source0: ftp://ftp.kernel.org/pub/linux/utils/kernel/kmod/%{name}-%{version}.tar.xz
Source1: weak-modules
Source2: depmod.conf.dist
Exclusiveos: Linux

BuildRoot: %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)

Patch01: kmod-0001-depmod-Don-t-fall-back-to-uname-on-bad-version.patch
Patch02: kmod-0002-depmod-Ignore-PowerPC64-ABIv2-.TOC.-symbol.patch
Patch03: kmod-0003-libkmod-Handle-long-lines-in-proc-modules.patch

BuildRequires: chrpath
BuildRequires: zlib-devel
BuildRequires: xz-devel
BuildRequires: libxslt

Provides: module-init-tools = 4.0-1
Obsoletes: module-init-tools < 4.0-1
Provides: /sbin/modprobe

# Required for the weak-modules script
Requires: /usr/bin/nm
Requires: /usr/bin/gzip
Requires: /usr/bin/xz
Requires: /usr/bin/cpio
Requires: dracut
Requires: diffutils

%description
The kmod package provides various programs needed for automatic
loading and unloading of modules under 2.6, 3.x, and later kernels, as well
as other module management programs. Device drivers and filesystems are two
examples of loaded and unloaded modules.

%package libs
Summary: Libraries to handle kernel module loading and unloading
License: LGPLv2+
Group: System Environment/Libraries

%description libs
The kmod-libs package provides runtime libraries for any application that
wishes to load or unload Linux kernel modules from the running system.

%package devel
Summary: Header files for kmod development
Group: Development/Libraries
Requires: %{name}-libs%{?_isa} = %{version}-%{release}

%description devel
The kmod-devel package provides header files used for development of
applications that wish to load or unload Linux kernel modules.

%prep
%setup -q
%patch01 -p1 -b .0001-depmod-Don-t-fall-back-to-uname-on-bad-version
%patch02 -p1 -b .0002-depmod-Ignore-PowerPC64-ABIv2-.TOC.-symbol
%patch03 -p1 -b .0003-libkmod-Handle-long-lines-in-proc-modules

%build
export V=1
%configure \
--with-zlib \
--with-xz
make %{?_smp_mflags}
#make check

%install
make install DESTDIR=$RPM_BUILD_ROOT
pushd $RPM_BUILD_ROOT/%{_mandir}/man5
ln -s modprobe.d.5.gz modprobe.conf.5.gz
popd

rm -rf $RPM_BUILD_ROOT%{_libdir}/*.la
mkdir -p $RPM_BUILD_ROOT%{_sbindir}
ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/modprobe
ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/modinfo
ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/insmod
ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/rmmod
ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/depmod
ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/lsmod

mkdir -p $RPM_BUILD_ROOT%{_sysconfdir}/modprobe.d
mkdir -p $RPM_BUILD_ROOT%{_sysconfdir}/depmod.d
mkdir -p $RPM_BUILD_ROOT%{_prefix}/lib/modprobe.d

mkdir -p $RPM_BUILD_ROOT/sbin
install -m 755 %{SOURCE1} $RPM_BUILD_ROOT%{_sbindir}/weak-modules

install -m 0644 %{SOURCE2} $RPM_BUILD_ROOT%{_sysconfdir}/depmod.d/dist.conf

%post libs -p /sbin/ldconfig

%postun libs -p /sbin/ldconfig

%files
%defattr(-,root,root,-)
%dir %{_sysconfdir}/depmod.d
%dir %{_sysconfdir}/modprobe.d
%dir %{_prefix}/lib/modprobe.d
%{_bindir}/kmod
%{_sbindir}/modprobe
%{_sbindir}/modinfo
%{_sbindir}/insmod
%{_sbindir}/rmmod
%{_sbindir}/lsmod
%{_sbindir}/depmod
%{_sbindir}/weak-modules
%{_datadir}/bash-completion/completions/kmod
%{_sysconfdir}/depmod.d/dist.conf
%attr(0644,root,root) %{_mandir}/man5/*.5*
%attr(0644,root,root) %{_mandir}/man8/*.8*
%doc NEWS README TODO COPYING

%files libs
%{_libdir}/libkmod.so.*

%files devel
%{_includedir}/libkmod.h
%{_libdir}/pkgconfig/libkmod.pc
%{_libdir}/libkmod.so

%changelog
* Fri May 12 2017 Yauheni Kaliuta <ykaliuta@redhat.com> - 20-15
- weak-modules: install weak link even if there is same name in extra.
Resolves: rhbz#1450003

* Fri May 5 2017 Yauheni Kaliuta <ykaliuta@redhat.com> - 20-14
- weak-modules: check if kernel installed for the final depmod.
Resolves: rhbz#1448349

* Mon Mar 27 2017 Yauheni Kaliuta <ykaliuta@redhat.com> - 20-13
- Remove kmod-20.tar from sources, kmod-20.tar.xz is used.
Resolves: rhbz#1434319

* Tue Feb 21 2017 Yauheni Kaliuta <ykaliuta@redhat.com> - 20-12
- weak-modules: fix coverity introduced by latest changes
- weak-modules: fix "permission denied" on some upgrades.
Resolves: rhbz#1416566

* Thu Feb 16 2017 Yauheni Kaliuta <ykaliuta@redhat.com> - 20-11
- Rebuild package with updated rpm macros.
Resolves: rhbz#1420768

* Thu Feb 2 2017 Tony Camuso <tcamuso@redhat.com> - 20-10
- Rename patches so they are not specific to the build. This was
causing problems with z-stream builds.
Resolves: rhbz#1416498

* Mon Nov 28 2016 Yauheni Kaliuta <ykaliuta@redhat.com> - 20-10
- weak-modules: deprecate --delete-modules switch.
- weak-modules: implement some pathes configuration from cmdline.
- weak-modules: redesign to reuse depmod -aeE functionality
(with some preparation changes).
This is an updated version of the script which doesn't support
multiple installation of the same out-of-tree module (stored in the
'extra' subdirectory). But it more correctly checks dependencies
between the modules.
Resolves: rhbz#1367942

* Fri Sep 2 2016 Tony Camuso <tcamuso@redhat.com> - 20-9
- Must be bumped to 20-9 due to changes and version bumps in the
7.2-z stream.
Resolves: rhbz#1320204

* Sat Jun 25 2016 Tony Camuso <tcamuso@redhat.com> - 20-7
- Backported some needed fixes.
Resolves: rhbz#1320204

* Fri Feb 26 2016 David Shea <dshea@redhat.com> - 20-6
- Accept '.' as part of a symbol exported by the kernel
Resolves: rhbz#1283486
- Check the addon modules of the new kernel for exported symbols
Resolves: rhbz#1296465

* Wed Jun 3 2015 David Shea <dshea@redhat.com> - 20-5
- Check for changes in non-module files that affect that initramfs
Resolves: rhbz#1108166
- Use dracut to skip early cpio archives in the initramfs
Resolves: rhbz#1210449

* Mon Apr 13 2015 David Shea <dshea@redhat.com> - 20-4
- Do not remove the weak-updates directory
Resolves: rhbz#1124352

* Thu Apr 2 2015 David Shea <dshea@redhat.com> - 20-3
- Require kmod-libs instead of kmod from kmod-devel
Related: rhbz#1199646

* Thu Apr 2 2015 David Shea <dshea@redhat.com> - 20-2
- Remove the explicit requirement on kmod-libs
Related: rhbz#1199646

* Wed Mar 11 2015 David Shea <dshea@redhat.com> - 20-1
- Rebase to kmod-20
Resolves: rhbz#1199646

* Wed Jan 14 2015 David Shea <dshea@redhat.com> - 14-10
- Allow module paths to start with /usr
Resolves: rhbz#1177266

* Tue Apr 1 2014 David Shea <dshea@redhat.com> - 14-9
- Support initramfs files with early_cpio
Resolves: rhbz#1070035

* Wed Feb 26 2014 David Shea <dshea@redhat.com> - 14-8
- Support xz-compressed and uncompressed initramfs files
Resolves: rhbz#1070035

* Tue Feb 25 2014 David Shea <dshea@redhat.com> - 14-7
- Require binutils for weak-modules
Resolves: rhbz#1069612

* Mon Feb 17 2014 David Shea <dshea@redhat.com> - 14-6
- Added a depmod search order as /etc/depmod.d/dist.conf
Resolves: rhbz#1065354

* Fri Jan 24 2014 Daniel Mach <dmach@redhat.com> - 14-5
- Mass rebuild 2014-01-24

* Mon Jan 06 2014 Václav Pavlín <vpavlin@redhat.com> - 14-4
- Version bump due to build fail
Resolves: rhbz#1048868

* Fri Dec 27 2013 Daniel Mach <dmach@redhat.com> - 14-3
- Mass rebuild 2013-12-27

* Wed Aug 07 2013 Václav Pavlín <vpavlin@redhat.com> - 14-2
- Run tests during build

* Fri Jul 05 2013 Josh Boyer <jwboyer@redhat.com> - 14-1
- Update to version 14

* Fri Apr 19 2013 Václav Pavlín <vpavlin@redhat.com> - 13-2
- Main package should require -libs

* Wed Apr 10 2013 Josh Boyer <jwboyer@redhat.com> - 13-1
- Update to version 13

* Wed Mar 20 2013 Weiping Pan <wpan@redhat.com> - 12-3
- Pull in weak-modules for kABI from Jon Masters <jcm@redhat.com>

* Mon Mar 18 2013 Josh Boyer <jwboyer@redhat.com>
- Add patch to make rmmod understand built-in modules (rhbz 922187)

* Thu Feb 14 2013 Fedora Release Engineering <rel-eng@lists.fedoraproject.org> - 12-2
- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild

* Thu Dec 06 2012 Josh Boyer <jwboyer@redhat.com>
- Update to version 12

* Thu Nov 08 2012 Josh Boyer <jwboyer@redhat.com>
- Update to version 11

* Fri Sep 07 2012 Josh Boyer <jwboyer@redaht.com>
- Update to version 10

* Mon Aug 27 2012 Josh Boyer <jwboyer@redhat.com>
- Update to version 9

* Thu Jul 19 2012 Fedora Release Engineering <rel-eng@lists.fedoraproject.org> - 8-3
- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild

* Wed May 23 2012 Josh Boyer <jwboyer@redhat.com> - 8-2
- Provide modprobe.conf(5) (rhbz 824552)

* Tue May 08 2012 Josh Boyer <jwboyer@redhat.com> - 8-1
- Update to version 8

* Mon Mar 19 2012 Kay Sievers <kay@redhat.com> - 7-1
- update to version 7
- fix issue with --show-depends, where built-in
modules of the running kernel fail to include
loadable modules of the kernel specified

* Sun Mar 04 2012 Kay Sievers <kay@redhat.com> - 6-1
- update to version 6
- remove all patches, they are included in the release

* Fri Feb 24 2012 Kay Sievers <kay@redhat.com> - 5-8
- try to address brc#771285

* Sun Feb 12 2012 Kay Sievers <kay@redhat.com> - 5-7
- fix infinite loop with softdeps

* Thu Feb 09 2012 Harald Hoyer <harald@redhat.com> 5-6
- add upstream patch to fix "modprobe --ignore-install --show-depends"
otherwise dracut misses a lot of modules, which are already loaded

* Wed Feb 08 2012 Harald Hoyer <harald@redhat.com> 5-5
- add "lsmod"

* Tue Feb 7 2012 Kay Sievers <kay@redhat.com> - 5-4
- remove temporarily added fake-provides

* Tue Feb 7 2012 Kay Sievers <kay@redhat.com> - 5-3
- temporarily add fake-provides to be able to bootstrap
the new udev which pulls the old udev into the buildroot

* Tue Feb 7 2012 Kay Sievers <kay@redhat.com> - 5-1
- Update to version 5
- replace the module-init-tools package and provide all tools
as compatibility symlinks

* Mon Jan 16 2012 Kay Sievers <kay@redhat.com> - 4-1
- Update to version 4
- set --with-rootprefix=
- enable zlib and xz support

* Thu Jan 05 2012 Jon Masters <jcm@jonmasters.org> - 3-1
- Update to latest upstream (adds new depmod replacement utility)
- For the moment, use the "kmod" utility to test the various functions

* Fri Dec 23 2011 Jon Masters <jcm@jonmasters.org> - 2-6
- Update kmod-2-with-rootlibdir patch with rebuild automake files

* Fri Dec 23 2011 Jon Masters <jcm@jonmasters.org> - 2-5
- Initial build for Fedora following package import

* Thu Dec 22 2011 Jon Masters <jcm@jonmasters.org> - 2-4
- There is no generic macro for non-multilib "/lib", hardcode like others

* Thu Dec 22 2011 Jon Masters <jcm@jonmasters.org> - 2-3
- Update package incorporating fixes from initial review feedback
- Cleaups to SPEC, rpath, documentation, library and binary locations

* Thu Dec 22 2011 Jon Masters <jcm@jonmasters.org> - 2-2
- Update package for posting to wider test audience (initial review submitted)

* Thu Dec 22 2011 Jon Masters <jcm@jonmasters.org> - 2-1
- Initial Fedora package for module-init-tools replacement (kmod) library