From ca908232a369a939d665f8419fd011c66bd740c0 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Nov 02 2019 19:42:13 +0000 Subject: import kmod-20-27.el7 --- diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f8a41ec --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +SOURCES/kmod-20.tar.xz diff --git a/.kmod.metadata b/.kmod.metadata new file mode 100644 index 0000000..fa5ddbb --- /dev/null +++ b/.kmod.metadata @@ -0,0 +1 @@ +40a17f9208e841b3fd74984520cc7ba309674ab3 SOURCES/kmod-20.tar.xz diff --git a/SOURCES/depmod.conf.dist b/SOURCES/depmod.conf.dist new file mode 100644 index 0000000..8513288 --- /dev/null +++ b/SOURCES/depmod.conf.dist @@ -0,0 +1,6 @@ +# +# depmod.conf +# + +# override default search ordering for kmod packaging +search updates extra built-in weak-updates diff --git a/SOURCES/kmod-0001-depmod-Don-t-fall-back-to-uname-on-bad-version.patch b/SOURCES/kmod-0001-depmod-Don-t-fall-back-to-uname-on-bad-version.patch new file mode 100644 index 0000000..717c678 --- /dev/null +++ b/SOURCES/kmod-0001-depmod-Don-t-fall-back-to-uname-on-bad-version.patch @@ -0,0 +1,43 @@ +From 1f5010924500a4fd83047584d1fbdba5517dffa2 Mon Sep 17 00:00:00 2001 +From: Tony Camuso +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 +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 +--- + 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 + diff --git a/SOURCES/kmod-0002-depmod-Ignore-PowerPC64-ABIv2-.TOC.-symbol.patch b/SOURCES/kmod-0002-depmod-Ignore-PowerPC64-ABIv2-.TOC.-symbol.patch new file mode 100644 index 0000000..70a9900 --- /dev/null +++ b/SOURCES/kmod-0002-depmod-Ignore-PowerPC64-ABIv2-.TOC.-symbol.patch @@ -0,0 +1,40 @@ +From 6708fbf7d26c6241cc37614c632bba1ce4ef1a4e Mon Sep 17 00:00:00 2001 +From: Tony Camuso +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 +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 +--- + 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 + diff --git a/SOURCES/kmod-0003-libkmod-Handle-long-lines-in-proc-modules.patch b/SOURCES/kmod-0003-libkmod-Handle-long-lines-in-proc-modules.patch new file mode 100644 index 0000000..7d41e1a --- /dev/null +++ b/SOURCES/kmod-0003-libkmod-Handle-long-lines-in-proc-modules.patch @@ -0,0 +1,89 @@ +From 22dadafa9fa961fa70cc616679b8b24689382348 Mon Sep 17 00:00:00 2001 +From: Tony Camuso +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 +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 + +Signed-off-by: Tony Camuso +--- + 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 + diff --git a/SOURCES/kmod-0004-libkmod-elf-resolve-CRC-if-module-is-built-with-MODU.patch b/SOURCES/kmod-0004-libkmod-elf-resolve-CRC-if-module-is-built-with-MODU.patch new file mode 100644 index 0000000..4e3be9b --- /dev/null +++ b/SOURCES/kmod-0004-libkmod-elf-resolve-CRC-if-module-is-built-with-MODU.patch @@ -0,0 +1,93 @@ +From 1e48901166efd65c574de9f6a2b7139721b72623 Mon Sep 17 00:00:00 2001 +From: Yauheni Kaliuta +Date: Wed, 19 Jul 2017 17:56:49 +0300 +Subject: [PATCH] libkmod-elf: resolve CRC if module is built with + MODULE_REL_CRCS + +Normally exported symbol's crc is stored as absolute (SHN_ABS) +value of special named symbol __crc_. + +When the kernel and modules are built with the config option +CONFIG_MODULE_REL_CRCS, all the CRCs are put in a special section +and the __crc_ symbols values are offsets in the +section. See patch description of the commit: + +https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=56067812d5b0e737ac2063e94a50f76b810d6ca3 + +Add kmod support of this configuration. + +Signed-off-by: Yauheni Kaliuta +--- + libkmod/libkmod-elf.c | 30 +++++++++++++++++++++++++++++- + 1 file changed, 29 insertions(+), 1 deletion(-) + +diff --git a/libkmod/libkmod-elf.c b/libkmod/libkmod-elf.c +index 90da89aebbaf..ef4a8a3142a1 100644 +--- a/libkmod/libkmod-elf.c ++++ b/libkmod/libkmod-elf.c +@@ -747,6 +747,31 @@ static inline uint8_t kmod_symbol_bind_from_elf(uint8_t elf_value) + } + } + ++static uint64_t kmod_elf_resolve_crc(const struct kmod_elf *elf, uint64_t crc, uint16_t shndx) ++{ ++ int err; ++ uint64_t off, size; ++ uint32_t nameoff; ++ ++ if (shndx == SHN_ABS || shndx == SHN_UNDEF) ++ return crc; ++ ++ err = elf_get_section_info(elf, shndx, &off, &size, &nameoff); ++ if (err < 0) { ++ ELFDBG("Cound not find section index %"PRIu16" for crc", shndx); ++ return (uint64_t)-1; ++ } ++ ++ if (crc > (size - sizeof(uint32_t))) { ++ ELFDBG("CRC offset %"PRIu64" is too big, section %"PRIu16" size is %"PRIu64"\n", ++ crc, shndx, size); ++ return (uint64_t)-1; ++ } ++ ++ crc = elf_get_uint(elf, off + crc, sizeof(uint32_t)); ++ return crc; ++} ++ + /* array will be allocated with strings in a single malloc, just free *array */ + int kmod_elf_get_symbols(const struct kmod_elf *elf, struct kmod_modversion **array) + { +@@ -830,6 +855,7 @@ int kmod_elf_get_symbols(const struct kmod_elf *elf, struct kmod_modversion **ar + uint32_t name_off; + uint64_t crc; + uint8_t info, bind; ++ uint16_t shndx; + + #define READV(field) \ + elf_get_uint(elf, sym_off + offsetof(typeof(*s), field),\ +@@ -839,11 +865,13 @@ int kmod_elf_get_symbols(const struct kmod_elf *elf, struct kmod_modversion **ar + name_off = READV(st_name); + crc = READV(st_value); + info = READV(st_info); ++ shndx = READV(st_shndx); + } else { + Elf64_Sym *s; + name_off = READV(st_name); + crc = READV(st_value); + info = READV(st_info); ++ shndx = READV(st_shndx); + } + #undef READV + name = elf_get_mem(elf, str_off + name_off); +@@ -856,7 +884,7 @@ int kmod_elf_get_symbols(const struct kmod_elf *elf, struct kmod_modversion **ar + else + bind = ELF64_ST_BIND(info); + +- a[count].crc = crc; ++ a[count].crc = kmod_elf_resolve_crc(elf, crc, shndx); + a[count].bind = kmod_symbol_bind_from_elf(bind); + a[count].symbol = itr; + slen = strlen(name); +-- +2.14.0.rc0 + diff --git a/SOURCES/kmod-0005-depmod-backport-external-directories-support.patch b/SOURCES/kmod-0005-depmod-backport-external-directories-support.patch new file mode 100644 index 0000000..8cdb014 --- /dev/null +++ b/SOURCES/kmod-0005-depmod-backport-external-directories-support.patch @@ -0,0 +1,920 @@ +From e91ce48303e37b92f123a91acfa9cbda17035d7c Mon Sep 17 00:00:00 2001 +From: Yauheni Kaliuta +Date: Thu, 17 Aug 2017 15:09:06 +0300 +Subject: [PATCH] depmod: backport external directories support + +Requires to backport scratchbuf implementation + +Squashed commit of the following: + +commit 92ab2321a4b761eb2822d77dc235dd543b021c69 +Author: Yauheni Kaliuta +Date: Thu Jul 20 17:09:52 2017 +0300 + + man/depmod.d: add external keyword description + + The commit 'depmod: implement external directories support' added + external directories support (see + 7da6884e7357ac05772e90f6d7e63b1948103fc4). + + This patch documents the extention in the manpage. + + Signed-off-by: Yauheni Kaliuta + +commit 01673c9b8dbe580634604808f831b735aa7fe298 +Author: Yauheni Kaliuta +Date: Tue May 9 22:09:23 2017 +0300 + + depmod: implement external directories support + + The idea is to add a configuration keyword, external, which + will list directories for scanning for particular kernel version + mask: + + external 4.10 /the/modules/dir /second/modules/dir + + And extend "search" keyword to set it's priority with pseudo dir + "external" (as it's done for built-in): + + search subdir external subdir2 built-in subdir3 + + (actually, the version is the same as for override keyword: * or + posix regexp, so example above is a bit incorrect). + + All other logic left the same: if there are duplicates, only one + is under consideration and it is unloadable if it is bad. + + The resulting modules.dep will contain entries a-la: + + /the/modules/dir/module1.ko: + kernel/module2.ko: /the/modules/dir/module1.ko + + (here /lib/modules/$(uname -r)/kernel/module2.ko depends of + symbols, provided by /the/modules/dir/module1.ko and external has + higher priority). + + modprobe and modinfo understand it out of box. + + This is a pretty simple extention of existing logic, since now + depmod already is able to: + + a) scan modules with full path from command line without -a + switch; + b) detects broken symbol dependencies and broken modversions, + what assumes, that modules are already are not built for the + existing kernel. + + Signed-off-by: Yauheni Kaliuta + +commit 5274ad44377ad5998b9f4b3c5c180d407ed68fb9 +Author: Yauheni Kaliuta +Date: Tue May 9 22:09:22 2017 +0300 + + depmod: rewrite depmod modules search with scratchbuf + + The recursive search code used used pretty big, PATH_MAX, + automatic storage buffer for the module directory scanning. Some + time ago there was scratchbuf implemented, which dynamically + reallocates its buffer on demand. The patch takes it in use for + the scanning code also. The initial size is hardcoded to 256 + bytes which sounds good enough for most usecases so there should + be not many reallocations. + + (add #include which in upstream + comes from 3b4c684c125d depmod: fix string overflow) + + Signed-off-by: Yauheni Kaliuta + +commit 88f47f04df80dd80065d2811f3a7bae25dd98a79 +Author: Yauheni Kaliuta +Date: Tue May 9 22:09:21 2017 +0300 + + depmod: create depmod dir independent search function + + Prepare to implement external directories support. + + The patch splits depmod_modules_search() function to two + functions: depmod_modules_search(), called by the high level with + intention to search all possible modules, and + depmod_module_search_path(), which takes path as a parameter and + scans modules under the path only. Initially it is used to scan + the same depmod->cfg->dirname path only. + + Signed-off-by: Yauheni Kaliuta + +commit 6488110e07ad49a0dc4da7bbf79dd00a50bd9cc5 +Author: Yauheni Kaliuta +Date: Wed Nov 23 17:23:38 2016 +0200 + + depmod: search key: move builtin detection under the add function + + Prepare to implement external directories support. + + It's better to isolate behaviour difference under the + cfg_search_add() call, then make the client code aware of it. + + In case of external modules/directories support, there will be + one more keyword added, so making the clients aware of it makes + even less sense. + + Signed-off-by: Yauheni Kaliuta + +commit 183465f82e0157b7facba9e100d0e822163ca951 +Author: Yauheni Kaliuta +Date: Wed Nov 9 08:52:26 2016 +0200 + + shared: make scratchbuf_str static + + It fixes linking problem + + tools/depmod.o: In function `output_symbols_bin': + depmod.c:(.text.output_symbols_bin+0x135): undefined reference to `scratchbuf_str' + + for -O0 build, where gcc doesn't actually inline it. + + Signed-off-by: Yauheni Kaliuta + +commit 4d202380a16b273a641b3c9e85a6d80d9f367c68 +Author: Lucas De Marchi +Date: Wed Aug 10 14:51:57 2016 -0300 + + testsuite: include stdio.h + + It's used in the log macros so include it. + +commit c226d66c43c7550247c76e7285aeb338dce2ea34 +Author: Lucas De Marchi +Date: Wed Aug 10 14:20:32 2016 -0300 + + Add scratchbuf implementation + + This should fill the requirements for "we need to loop over a lot of + strings that usually are small enough to remain on stack, but we want to + protect ourselves against huge strings not fitting in the static + buffer we estimated as sufficient" + +Signed-off-by: Yauheni Kaliuta +--- + Makefile.am | 5 + + man/depmod.d.xml | 20 ++++ + shared/scratchbuf.c | 60 +++++++++++ + shared/scratchbuf.h | 31 ++++++ + testsuite/.gitignore | 3 + + testsuite/test-scratchbuf.c | 89 +++++++++++++++++ + testsuite/testsuite.h | 1 + + tools/depmod.c | 239 ++++++++++++++++++++++++++++++++++++-------- + 8 files changed, 404 insertions(+), 44 deletions(-) + create mode 100644 shared/scratchbuf.c + create mode 100644 shared/scratchbuf.h + create mode 100644 testsuite/test-scratchbuf.c + +diff --git a/Makefile.am b/Makefile.am +index 896ae6366f45..407efe3f93c2 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -51,6 +51,7 @@ shared_libshared_la_SOURCES = \ + shared/array.h \ + shared/hash.c \ + shared/hash.h \ ++ shared/scratchbuf.c \ + shared/strbuf.c \ + shared/strbuf.h \ + shared/util.c \ +@@ -307,6 +308,7 @@ testsuite_libtestsuite_la_LIBADD = -lrt + TESTSUITE = \ + testsuite/test-hash \ + testsuite/test-array \ ++ testsuite/test-scratchbuf \ + testsuite/test-strbuf \ + testsuite/test-init \ + testsuite/test-initstate \ +@@ -329,6 +331,9 @@ testsuite_test_hash_CPPFLAGS = $(TESTSUITE_CPPFLAGS) + testsuite_test_array_LDADD = $(TESTSUITE_LDADD) + testsuite_test_array_CPPFLAGS = $(TESTSUITE_CPPFLAGS) + ++testsuite_test_scratchbuf_LDADD = $(TESTSUITE_LDADD) ++testsuite_test_scratchbuf_CPPFLAGS = $(TESTSUITE_CPPFLAGS) ++ + testsuite_test_strbuf_LDADD = $(TESTSUITE_LDADD) + testsuite_test_strbuf_CPPFLAGS = $(TESTSUITE_CPPFLAGS) + +diff --git a/man/depmod.d.xml b/man/depmod.d.xml +index c30c06c5b605..4341a568e8a0 100644 +--- a/man/depmod.d.xml ++++ b/man/depmod.d.xml +@@ -75,6 +75,9 @@ + first listed directory and the lowest priority given to the last + directory listed. The special keyword built-in + refers to the standard module directories installed by the kernel. ++ Another special keyword external refers to the ++ list of external directories, defined by the ++ external command. + + + By default, depmod will give a higher priority to +@@ -110,6 +113,23 @@ + + + ++ ++ external kernelversion ++ absolutemodulesdirectory... ++ ++ ++ ++ This specifies a list of directories, which will be checked ++ according to the priorities in the search ++ command. The order matters also, the first directory has the higher ++ priority. ++ ++ ++ The kernelversion is a POSIX regular ++ expression or * wildcard, like in the override. ++ ++ ++ + + + +diff --git a/shared/scratchbuf.c b/shared/scratchbuf.c +new file mode 100644 +index 000000000000..8d9eb83f30c1 +--- /dev/null ++++ b/shared/scratchbuf.c +@@ -0,0 +1,60 @@ ++/* ++ * kmod - interface to kernel module operations ++ * ++ * Copyright (C) 2016 Intel Corporation. All rights reserved. ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see . ++ */ ++#include "scratchbuf.h" ++ ++#include ++#include ++ ++void scratchbuf_init(struct scratchbuf *buf, char *stackbuf, size_t size) ++{ ++ buf->bytes = stackbuf; ++ buf->size = size; ++ buf->need_free = false; ++} ++ ++int scratchbuf_alloc(struct scratchbuf *buf, size_t size) ++{ ++ char *tmp; ++ ++ if (size <= buf->size) ++ return 0; ++ ++ if (buf->need_free) { ++ tmp = realloc(buf->bytes, size); ++ if (tmp == NULL) ++ return -ENOMEM; ++ } else { ++ tmp = malloc(size); ++ if (tmp == NULL) ++ return -ENOMEM; ++ memcpy(tmp, buf->bytes, buf->size); ++ } ++ ++ buf->size = size; ++ buf->bytes = tmp; ++ buf->need_free = true; ++ ++ return 0; ++} ++ ++void scratchbuf_release(struct scratchbuf *buf) ++{ ++ if (buf->need_free) ++ free(buf->bytes); ++} +diff --git a/shared/scratchbuf.h b/shared/scratchbuf.h +new file mode 100644 +index 000000000000..27ea9d9f6008 +--- /dev/null ++++ b/shared/scratchbuf.h +@@ -0,0 +1,31 @@ ++#pragma once ++ ++#include ++#include ++ ++#include ++ ++/* ++ * Buffer abstract data type ++ */ ++struct scratchbuf { ++ char *bytes; ++ size_t size; ++ bool need_free; ++}; ++ ++void scratchbuf_init(struct scratchbuf *buf, char *stackbuf, size_t size); ++int scratchbuf_alloc(struct scratchbuf *buf, size_t sz); ++void scratchbuf_release(struct scratchbuf *buf); ++ ++/* Return a C string */ ++static inline char *scratchbuf_str(struct scratchbuf *buf) ++{ ++ return buf->bytes; ++} ++ ++#define SCRATCHBUF_INITIALIZER(buf_) { \ ++ .bytes = buf_, \ ++ .size = sizeof(buf_) + _array_size_chk(buf_), \ ++ .need_free = false, \ ++} +diff --git a/testsuite/test-scratchbuf.c b/testsuite/test-scratchbuf.c +new file mode 100644 +index 000000000000..6d86957cefb8 +--- /dev/null ++++ b/testsuite/test-scratchbuf.c +@@ -0,0 +1,89 @@ ++/* ++ * Copyright (C) 2016 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see . ++ */ ++ ++#include ++#include ++#include ++ ++#include ++ ++#include "testsuite.h" ++ ++static int test_scratchbuf_onlystack(const struct test *t) ++{ ++ struct scratchbuf sbuf; ++ const char *smallstr = "xyz"; ++ char buf[3 + 2]; ++ char buf2[3 + 1]; ++ ++ scratchbuf_init(&sbuf, buf, sizeof(buf)); ++ assert_return(scratchbuf_alloc(&sbuf, strlen(smallstr) + 1) == 0, EXIT_FAILURE); ++ assert_return(sbuf.need_free == false, EXIT_FAILURE); ++ scratchbuf_release(&sbuf); ++ ++ scratchbuf_init(&sbuf, buf2, sizeof(buf2)); ++ assert_return(scratchbuf_alloc(&sbuf, strlen(smallstr) + 1) == 0, EXIT_FAILURE); ++ assert_return(sbuf.need_free == false, EXIT_FAILURE); ++ scratchbuf_release(&sbuf); ++ ++ memcpy(scratchbuf_str(&sbuf), smallstr, strlen(smallstr) + 1); ++ assert_return(strcmp(scratchbuf_str(&sbuf), smallstr) == 0, EXIT_FAILURE); ++ ++ return 0; ++} ++DEFINE_TEST(test_scratchbuf_onlystack, ++ .description = "test scratchbuf for buffer on stack only"); ++ ++ ++static int test_scratchbuf_heap(const struct test *t) ++{ ++ struct scratchbuf sbuf; ++ const char *smallstr = "xyz"; ++ const char *largestr = "xyzxyzxyz"; ++ const char *largestr2 = "xyzxyzxyzxyzxyz"; ++ char buf[3 + 1]; ++ ++ scratchbuf_init(&sbuf, buf, sizeof(buf)); ++ ++ /* Initially only on stack */ ++ assert_return(scratchbuf_alloc(&sbuf, strlen(smallstr) + 1) == 0, EXIT_FAILURE); ++ assert_return(sbuf.need_free == false, EXIT_FAILURE); ++ memcpy(scratchbuf_str(&sbuf), smallstr, strlen(smallstr) + 1); ++ ++ /* Grow once to heap */ ++ assert_return(scratchbuf_alloc(&sbuf, strlen(largestr) + 1) == 0, EXIT_FAILURE); ++ assert_return(sbuf.need_free == true, EXIT_FAILURE); ++ assert_return(sbuf.size == strlen(largestr) + 1, EXIT_FAILURE); ++ assert_return(strcmp(scratchbuf_str(&sbuf), smallstr) == 0, EXIT_FAILURE); ++ memcpy(scratchbuf_str(&sbuf), largestr, strlen(largestr) + 1); ++ assert_return(strcmp(scratchbuf_str(&sbuf), largestr) == 0, EXIT_FAILURE); ++ ++ /* Grow again - realloc should take place */ ++ assert_return(scratchbuf_alloc(&sbuf, strlen(largestr2) + 1) == 0, EXIT_FAILURE); ++ assert_return(sbuf.need_free == true, EXIT_FAILURE); ++ assert_return(sbuf.size == strlen(largestr2) + 1, EXIT_FAILURE); ++ memcpy(scratchbuf_str(&sbuf), largestr2, strlen(largestr2) + 1); ++ assert_return(strcmp(scratchbuf_str(&sbuf), largestr2) == 0, EXIT_FAILURE); ++ ++ scratchbuf_release(&sbuf); ++ ++ return 0; ++} ++DEFINE_TEST(test_scratchbuf_heap, ++ .description = "test scratchbuf for buffer on that grows to heap"); ++ ++TESTSUITE_MAIN(); +diff --git a/testsuite/testsuite.h b/testsuite/testsuite.h +index 3bd74f34ca7e..bb0eb507ac2f 100644 +--- a/testsuite/testsuite.h ++++ b/testsuite/testsuite.h +@@ -19,6 +19,7 @@ + + #include + #include ++#include + + #include + +diff --git a/tools/depmod.c b/tools/depmod.c +index 7b9583249018..79fd14354266 100644 +--- a/tools/depmod.c ++++ b/tools/depmod.c +@@ -35,6 +35,7 @@ + #include + #include + #include ++#include + + #include + +@@ -44,6 +45,7 @@ + static int verbose = DEFAULT_VERBOSE; + + static const char CFG_BUILTIN_KEY[] = "built-in"; ++static const char CFG_EXTERNAL_KEY[] = "external"; + static const char *default_cfg_paths[] = { + "/run/depmod.d", + SYSCONFDIR "/depmod.d", +@@ -432,9 +434,21 @@ struct cfg_override { + char path[]; + }; + ++enum search_type { ++ SEARCH_PATH, ++ SEARCH_BUILTIN, ++ SEARCH_EXTERNAL ++}; ++ + struct cfg_search { + struct cfg_search *next; +- uint8_t builtin; ++ enum search_type type; ++ size_t len; ++ char path[]; ++}; ++ ++struct cfg_external { ++ struct cfg_external *next; + size_t len; + char path[]; + }; +@@ -449,14 +463,27 @@ struct cfg { + uint8_t warn_dups; + struct cfg_override *overrides; + struct cfg_search *searches; ++ struct cfg_external *externals; + }; + +-static int cfg_search_add(struct cfg *cfg, const char *path, uint8_t builtin) ++static enum search_type cfg_define_search_type(const char *path) ++{ ++ if (streq(path, CFG_BUILTIN_KEY)) ++ return SEARCH_BUILTIN; ++ if (streq(path, CFG_EXTERNAL_KEY)) ++ return SEARCH_EXTERNAL; ++ return SEARCH_PATH; ++} ++ ++static int cfg_search_add(struct cfg *cfg, const char *path) + { + struct cfg_search *s; + size_t len; ++ enum search_type type; + +- if (builtin) ++ type = cfg_define_search_type(path); ++ ++ if (type != SEARCH_PATH) + len = 0; + else + len = strlen(path) + 1; +@@ -466,15 +493,15 @@ static int cfg_search_add(struct cfg *cfg, const char *path, uint8_t builtin) + ERR("search add: out of memory\n"); + return -ENOMEM; + } +- s->builtin = builtin; +- if (builtin) ++ s->type = type; ++ if (type != SEARCH_PATH) + s->len = 0; + else { + s->len = len - 1; + memcpy(s->path, path, len); + } + +- DBG("search add: %s, builtin=%hhu\n", path, builtin); ++ DBG("search add: %s, search type=%hhu\n", path, type); + + s->next = cfg->searches; + cfg->searches = s; +@@ -522,6 +549,32 @@ static void cfg_override_free(struct cfg_override *o) + free(o); + } + ++static int cfg_external_add(struct cfg *cfg, const char *path) ++{ ++ struct cfg_external *ext; ++ size_t len = strlen(path); ++ ++ ext = malloc(sizeof(struct cfg_external) + len + 1); ++ if (ext == NULL) { ++ ERR("external add: out of memory\n"); ++ return -ENOMEM; ++ } ++ ++ strcpy(ext->path, path); ++ ext->len = len; ++ ++ DBG("external add: %s\n", ext->path); ++ ++ ext->next = cfg->externals; ++ cfg->externals = ext; ++ return 0; ++} ++ ++static void cfg_external_free(struct cfg_external *ext) ++{ ++ free(ext); ++} ++ + static int cfg_kernel_matches(const struct cfg *cfg, const char *pattern) + { + regex_t re; +@@ -567,8 +620,7 @@ static int cfg_file_parse(struct cfg *cfg, const char *filename) + if (streq(cmd, "search")) { + const char *sp; + while ((sp = strtok_r(NULL, "\t ", &saveptr)) != NULL) { +- uint8_t builtin = streq(sp, CFG_BUILTIN_KEY); +- cfg_search_add(cfg, sp, builtin); ++ cfg_search_add(cfg, sp); + } + } else if (streq(cmd, "override")) { + const char *modname = strtok_r(NULL, "\t ", &saveptr); +@@ -586,6 +638,20 @@ static int cfg_file_parse(struct cfg *cfg, const char *filename) + } + + cfg_override_add(cfg, modname, subdir); ++ } else if (streq(cmd, "external")) { ++ const char *version = strtok_r(NULL, "\t ", &saveptr); ++ const char *dir = strtok_r(NULL, "\t ", &saveptr); ++ ++ if (version == NULL || dir == NULL) ++ goto syntax_error; ++ ++ if (!cfg_kernel_matches(cfg, version)) { ++ INF("%s:%u: external directory did not match %s\n", ++ filename, linenum, version); ++ goto done_next; ++ } ++ ++ cfg_external_add(cfg, dir); + } else if (streq(cmd, "include") + || streq(cmd, "make_map_files")) { + INF("%s:%u: command %s not implemented yet\n", +@@ -762,7 +828,7 @@ static int cfg_load(struct cfg *cfg, const char * const *cfg_paths) + * list here. But only if there was no "search" option specified. + */ + if (cfg->searches == NULL) +- cfg_search_add(cfg, "updates", 0); ++ cfg_search_add(cfg, "updates"); + + return 0; + } +@@ -780,6 +846,12 @@ static void cfg_free(struct cfg *cfg) + cfg->searches = cfg->searches->next; + cfg_search_free(tmp); + } ++ ++ while (cfg->externals) { ++ struct cfg_external *tmp = cfg->externals; ++ cfg->externals = cfg->externals->next; ++ cfg_external_free(tmp); ++ } + } + + +@@ -987,6 +1059,33 @@ static int depmod_module_del(struct depmod *depmod, struct mod *mod) + return 0; + } + ++static const char *search_to_string(const struct cfg_search *s) ++{ ++ switch(s->type) { ++ case SEARCH_EXTERNAL: ++ return "external"; ++ case SEARCH_BUILTIN: ++ return "built-in"; ++ default: ++ return s->path; ++ } ++} ++ ++static bool depmod_is_path_starts_with(const char *path, ++ size_t pathlen, ++ const char *prefix, ++ size_t prefix_len) ++{ ++ if (pathlen <= prefix_len) ++ return false; ++ if (path[prefix_len] != '/') ++ return false; ++ if (memcmp(path, prefix, prefix_len) != 0) ++ return false; ++ ++ return true; ++} ++ + /* returns if existing module @mod is higher priority than newpath. + * note this is the inverse of module-init-tools is_higher_priority() + */ +@@ -995,6 +1094,7 @@ static int depmod_module_is_higher_priority(const struct depmod *depmod, const s + const struct cfg *cfg = depmod->cfg; + const struct cfg_override *ov; + const struct cfg_search *se; ++ const struct cfg_external *ext; + + /* baselen includes the last '/' and mod->baselen doesn't. So it's + * actually correct to use modnamelen in the first and modnamesz in +@@ -1003,35 +1103,55 @@ static int depmod_module_is_higher_priority(const struct depmod *depmod, const s + size_t oldlen = mod->baselen + mod->modnamesz; + const char *oldpath = mod->path; + int i, bprio = -1, oldprio = -1, newprio = -1; +- +- assert(strncmp(newpath, cfg->dirname, cfg->dirnamelen) == 0); +- assert(strncmp(oldpath, cfg->dirname, cfg->dirnamelen) == 0); +- +- newpath += cfg->dirnamelen + 1; +- newlen -= cfg->dirnamelen + 1; +- oldpath += cfg->dirnamelen + 1; +- oldlen -= cfg->dirnamelen + 1; ++ size_t relnewlen = 0; ++ size_t reloldlen = 0; ++ const char *relnewpath = NULL; ++ const char *reloldpath = NULL; + + DBG("comparing priorities of %s and %s\n", + oldpath, newpath); + ++ if (strncmp(newpath, cfg->dirname, cfg->dirnamelen) == 0) { ++ relnewpath = newpath + cfg->dirnamelen + 1; ++ relnewlen = newlen - cfg->dirnamelen + 1; ++ } ++ if (strncmp(oldpath, cfg->dirname, cfg->dirnamelen) == 0) { ++ reloldpath = oldpath + cfg->dirnamelen + 1; ++ reloldlen = oldlen - cfg->dirnamelen + 1; ++ } ++ + for (ov = cfg->overrides; ov != NULL; ov = ov->next) { + DBG("override %s\n", ov->path); +- if (newlen == ov->len && memcmp(ov->path, newpath, newlen) == 0) ++ if (relnewlen == ov->len && ++ memcmp(ov->path, relnewpath, relnewlen) == 0) + return 0; +- if (oldlen == ov->len && memcmp(ov->path, oldpath, oldlen) == 0) ++ if (reloldlen == ov->len && ++ memcmp(ov->path, reloldpath, reloldlen) == 0) + return 1; + } + + for (i = 0, se = cfg->searches; se != NULL; se = se->next, i++) { +- DBG("search %s\n", se->builtin ? "built-in" : se->path); +- if (se->builtin) ++ DBG("search %s\n", search_to_string(se)); ++ if (se->type == SEARCH_BUILTIN) + bprio = i; +- else if (newlen > se->len && newpath[se->len] == '/' && +- memcmp(se->path, newpath, se->len) == 0) ++ else if (se->type == SEARCH_EXTERNAL) { ++ for (ext = cfg->externals; ext != NULL; ext = ext->next, i++) { ++ if (depmod_is_path_starts_with(newpath, ++ newlen, ++ ext->path, ++ ext->len)) ++ newprio = i; ++ if (depmod_is_path_starts_with(oldpath, ++ oldlen, ++ ext->path, ++ ext->len)) ++ oldprio = i; ++ } ++ } else if (relnewlen > se->len && relnewpath[se->len] == '/' && ++ memcmp(se->path, relnewpath, se->len) == 0) + newprio = i; +- else if (oldlen > se->len && oldpath[se->len] == '/' && +- memcmp(se->path, oldpath, se->len) == 0) ++ else if (reloldlen > se->len && reloldpath[se->len] == '/' && ++ memcmp(se->path, reloldpath, se->len) == 0) + oldprio = i; + } + +@@ -1102,10 +1222,11 @@ add: + return 0; + } + +-static int depmod_modules_search_dir(struct depmod *depmod, DIR *d, size_t baselen, char *path) ++static int depmod_modules_search_dir(struct depmod *depmod, DIR *d, size_t baselen, struct scratchbuf *s_path) + { + struct dirent *de; + int err = 0, dfd = dirfd(d); ++ char *path; + + while ((de = readdir(d)) != NULL) { + const char *name = de->d_name; +@@ -1118,11 +1239,13 @@ static int depmod_modules_search_dir(struct depmod *depmod, DIR *d, size_t basel + if (streq(name, "build") || streq(name, "source")) + continue; + namelen = strlen(name); +- if (baselen + namelen + 2 >= PATH_MAX) { +- path[baselen] = '\0'; +- ERR("path is too long %s%s\n", path, name); ++ if (scratchbuf_alloc(s_path, baselen + namelen + 2) < 0) { ++ err = -ENOMEM; ++ ERR("No memory\n"); + continue; + } ++ ++ path = scratchbuf_str(s_path); + memcpy(path + baselen, name, namelen + 1); + + if (de->d_type == DT_REG) +@@ -1148,10 +1271,6 @@ static int depmod_modules_search_dir(struct depmod *depmod, DIR *d, size_t basel + if (is_dir) { + int fd; + DIR *subdir; +- if (baselen + namelen + 2 + NAME_MAX >= PATH_MAX) { +- ERR("directory path is too long %s\n", path); +- continue; +- } + fd = openat(dfd, name, O_RDONLY); + if (fd < 0) { + ERR("openat(%d, %s, O_RDONLY): %m\n", +@@ -1168,7 +1287,7 @@ static int depmod_modules_search_dir(struct depmod *depmod, DIR *d, size_t basel + path[baselen + namelen + 1] = '\0'; + err = depmod_modules_search_dir(depmod, subdir, + baselen + namelen + 1, +- path); ++ s_path); + closedir(subdir); + } else { + err = depmod_modules_search_file(depmod, baselen, +@@ -1181,33 +1300,65 @@ static int depmod_modules_search_dir(struct depmod *depmod, DIR *d, size_t basel + err = 0; /* ignore errors */ + } + } +- + return err; + } + +-static int depmod_modules_search(struct depmod *depmod) ++static int depmod_modules_search_path(struct depmod *depmod, ++ const char *path) + { +- char path[PATH_MAX]; +- DIR *d = opendir(depmod->cfg->dirname); ++ char buf[256]; ++ _cleanup_(scratchbuf_release) struct scratchbuf s_path_buf = ++ SCRATCHBUF_INITIALIZER(buf); ++ char *path_buf; ++ DIR *d; + size_t baselen; + int err; ++ ++ d = opendir(path); + if (d == NULL) { + err = -errno; +- ERR("could not open directory %s: %m\n", depmod->cfg->dirname); ++ ERR("could not open directory %s: %m\n", path); + return err; + } + +- baselen = depmod->cfg->dirnamelen; +- memcpy(path, depmod->cfg->dirname, baselen); +- path[baselen] = '/'; ++ baselen = strlen(path); ++ ++ if (scratchbuf_alloc(&s_path_buf, baselen + 2) < 0) { ++ err = -ENOMEM; ++ goto out; ++ } ++ path_buf = scratchbuf_str(&s_path_buf); ++ ++ memcpy(path_buf, path, baselen); ++ path_buf[baselen] = '/'; + baselen++; +- path[baselen] = '\0'; ++ path_buf[baselen] = '\0'; + +- err = depmod_modules_search_dir(depmod, d, baselen, path); ++ err = depmod_modules_search_dir(depmod, d, baselen, &s_path_buf); ++out: + closedir(d); + return err; + } + ++static int depmod_modules_search(struct depmod *depmod) ++{ ++ int err; ++ struct cfg_external *ext; ++ ++ err = depmod_modules_search_path(depmod, depmod->cfg->dirname); ++ if (err < 0) ++ return err; ++ ++ for (ext = depmod->cfg->externals; ext != NULL; ext = ext->next) { ++ err = depmod_modules_search_path(depmod, ext->path); ++ if (err < 0 && err == -ENOENT) ++ /* ignore external dir absense */ ++ continue; ++ } ++ ++ return 0; ++} ++ + static int mod_cmp(const void *pa, const void *pb) { + const struct mod *a = *(const struct mod **)pa; + const struct mod *b = *(const struct mod **)pb; +-- +2.14.1 + +--- kmod-20/man/depmod.d.5.orig 2017-08-17 16:01:34.330058135 +0300 ++++ kmod-20/man/depmod.d.5 2017-08-17 16:01:37.901058086 +0300 +@@ -1,13 +1,13 @@ + '\" t + .\" Title: depmod.d + .\" Author: Jon Masters +-.\" Generator: DocBook XSL Stylesheets v1.78.1 +-.\" Date: 03/01/2015 ++.\" Generator: DocBook XSL Stylesheets v1.79.1 ++.\" Date: 08/17/2017 + .\" Manual: depmod.d + .\" Source: kmod + .\" Language: English + .\" +-.TH "DEPMOD\&.D" "5" "03/01/2015" "kmod" "depmod.d" ++.TH "DEPMOD\&.D" "5" "08/17/2017" "kmod" "depmod.d" + .\" ----------------------------------------------------------------- + .\" * Define some portability stuff + .\" ----------------------------------------------------------------- +@@ -52,7 +52,11 @@ + This allows you to specify the order in which /lib/modules (or other configured module location) subdirectories will be processed by + \fBdepmod\fR\&. Directories are listed in order, with the highest priority given to the first listed directory and the lowest priority given to the last directory listed\&. The special keyword + \fBbuilt\-in\fR +-refers to the standard module directories installed by the kernel\&. ++refers to the standard module directories installed by the kernel\&. Another special keyword ++\fBexternal\fR ++refers to the list of external directories, defined by the ++\fBexternal\fR ++command\&. + .sp + By default, depmod will give a higher priority to a directory with the name + \fBupdates\fR +@@ -73,6 +77,18 @@ + \fBextra\fR + subdirectory within /lib/modules (or other module location) will take priority over any likenamed module already provided by the kernel\&. + .RE ++.PP ++external \fIkernelversion\fR \fIabsolutemodulesdirectory\&.\&.\&.\fR ++.RS 4 ++This specifies a list of directories, which will be checked according to the priorities in the ++\fBsearch\fR ++command\&. The order matters also, the first directory has the higher priority\&. ++.sp ++The ++\fIkernelversion\fR ++is a POSIX regular expression or * wildcard, like in the ++\fBoverride\fR\&. ++.RE + .SH "COPYRIGHT" + .PP + This manual page Copyright 2006\-2010, Jon Masters, Red Hat, Inc\&. diff --git a/SOURCES/kmod-0006-depmod-module_is_higher_priority-fix-modname-length-.patch b/SOURCES/kmod-0006-depmod-module_is_higher_priority-fix-modname-length-.patch new file mode 100644 index 0000000..88b1f7b --- /dev/null +++ b/SOURCES/kmod-0006-depmod-module_is_higher_priority-fix-modname-length-.patch @@ -0,0 +1,56 @@ +From dd73c8a2f5e8da3c38f6e16c63f249071d440378 Mon Sep 17 00:00:00 2001 +From: Yauheni Kaliuta +Date: Thu, 7 Dec 2017 20:59:54 +0200 +Subject: [PATCH 2/2] depmod: module_is_higher_priority: fix modname length + calculation + +depmod_module_is_higher_priority checks module's path if it is under +module root directory and if so uses relative to the root path to +lookup the module in override and search lists. + +Originally only relative path was used in the function, so the +variables with full path and and path length were changed: + + newpath += cfg->dirnamelen + 1; + newlen -= cfg->dirnamelen + 1; + oldpath += cfg->dirnamelen + 1; + oldlen -= cfg->dirnamelen + 1; + +Commit 7da6884e7357ac05772e90f6d7e63b1948103fc4 (depmod: implement +external directories support) changed the logic since it need the +full path to the module for comparations as well. + +Unfortunately, it introduce a mistake in calculation of the relative +paths replacing '-=' with assignment to a new variable -- the +'cfg->dirnamelen + 1' value must be substracted all together. It +breaks, for example, overrides lookup. + +Fix the calculation by putting braces around the value in the +subsctuction expression. + +Signed-off-by: Yauheni Kaliuta +--- + tools/depmod.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/tools/depmod.c b/tools/depmod.c +index 7ff3e9ed191e..921dc5cc93eb 100644 +--- a/tools/depmod.c ++++ b/tools/depmod.c +@@ -1118,11 +1118,11 @@ static int depmod_module_is_higher_priority(const struct depmod *depmod, const s + + if (strncmp(newpath, cfg->dirname, cfg->dirnamelen) == 0) { + relnewpath = newpath + cfg->dirnamelen + 1; +- relnewlen = newlen - cfg->dirnamelen + 1; ++ relnewlen = newlen - (cfg->dirnamelen + 1); + } + if (strncmp(oldpath, cfg->dirname, cfg->dirnamelen) == 0) { + reloldpath = oldpath + cfg->dirnamelen + 1; +- reloldlen = oldlen - cfg->dirnamelen + 1; ++ reloldlen = oldlen - (cfg->dirnamelen + 1); + } + + for (ov = cfg->overrides; ov != NULL; ov = ov->next) { +-- +2.15.1 + diff --git a/SOURCES/weak-modules b/SOURCES/weak-modules new file mode 100644 index 0000000..324edb2 --- /dev/null +++ b/SOURCES/weak-modules @@ -0,0 +1,1119 @@ +#!/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 + [[ "${#modules[@]}" -eq 0 ]] && return + + $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 +do_make_groups() +{ + local tmp="$1" + local group_name + local mod + declare -a mods + + while read i; do + mods=($i) + + # 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 + # 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 +filter_depmod_deps() +{ + awk 'BEGIN { pr = 1 } /^#/{ pr = 0 } pr == 1 {sub(":",""); print $0}' +} + +# make_abs_path: +# Takes kernel version +# makes full path from the relative module path +# (produced by depmod for in-kernel-dir modules) +make_abs_path() +{ + local kver="$1" + local mod + declare -a mods + + while read i; do + mods=($i) + for j in "${!mods[@]}"; do + mod="${mods[$j]}" + [[ ${mod:0:1} == "/" ]] || mod="/lib/modules/$kver/$mod" + mods[$j]="$mod" + done + echo "${mods[@]}" + done +} + +# make_groups: +# takes krel and a file with the list of modules, +# prepares and feeds to do_make_groups +# to create the module groups (global) +make_groups() +{ + local krel="$1" + local tmp1="$2" + local tmp2=$(mktemp -p $tmpdir) + + groups=() + grouped_modules=() + + $depmod -n $krel $(cat $tmp1) 2>/dev/null | + filter_depmod_deps | make_abs_path $krel > $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 $krel $tmp + + # 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 diff --git a/SPECS/kmod.spec b/SPECS/kmod.spec new file mode 100644 index 0000000..67dddfb --- /dev/null +++ b/SPECS/kmod.spec @@ -0,0 +1,403 @@ +Name: kmod +Version: 20 +Release: 27%{?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 +Patch04: kmod-0004-libkmod-elf-resolve-CRC-if-module-is-built-with-MODU.patch +Patch05: kmod-0005-depmod-backport-external-directories-support.patch +Patch06: kmod-0006-depmod-module_is_higher_priority-fix-modname-length-.patch + +BuildRequires: chrpath +BuildRequires: zlib-devel +BuildRequires: xz-devel +BuildRequires: libxslt +# Remove it as soon as no need for Patch05 anymore (Makefile.am updated) +BuildRequires: automake autoconf libtool + +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 +%patch04 -p1 -b .0004-libkmod-elf-resolve-CRC-if-module-is-built-with-MODU +%patch05 -p1 -b .0005-depmod-backport-external-directories-support +%patch06 -p1 -b .0006-depmod-module_is_higher_priority-fix-modname-length-.patch + +%build +export V=1 +aclocal +autoreconf --install --symlink +%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 +* Tue Sep 24 2019 Yauheni Kaliuta - 20-27 +- weak-modules: reverse checking order for add-kernel + Resolves: rhbz#1752902 + +* Wed Jun 12 2019 Yauheni Kaliuta - 20-26 +- weak-modules: handle independent modules in one run +- weak-modules: use asterisk for kernel version in sandbox + Resolves: rhbz#1695547 + +* Wed Nov 21 2018 Yauheni Kaliuta - 20-25 +- weak-modules: do not make groups if there are no extra modules + Related: rhbz#1643299 + +* Mon Nov 12 2018 Yauheni Kaliuta - 20-24 +- weak-modules: group modules on add-kernel. + Resolves: rhbz#1643299. + +* Tue Aug 28 2018 Yauheni Kaliuta - 20-23 +- weak-modules: fix initial state creation for dry-run +- weak-modules: check compatibility in a temporary directory + Resolves: rhbz#1619889. + +* Thu Jun 21 2018 Yauheni Kaliuta - 20-22 +- weak-modules: add compressed modules support. + Resolves: rhbz#1593448 + +* Fri Dec 8 2017 Yauheni Kaliuta - 20-21 +- depmod: module_is_higher_priority: fix modname length calculation. + Resolves: rhbz#1522994 + +* Thu Nov 9 2017 Yauheni Kaliuta - 20-20 +- weak-modules: use function to generate weak_updates_dir +- weak-modules: implement dry-run on the tempdir + Resolves: rhbz#1510058 + +* Thu Sep 14 2017 Yauheni Kaliuta - 20-19 +- weak-modules: fix dry-run for non-lib-modules installation + Resolves: rhbz#1477073 + +* Thu Aug 17 2017 Yauheni Kaliuta - 20-18 +- depmod: external directories support. + Resolves: rhbz#1361857 +- BuildRequires automake autoconf libtool. + +* Mon Aug 7 2017 Yauheni Kaliuta - 20-17 +- libkmod-elf: resolve CRC if module is built with MODULE_REL_CRCS. +- weak-modules: process only weak-updates related depmod output. + Resolves: rhbz#1468305 +- weak-modules: implement dry run by symlink restoration. + Resolves: rhbz#1477073 + +* Wed Jul 12 2017 Yauheni Kaliuta - 20-16 +- weak-modules: fallback weak-modules state if incompatible installed. + Resolved: rhbz#1468042 + +* Fri May 12 2017 Yauheni Kaliuta - 20-15 +- weak-modules: install weak link even if there is same name in extra. + Resolves: rhbz#1450003 + +* Fri May 5 2017 Yauheni Kaliuta - 20-14 +- weak-modules: check if kernel installed for the final depmod. + Resolves: rhbz#1448349 + +* Mon Mar 27 2017 Yauheni Kaliuta - 20-13 +- Remove kmod-20.tar from sources, kmod-20.tar.xz is used. + Resolves: rhbz#1434319 + +* Tue Feb 21 2017 Yauheni Kaliuta - 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 - 20-11 +- Rebuild package with updated rpm macros. + Resolves: rhbz#1420768 + +* Thu Feb 2 2017 Tony Camuso - 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 - 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 - 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 - 20-7 +- Backported some needed fixes. + Resolves: rhbz#1320204 + +* Fri Feb 26 2016 David Shea - 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 - 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 - 20-4 +- Do not remove the weak-updates directory + Resolves: rhbz#1124352 + +* Thu Apr 2 2015 David Shea - 20-3 +- Require kmod-libs instead of kmod from kmod-devel + Related: rhbz#1199646 + +* Thu Apr 2 2015 David Shea - 20-2 +- Remove the explicit requirement on kmod-libs + Related: rhbz#1199646 + +* Wed Mar 11 2015 David Shea - 20-1 +- Rebase to kmod-20 + Resolves: rhbz#1199646 + +* Wed Jan 14 2015 David Shea - 14-10 +- Allow module paths to start with /usr + Resolves: rhbz#1177266 + +* Tue Apr 1 2014 David Shea - 14-9 +- Support initramfs files with early_cpio + Resolves: rhbz#1070035 + +* Wed Feb 26 2014 David Shea - 14-8 +- Support xz-compressed and uncompressed initramfs files + Resolves: rhbz#1070035 + +* Tue Feb 25 2014 David Shea - 14-7 +- Require binutils for weak-modules + Resolves: rhbz#1069612 + +* Mon Feb 17 2014 David Shea - 14-6 +- Added a depmod search order as /etc/depmod.d/dist.conf + Resolves: rhbz#1065354 + +* Fri Jan 24 2014 Daniel Mach - 14-5 +- Mass rebuild 2014-01-24 + +* Mon Jan 06 2014 Václav Pavlín - 14-4 +- Version bump due to build fail + Resolves: rhbz#1048868 + +* Fri Dec 27 2013 Daniel Mach - 14-3 +- Mass rebuild 2013-12-27 + +* Wed Aug 07 2013 Václav Pavlín - 14-2 +- Run tests during build + +* Fri Jul 05 2013 Josh Boyer - 14-1 +- Update to version 14 + +* Fri Apr 19 2013 Václav Pavlín - 13-2 +- Main package should require -libs + +* Wed Apr 10 2013 Josh Boyer - 13-1 +- Update to version 13 + +* Wed Mar 20 2013 Weiping Pan - 12-3 +- Pull in weak-modules for kABI from Jon Masters + +* Mon Mar 18 2013 Josh Boyer +- Add patch to make rmmod understand built-in modules (rhbz 922187) + +* Thu Feb 14 2013 Fedora Release Engineering - 12-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild + +* Thu Dec 06 2012 Josh Boyer +- Update to version 12 + +* Thu Nov 08 2012 Josh Boyer +- Update to version 11 + +* Fri Sep 07 2012 Josh Boyer +- Update to version 10 + +* Mon Aug 27 2012 Josh Boyer +- Update to version 9 + +* Thu Jul 19 2012 Fedora Release Engineering - 8-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Wed May 23 2012 Josh Boyer - 8-2 +- Provide modprobe.conf(5) (rhbz 824552) + +* Tue May 08 2012 Josh Boyer - 8-1 +- Update to version 8 + +* Mon Mar 19 2012 Kay Sievers - 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 - 6-1 +- update to version 6 +- remove all patches, they are included in the release + +* Fri Feb 24 2012 Kay Sievers - 5-8 +- try to address brc#771285 + +* Sun Feb 12 2012 Kay Sievers - 5-7 +- fix infinite loop with softdeps + +* Thu Feb 09 2012 Harald Hoyer 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 5-5 +- add "lsmod" + +* Tue Feb 7 2012 Kay Sievers - 5-4 +- remove temporarily added fake-provides + +* Tue Feb 7 2012 Kay Sievers - 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 - 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 - 4-1 +- Update to version 4 +- set --with-rootprefix= +- enable zlib and xz support + +* Thu Jan 05 2012 Jon Masters - 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 - 2-6 +- Update kmod-2-with-rootlibdir patch with rebuild automake files + +* Fri Dec 23 2011 Jon Masters - 2-5 +- Initial build for Fedora following package import + +* Thu Dec 22 2011 Jon Masters - 2-4 +- There is no generic macro for non-multilib "/lib", hardcode like others + +* Thu Dec 22 2011 Jon Masters - 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 - 2-2 +- Update package for posting to wider test audience (initial review submitted) + +* Thu Dec 22 2011 Jon Masters - 2-1 +- Initial Fedora package for module-init-tools replacement (kmod) library