pax_global_header00006660000000000000000000000064150067034020014507gustar00rootroot0000000000000052 comment=c967462f47e2f0ac2e26eaf17730621aeca7239c dkms-3.2.0/000077500000000000000000000000001500670340200124475ustar00rootroot00000000000000dkms-3.2.0/.editorconfig000066400000000000000000000003371500670340200151270ustar00rootroot00000000000000# To use this config with your editor, follow the instructions at: # http://editorconfig.org root = true [*] charset = utf-8 insert_final_newline = true indent_style = space indent_size = 4 [Makefile] indent_style = tab dkms-3.2.0/.github/000077500000000000000000000000001500670340200140075ustar00rootroot00000000000000dkms-3.2.0/.github/dependabot.yml000066400000000000000000000001661500670340200166420ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: "github-actions" directory: "/" schedule: interval: "weekly" dkms-3.2.0/.github/workflows/000077500000000000000000000000001500670340200160445ustar00rootroot00000000000000dkms-3.2.0/.github/workflows/shellcheck.yml000066400000000000000000000006151500670340200206760ustar00rootroot00000000000000name: Shellcheck on: push: pull_request: jobs: shellcheck: name: Shellcheck runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Run ShellCheck uses: ludeeus/action-shellcheck@master with: additional_files: '*.in' ignore_names: >- dkms.8.in dkms.service.in dkms_framework.conf.in dkms-3.2.0/.github/workflows/tests.yml000066400000000000000000000126731500670340200177420ustar00rootroot00000000000000name: Run tests on: # Build at 23:00 every Sunday schedule: - cron: "0 23 * * 1" pull_request: push: jobs: test-distributions: name: Build in containers strategy: matrix: distro: - {name: "almalinux", tag: "9"} - {name: "almalinux", tag: "8"} - {name: "alpine", tag: "3.21", variant: "-lts"} - {name: "alpine", tag: "3.21", variant: "-virt"} - {name: "alpine", tag: "3.20", variant: "-lts"} - {name: "alpine", tag: "3.20", variant: "-virt"} - {name: "alpine", tag: "3.19", variant: "-lts"} - {name: "alpine", tag: "3.19", variant: "-virt"} - {name: "alpine", tag: "3.18", variant: "-lts"} - {name: "alpine", tag: "3.18", variant: "-virt"} - {name: "archlinux", tag: "latest"} - {name: "archlinux", tag: "latest", variant: "-lts"} - {name: "archlinux", tag: "latest", variant: "-zen"} - {name: "centos", tag: "stream10", url: "quay.io/centos/"} - {name: "centos", tag: "stream9", url: "quay.io/centos/"} - {name: "debian", tag: "testing"} - {name: "debian", tag: "12"} - {name: "fedora", tag: "rawhide", url: "registry.fedoraproject.org/"} - {name: "fedora", tag: "42", url: "registry.fedoraproject.org/"} - {name: "fedora", tag: "41", url: "registry.fedoraproject.org/"} - {name: "gentoo/stage3", tag: "latest"} - {name: "opensuse/tumbleweed", tag: "latest", variant: "-default", url: "registry.opensuse.org/"} - {name: "opensuse/leap", tag: "15.6", variant: "-default", url: "registry.opensuse.org/"} - {name: "ubuntu", tag: "25.04"} - {name: "ubuntu", tag: "24.10"} - {name: "ubuntu", tag: "24.04"} - {name: "ubuntu", tag: "22.04"} - {name: "ubuntu", tag: "20.04"} runs-on: ubuntu-24.04 container: image: ${{ matrix.distro.url }}${{ matrix.distro.name }}:${{ matrix.distro.tag }} steps: - name: Install git for checkout action if: contains(matrix.distro.name, 'opensuse') run: | zypper --non-interactive install git - uses: actions/checkout@v4 - name: Install dependencies for Red Hat based distributions if: matrix.distro.name == 'almalinux' || matrix.distro.name == 'centos' || matrix.distro.name == 'fedora' # Relax crypto policies on Fedora 43+ to allow RSA signatures run: | dnf install -y gawk diffutils elfutils-libelf gcc kernel kernel-devel make openssl patch crypto-policies-scripts update-crypto-policies --set LEGACY make install-redhat - name: Install Alpine dependencies if: matrix.distro.name == 'alpine' run: | apk --no-cache --update add bash gcc linux-headers linux${{ matrix.distro.variant }} linux${{ matrix.distro.variant }}-dev make openssl coreutils patch make install - name: Install Arch Linux dependencies if: matrix.distro.name == 'archlinux' run: | pacman -Syu --noconfirm diffutils gcc make linux${{ matrix.distro.variant }} linux${{ matrix.distro.variant }}-headers openssl patch make install - name: Install Debian dependencies if: matrix.distro.name == 'debian' run: | apt-get update -q apt-get install -qy make linux-headers-amd64 linux-image-amd64 openssl xz-utils patch make install-debian - name: Install Gentoo Linux dependencies if: matrix.distro.name == 'gentoo/stage3' run: | echo -e "MAKEOPTS=\"-j$(nproc) -l$(nproc)\"\nACCEPT_LICENSE=\"*\"" >> /etc/portage/make.conf wget --progress=dot:mega -O - https://github.com/gentoo-mirror/gentoo/archive/master.tar.gz | tar -xz && mv gentoo-master /var/db/repos/gentoo FEATURES="getbinpkg binpkg-ignore-signature parallel-fetch parallel-install pkgdir-index-trusted" USE="-initramfs" emerge --quiet --noreplace -j$(nproc) -l$(nproc) --autounmask-continue --with-bdeps=n '>=sys-kernel/gentoo-kernel-bin-6.6.0' make install - name: Install openSUSE leap dependencies if: contains(matrix.distro.name, 'opensuse') run: | zypper --non-interactive install diffutils elfutils gcc kernel${{ matrix.distro.variant }} kernel${{ matrix.distro.variant }}-devel make openssl patch zstd make install - name: Install Ubuntu dependencies if: matrix.distro.name == 'ubuntu' run: | apt-get update -q apt-get install -qy gcc make linux-headers-generic linux-image-generic openssl shim-signed patch make install-debian - name: Run tests run: | for moddir in /usr/lib/modules/ /lib/modules/; do if [ -e "$moddir" ]; then kernels=$(find "$moddir" -maxdepth 1 -type d -exec basename {} \;) break fi done # There should be two entries - "modules" and the kernel we installed if [ $(echo "${kernels}" | wc -l) -ne 2 ]; then echo >&2 "Error: invalid number of kernels installed" fi KERNEL_VER=$(echo "${kernels}" | tail -n1) if [ -z "${KERNEL_VER}" ] ; then echo >&2 "Error: no kernel package found" exit 1 fi echo "Found kernel ${KERNEL_VER}" export KERNEL_VER echo "Module search paths" for depmod in /etc/depmod.d/ /usr/lib/depmod.d/ /lib/depmod.d/; do [ -e "$depmod" ] && grep -r ^search "$depmod" || true done ./run_test.sh dkms-3.2.0/.gitignore000066400000000000000000000004551500670340200144430ustar00rootroot00000000000000/dist dkms dkms.8 dkms.bash-completion dkms.zsh-completion dkms_framework.conf dkms_autoinstaller dkms.service dkms_common.postinst debian_kernel_install.d debian_kernel_postinst.d debian_kernel_preinst.d debian_kernel_prerm.d redhat_kernel_install.d test_cmd_expected_output.log test_cmd_output.log dkms-3.2.0/COPYING000066400000000000000000000431001500670340200135000ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Moe Ghoul, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. dkms-3.2.0/Makefile000066400000000000000000000072241500670340200141140ustar00rootroot00000000000000RELEASE_DATE := "07 May 2025" RELEASE_MAJOR := 3 RELEASE_MINOR := 2 RELEASE_MICRO := 0 RELEASE_NAME := dkms RELEASE_VERSION := $(RELEASE_MAJOR).$(RELEASE_MINOR).$(RELEASE_MICRO) RELEASE_STRING := $(RELEASE_NAME)-$(RELEASE_VERSION) SHELL=bash SBIN = /usr/sbin LIBDIR = /usr/lib/dkms MODDIR = /lib/modules KCONF = /etc/kernel KINSTALL = /usr/lib/kernel/install.d SYSTEMD = /usr/lib/systemd/system #Define the top-level build directory BUILDDIR := $(shell pwd) SED ?= sed SED_SUBSTITUTIONS = \ -e 's,@RELEASE_STRING@,$(RELEASE_STRING),g' \ -e 's,@RELEASE_DATE@,$(RELEASE_DATE),g' \ -e 's,@SBINDIR@,$(SBIN),g' \ -e 's,@KCONFDIR@,$(KCONF),g' \ -e 's,@MODDIR@,$(MODDIR),g' \ -e 's,@LIBDIR@,$(LIBDIR),g' %: %.in $(SED) $(SED_SUBSTITUTIONS) $< > $@ GENERATED= \ dkms \ dkms.8 \ dkms_autoinstaller \ dkms.bash-completion \ dkms.zsh-completion \ dkms_common.postinst \ dkms_framework.conf \ dkms.service \ debian_kernel_install.d \ debian_kernel_postinst.d \ debian_kernel_preinst.d \ debian_kernel_prerm.d \ redhat_kernel_install.d all: $(GENERATED) clean: -rm -rf dist/ $(RM) $(GENERATED) install: all $(if $(strip $(VAR)),$(error Setting VAR is not supported)) install -d -m 0755 $(DESTDIR)/var/lib/dkms ifneq (,$(DESTDIR)) $(if $(filter $(DESTDIR)%,$(SBIN)),$(error Using a DESTDIR as prefix for SBIN is no longer supported)) $(if $(filter $(DESTDIR)%,$(LIBDIR)),$(error Using a DESTDIR as prefix for LIBDIR is no longer supported)) $(if $(filter $(DESTDIR)%,$(KCONF)),$(error Using a DESTDIR as prefix for KCONF is no longer supported)) endif install -D -m 0755 dkms $(DESTDIR)$(SBIN)/dkms $(if $(strip $(ETC)),$(error Setting ETC is not supported)) install -D -m 0644 dkms_framework.conf $(DESTDIR)/etc/dkms/framework.conf install -d -m 0755 $(DESTDIR)/etc/dkms/framework.conf.d $(if $(strip $(BASHDIR)),$(error Setting BASHDIR is not supported)) install -D -m 0644 dkms.bash-completion $(DESTDIR)/usr/share/bash-completion/completions/dkms install -D -m 0644 dkms.zsh-completion $(DESTDIR)/usr/share/zsh/site-functions/_dkms install -D -m 0644 dkms.8 $(DESTDIR)/usr/share/man/man8/dkms.8 install-redhat: install ifneq (,$(DESTDIR)) $(if $(filter $(DESTDIR)%,$(SYSTEMD)),$(error Using a DESTDIR as prefix for SYSTEMD is no longer supported)) endif install -D -m 0644 dkms.service $(DESTDIR)$(SYSTEMD)/dkms.service install -D -m 0755 redhat_kernel_install.d $(DESTDIR)$(KINSTALL)/40-dkms.install install -D -m 0755 dkms_common.postinst $(DESTDIR)$(LIBDIR)/common.postinst install-debian: install $(if $(strip $(SHAREDIR)),$(error Setting SHAREDIR is not supported)) install -D -m 0755 dkms_autoinstaller $(DESTDIR)$(LIBDIR)/dkms_autoinstaller install -D -m 0755 dkms_apport.py $(DESTDIR)/usr/share/apport/package-hooks/dkms_packages.py install -D -m 0755 dkms_common.postinst $(DESTDIR)$(LIBDIR)/common.postinst install -D -m 0755 debian_kernel_install.d $(DESTDIR)$(KINSTALL)/40-dkms.install install -D -m 0755 debian_kernel_postinst.d $(DESTDIR)$(KCONF)/postinst.d/dkms install -D -m 0755 debian_kernel_postinst.d $(DESTDIR)$(KCONF)/header_postinst.d/dkms install -D -m 0755 debian_kernel_preinst.d $(DESTDIR)$(KCONF)/preinst.d/dkms install -D -m 0755 debian_kernel_prerm.d $(DESTDIR)$(KCONF)/prerm.d/dkms install -D -m 0644 dkms.service $(DESTDIR)$(SYSTEMD)/dkms.service install-doc: $(if $(strip $(DOC)),$(error Setting DOCDIR is not supported)) install -d -m 0755 $(DESTDIR)/usr/share/doc/dkms install -m 0644 COPYING README.md $(DESTDIR)/usr/share/doc/dkms .PHONY = tarball TARBALL=$(BUILDDIR)/dist/$(RELEASE_STRING).tar.gz tarball: $(TARBALL) $(TARBALL): all mkdir -p $(@D) git archive --prefix=$(RELEASE_STRING)/ --add-file=dkms --add-file=dkms.8 -o $@ HEAD dkms-3.2.0/README.md000066400000000000000000000201621500670340200137270ustar00rootroot00000000000000# Dynamic Kernel Module System (DKMS) This intention of this README is to explain how DKMS can be used in conjunction with tarballs which contain a dkms.conf file within them. The DKMS project (and any updates) can be found at: https://github.com/dell/dkms ## Installation Installation is performed from the source directory with one of the following commands: ``` make install make install-debian make install-redhat ``` Distribution specific installations (RPM, DEB, etc.) are not contained in this source repository. ## Installation of DKMS Tarballs DKMS can install directly from the following: 1. Generic module source tarballs which contain a dkms.conf file 2. Specially created DKMS tarballs with module source, pre-built module binaries and a `dkms.conf` file 3. Specially created DKMS tarballs with pre-built module binaries and a `dkms.conf` file 4. Manual placement of module source and `dkms.conf` file into `/usr/src/-/` directory In order to load any tarball into the DKMS tree, you must use the following command: ``` # dkms ldtarball /path/to/dkms_enabled.tar.gz ``` This command will first inspect the tarball to ensure that it contains a `dkms.conf` configuration file for that module. If it cannot find this file anywhere within the archive, then the `ldtarball` command will fail. From here, it will place the source in the tarball into `/usr/src/-/`. If source already exists in the directory, it will not overwrite it unless the `--force` option is specified. If the tarball is of type "c" above and does not contain source, it will only continue to load the tarball if existing module source is found in `/usr/src/-/` or if the `--force` option is specified. Continuing on, if the tarball is of type "b" or "c" it will then load any pre-built binaries found within the tarball into the DKMS tree, but will stop short of installing them. Thus, all pre-built binaries will then be of in the *built* state when checked from the `dkms status` command. You can then use the `dkms install` command to install any of these binaries. To create a tarball of type "1" above, you need only to take module source and a `dkms.conf` file for that module and create a tarball from them. Tarballs of type *2* or type *3* are created with the `dkms mktarball` command. To create a type *3* tarball, you must specify the flag `--binaries-only` along with the `mktarball` command. ### Installation on Systems with no Module Source and/or Compiler If you choose not to load module source on your system or if you choose not to load a compiler such as gcc onto your system, DKMS can still be used to install modules. It does this through use of DKMS binary only tarballs as explained in this README under tarballs of type *c*. If your system does not have module source, loading the dkms tarball will fail because of this. To avoid this, use the `--force` flag, as such: ``` # dkms ldtarball /path/to/dkms_enabled.tar.gz --force ``` This will load the pre-built binaries into the dkms tree, and create the directory `/usr/src/-/` which will only contain the module's `dkms.conf` configuration file. Once the tarball is loaded, you can then use `dkms install` to install any of the pre-built modules. Of course, since the module source will not be located in your DKMS tree, you will not be able to build any modules with DKMS for this package. ## Module signing By default, DKMS generates a self signed certificate for signing modules at build time and signs every module that it builds before it gets compressed in the configured kernel compression mechanism of choice. Private key and certificate are auto generated the first time DKMS is run and placed in `/var/lib/dkms`. These certificate files can be pre-populated with your own certificates of choice. The location as well can be changed by setting the appropriate variables in `/etc/dkms/framework.conf`. For example, to allow usage of the system default Ubuntu `update-secureboot-policy` set the configuration file as follows: ``` mok_signing_key="/var/lib/shim-signed/mok/MOK.priv" mok_certificate="/var/lib/shim-signed/mok/MOK.der" ``` NOTE: If any of the files specified by `mok_signing_key` and `mok_certificate` are non-existant, DKMS will re-create both files. The paths specified in `mok_signing_key`, `mok_certificate` and `sign_file` can use the variable `${kernelver}` to represent the target kernel version. ``` sign_file="/lib/modules/${kernelver}/build/scripts/sign-file" ``` The variable `mok_signing_key` can also be a `pkcs11:...` string for a [PKCS#11 engine](https://www.rfc-editor.org/rfc/rfc7512), as long as the `sign_file` program supports it. ### Code Signing extended key usage validation Your kernel might be patched and compiled with the option `CONFIG_CHECK_CODESIGN_EKU` to assist with compliance to the NIAP Protection Profile for General Purpose Operating Systems. Page 35 of [version 4.3 of the specification](https://www.niap-ccevs.org/protectionprofiles/469) states: ``` * The OS shall validate the extendedKeyUsage field according to the following rules: * Certificates used for trusted updates and executable code integrity verification shall have the Code Signing Purpose (id-kp 3 with OID 1.3.6.1.5.5.7.3.3) in the extendedKeyUsage field. ``` So from DKMS 3.1.7 the MOK self signed certificate is now generated with the `extendedKeyUsage` set to `codeSigning`. This requires version *1.1.1 or newer* of the `openssl` command to be present on the system. In case your system is validating the extended key usage and you have autogenerated keys from a DKMS version prior to 3.1.7, the keys need to be regenerated. For example, assuming the default configuration: ``` # rm -fr /var/lib/dkms/mok.{key,pub} # dkms generate_mok Signing key: /var/lib/dkms/mok.key Public certificate (MOK): /var/lib/dkms/mok.pub ``` ## Secure Boot On an UEFI system with Secure Boot enabled, modules require signing (as described in the above paragraph) before they can be loaded and the firmware of the system must know the correct public certificate to verify the module signature. For importing the MOK certificate make sure `mokutil` is installed. To check if Secure Boot is enabled: ``` # mokutil --sb-state SecureBoot enabled ``` With the appropriate key material on the system, enroll the public key: ``` # mokutil --import /var/lib/dkms/mok.pub ``` You'll be prompted to create a password. Enter it twice, it can also be blank. Reboot the computer. At boot you'll see the MOK Manager EFI interface: ![SHIM UEFI key management](/images/mok-key-1.png) Press any key to enter it, then select "Enroll MOK": ![Perform MOK management](/images/mok-key-2.png) Then select "Continue": ![Enroll MOK](/images/mok-key-3.png) And confirm with "Yes" when prompted: ![Enroll the key(s)?](/images/mok-key-4.png) After this, enter the password you set up with `mokutil --import` in the previous step: ![Enroll the key(s)?](/images/mok-key-5.png) At this point you are done, select "OK" and the computer will reboot trusting the key for your modules: ![Perform MOK management](/images/mok-key-6.png) After reboot, you can inspect the MOK certificates with the following command: ``` # mokutil --list-enrolled | grep DKMS Subject: CN=DKMS module signing key ``` To check the signature on a built DKMS module that is installed on a system: ``` # modinfo dkms_test | grep ^signer signer: DKMS module signing key ``` The module can now be loaded without issues. ### MOK certificate encryption algorithm UEFI specification 2.11 [contains a list of valid encryption keys](https://uefi.org/specs/UEFI/2.11/37_Secure_Technologies.html#encryption-algorithm-properties) for the MOK certificate. The list is quite limited, basically offering only RSA as a valid key type. For maximum compatibility, DKMS generates the MOK certificate with a *2048 bit RSA key with SHA-2 256 as a digest*. ## Further Documentation Once DKMS is installed, you can reference its man page for further information on different DKMS options and also to understand the formatting of a module's `dkms.conf` configuration file. The DKMS project is located at: https://github.com/dell/dkms dkms-3.2.0/debian_kernel_install.d.in000066400000000000000000000002101500670340200175220ustar00rootroot00000000000000#!/bin/sh if [ "$1" = "add" ]; then @KCONFDIR@/postinst.d/dkms "$2" fi if [ "$1" = "remove" ]; then @KCONFDIR@/prerm.d/dkms "$2" fi dkms-3.2.0/debian_kernel_postinst.d.in000066400000000000000000000002711500670340200177460ustar00rootroot00000000000000#!/bin/sh # We're passed the version of the kernel being installed inst_kern=$1 if [ -x @LIBDIR@/dkms_autoinstaller ]; then exec @LIBDIR@/dkms_autoinstaller start "$inst_kern" fi dkms-3.2.0/debian_kernel_preinst.d.in000066400000000000000000000004121500670340200175440ustar00rootroot00000000000000#!/bin/sh # This script is triggered when the kernel (linux-image) package is being # installed/upgraded. We're passed the version of the kernel being installed. inst_kern=$1 if command -v dkms > /dev/null; then dkms kernel_preinst -k "$inst_kern" fi exit 0 dkms-3.2.0/debian_kernel_prerm.d.in000066400000000000000000000003731500670340200172130ustar00rootroot00000000000000#!/bin/sh # This script is triggered when the kernel (linux-image) package is being # removed. We're passed the version of the kernel being removed. inst_kern=$1 if command -v dkms > /dev/null; then dkms kernel_prerm -k "$inst_kern" fi exit 0 dkms-3.2.0/dkms.8.in000066400000000000000000001017601500670340200141100ustar00rootroot00000000000000.\" -*- nroff -*- .\" .\" .SY, .YS, .OP macros from /usr/share/groff/1.21/tmac/an-ext.tmac .\" .\" Declare start of command synopsis. Sets up hanging indentation. .de SY . ie !\\n(mS \{\ . nh . nr mS 1 . nr mA \\n(.j . ad l . nr mI \\n(.i . \} . el \{\ . br . ns . \} . . HP \w'\fB\\$1\fP\ 'u . B "\\$1" .. . . .\" End of command synopsis. Restores adjustment. .de YS . in \\n(mIu . ad \\n(mA . hy \\n(HY . nr mS 0 .. . . .\" Declare optional option. .de OP . ie \\n(.$-1 \ . RI "[\fB\\$1\fP" "\ \\$2" "]" . el \ . RB "[" "\\$1" "]" .. .TH DKMS 8 @RELEASE_DATE@ @RELEASE_STRING@ .SH NAME dkms \- Dynamic Kernel Module Support .SH SYNOPSIS .SY dkms .OP action .OP options .OP module/module-version .OP /path/to/source-tree .OP /path/to/tarball.tar .OP /path/to/driver.rpm .YS .SH DESCRIPTION .B dkms is a framework which allows kernel modules to be dynamically built for each kernel on your system in a simplified and organized fashion. .SH ACTIONS .SY add .OP "module/module\-version | /path/to/source\-tree | /path/to/tarball.tar" .YS .IP "" 4 Adds a module/module\-version combination to the tree for builds and installs. If .IR module/module\-version , .IR "\-m module/module\-version" , or .I \-m module\ \-v module\-version are passed as options, this command requires source in .I /usr/src/\-/ as well as a properly formatted .I dkms.conf file. If .I /path/to/source\-tree is passed as an option, and source-tree contains a .I dkms.conf file, it will copy .I /path/to/source\-tree to .IR /usr/src/module\-module\-version . If .I /path/to/tarball.tar is passed, this command behaves like the .B ldtarball command. .SY remove .OP module/module\-version .OP -k kernel/arch .OP \-\-all .YS .IP "" 4 Removes a module/version or module/version/kernel/arch combination from the tree. If the module is currently installed, it first uninstalls it and if applicable, will replace it with its original_module. Use the .B \-\-all option in order to remove all instances for every kernel at once. .SY build .OP module/module\-version .OP -k kernel/arch .OP --force .YS .IP "" 4 Builds the specified module/version combo for the specified kernel/arch. If the .I \-k option is not specified it builds for the currently running kernel and arch. All builds occur in the directory .I /var/lib/dkms///build/ . If the module/module\-version combo has not been added, dkms will try to add it, and in that case .B build can take the same arguments that .B add can. If the module is already built, it will not be rebuilt again by default, and the .B --force option should be used to override this. .SY unbuild .OP module/module\-version .OP -k kernel/arch .OP \-\-all .YS .IP "" 4 Undoes the build for a module/version or module/version/kernel/arch combination from the tree. If the module is currently installed, it first uninstalls it and if applicable, will replace it with its original_module. Finally all binary kernel modules are removed. Use the .B \-\-all option in order to remove all instances for every kernel at once. .SY install .OP module/module\-version .OP -k kernel/arch .OP --force .OP /path/to/driver.rpm .YS .IP "" 4 Installs a built module/version combo onto the kernel it was built for. If the kernel option is not specified it assumes the currently running kernel. If the module has not been built, dkms will try to build it. If the module has not been added, dkms will try to add it. In both cases, the .B install command can then take the same arguments as the .B build or .B add commands. If the module is already installed, it will not be reinstalled again by default, and the .B --force option should be used to override this. If you pass a .rpm file, dkms will try to install that file with .BR "rpm -Uvh" , and it will perform an .B autoinstall action to be sure that everything is built for your kernel if the RPM installed successfully. .SY uninstall .OP module/module\-version .OP -k kernel/arch .OP \-\-all .YS .IP "" 4 Uninstalls an installed module/module\-version combo from the kernel/arch passed in the -k option, or the current kernel if the -k option was not passed. Use the .B \-\-all option in order to uninstall all instances for every kernel at once. After uninstall completion, the driver will be left in the built state. To completely remove a driver, the remove action should be utilized. .SY match .OP --templatekernel kernel/arch .OP -k kernel/arch .YS .IP "" 4 Match installs modules onto the specified kernel by looking at the configuration of the specified .B templatekernel. Every module that is installed on the .B templatekernel within .B dkms is then installed on that specified kernel. .SY mktarball .OP module/module\-version .OP -k kernel/arch .OP --archive /path/to/tarball.tar .OP --source-only .OP --binaries-only .YS .IP "" 4 Creates a tarball archive for the specified module/version of all files in the DKMS tree for that module/version combination. This includes the source and any built modules for kernels in the tree (as specified). Otherwise, you can specify a singular kernel to archive only, or multiple kernels to archive ( .I \-k kernel1/arch1 \-k kernel2/arch2 ). Optionally, you can use .B \-\-archive to specify the file that you would like to save this tarball to. You can also specify .B \-\-binaries\-only if you want the resultant tarball not to include the module source. Likewise, .B \-\-source-only can be used to specify that no prebuilt binaries should be included in the tarball. In general, .B mktarball is great for systems management purposes as you can build your driver on just one system and then use .B ldtarball on all of your other systems to get the same built modules loaded without having to wait for anything to compile. .SY ldtarball .OP /path/to/tarball.tar .OP --force .YS .IP "" 4 This takes a tarball made from the .B mktarball command and loads it into your DKMS tree. This will leave any newly added modules in the built state and .B dkms install should then be called to install any of them. If files already exist where .B ldtarball is attempting to place them, it will warn and not copy over them. The .B \-\-force option should be used to override this. .SY status .OP module/module\-version .OP -k kernel/arch .YS .IP "" 4 Returns the current status of modules, versions and kernels within the tree as well as whether they have been added, built or installed. Status can be shown for just a certain module, a certain kernel, a module/version combination or a module/version/kernel combination. If the source directory, or the symbolic link 'source' pointing to it is missing, the status of the module/version combination will be displayed as 'broken'. In that case dkms will not perform any other action on that particular module/version combination. Manual intervention is required. If only the symbolic link 'source' is missing, the .B add action may be used to re-add the module/version combination to dkms. .SY autoinstall .YS .IP "" 4 Attempt to install the latest revision of all modules that have been installed for other kernel revisions. The DKMS autoinstaller service is a stub that uses this action to perform its work. .SY generate_mok .YS .IP "" 4 Command to be issued standalone to generate Secure Boot keys. Required only if prior manipulation of the keys is needed, otherwise the keys are automatically generated on the first build attempt of a DKMS module. No additional arguments are parsed. .SH OPTIONS .TP .B \-m / The name of the module and module version you want to operate on. The .B \-m part of this option is optional, and can be omitted in virtually all circumstances. .TP .B \-v The version of the module to execute the specified action upon. This option only has to be specified if you pass a .B \-m option without a component of its own. .TP .B \-k / The kernel and arch to perform the action upon. You can specify multiple kernel version/arch pairs on the command line by repeating the \-k argument with a different kernel version and arch. However, not all actions support multiple kernel versions (it will error out in this case). The arch part can be omitted, and DKMS will assume you want it to be the arch of the currently running system. .TP .B \-a, \-\-arch The system architecture to perform the action upon. It is optional if you pass it as part of the .B \-k option. If not specified, it assumes the arch of the currently running system ( .B uname \-m ). You can specify multiple arch parameters on the same command line by repeating the .B \-a argument with a different architecture name. When multiple architectures are specified, there must be a 1:1 relationship between .B \-k arguments to .B \-a arguments. DKMS will then assume the first .B \-a argument aligns with the first .B \-k and so on for the second, third, etc. For example, if you were to specify: .B \-k kernel1 \-k kernel2 \-a i386 \-k kernel3 \-a i686 \-a x86_64 , DKMS would process this as: .B kernel1-i386 , .B kernel2-i686 , .B kernel3-x86_64. .TP .B \-q, \-\-quiet Quiet. .TP .B \-V, \-\-version Prints the currently installed version of dkms and exits. .TP .B \-h, \-\-help .TP .B \-c The location of the .I dkms.conf file. This is needed for the add action and if not specified, it is assumed to be located in .I /usr/src/\-/ . See below for more information on the format of .I dkms.conf. .TP .B \-\-config During a .B build this option is used to specify an alternate location for the kernel .I include/config/auto.conf configuration file which contains that kernel configuration. Normally, .B dkms is able to derive the location of the configuration file from the filesystem, but if there is a problem in the detection, you will need to tell .B dkms where the necessary .I include/config/auto.conf file (or the legacy .I .config file) can be found so that your kernel can be properly prepared for the module build. .TP .B \-\-archive This option is used during a .B ldtarball action to specify the location of the tarball you wish to load into your DKMS tree. You only have to specify the .B --archive part of this option if does not already exist as a file. .TP .B \-\-templatekernel This option is required for the action: .B match. Match will look at the templatekernel specified and install all of the same module/version combinations on the other kernel. .TP .B \-\-force This option can be used in conjunction with .B build, install and .B ldtarball to force copying over existing files. .TP .B \-\-force\-version\-override This option skips the checks whether the version of the module, which is going to be installed, is newer than the already installed version. .TP .B \-\-binaries\-only This option can be used in conjunction with .B mktarball in order to create a DKMS tarball which does not contain the source for the module within it. This can be helpful in reducing the size of the tarball if you know that the system which this tarball will be loaded upon already has the source installed. In order to load a tarball made as binaries-only .B you must have the module source in that systems DKMS tree. If you do not, DKMS .B will refuse to load a binaries-only tarball. .TP .B \-\-source\-only This option can be used in conjunction with .B mktarball but do not want the tarball you create to have any prebuilt modules within it, passing this option will keep its internal DKMS tarball from containing any prebuilt modules. .TP .B \-\-all This option can be used to automatically specify all relevant kernels/arches for a module/module-version. This can be used for things like remove, unbuild and uninstall. This saves the trouble of having to actually specify \-k kernel1 \-a arch1 \-k kernel2 \-a arch2 for every kernel you have built your module for. .TP .B \-\-no\-depmod This option prevents DKMS from running the depmod command during .B install and .B uninstall which will avoid (re)calculating module dependencies and thereby save time. .TP .B \-\-modprobe\-on\-install This option executes modprobe on the modules upon successful installation. .TP .B \-\-kernelsourcedir Using this option you can specify the location of your kernel source directory. Most likely you will not need to set this if your kernel source is accessible via .I @MODDIR@/$kernel_version/build. .TP .B \-\-directive <"cli\-directive=cli\-value"> Using this option, you can specify additional directives from the command line. The .B \-\-directive option can be used multiple times on the same command-line to specify multiple additional command line directives. .TP .B \-\-rpm_safe_upgrade This flag should be used when packaging DKMS enabled modules in RPMs. It should be specified during both the .B add and .B remove actions in the RPM spec to ensure that DKMS and RPM behave correctly in all scenarios when upgrading between various versions of a dkms enabled module RPM package. .TP .B \-\-dkmstree path/to/place Provides a destination tree for building and installing modules to. Useful in cases that you don't want to contaminate a system when using solely for building. .TP .B \-\-sourcetree path/to/place Provides a location to build a DKMS package from. Useful for systems that you may not have root access, but would still like to be able to build DKMS packages. .TP .B \-\-installtree path/to/place Provides a location to place modules when a .I dkms install command is issued. .TP .B \-j number Run no more than .I number jobs in parallel; see the -j option of .I make(1). Defaults to the number of CPUs in the system, detected by .I nproc(1). Specify 0 to impose no limit on the number of parallel jobs. .TP .B \-\-verbose Enable verbose output of external commands executed in DKMS. .SH ORIGINAL MODULES During the first install of a module for a , .B dkms will search .I @MODDIR@/ for a pre-existing module of the same name. If one is found, it will automatically be saved as an "original_module" so that if the newer module is later removed, .B dkms will put the original module back in its place. Currently, DKMS searches for these original modules with first preference going to modules located in .I @MODDIR@//updates/ followed by .B $DEST_MODULE_LOCATION (as specified in .I dkms.conf ). If one cannot be found in either location, a find will be used to locate one for that kernel. If none are found, then during a later uninstall, your kernel will not have that module replaced. If more than one is found, then the first one located (by preference indicated above) will be considered the "original_module". As well, all copies of the same-named module will be removed from your kernel tree and placed into .I /var/lib/dkms//original_module/$kernelver/collisions so that they can be *manually* accessible later. DKMS will never actually do anything with the modules found underneath the .B /collisions directory, and they will be stored there until you manually delete them. .SH DKMS.CONF When performing an .BR add , a proper .I dkms.conf file must be found. A properly formatted configuration file is essential for communicating to DKMS how and where the module should be installed. While not all the directives are required, providing as many as possible helps to limit any ambiguity. Note that .I dkms.conf is really only a shell\-script of variable definitions which are then sourced in by the .B dkms executable (of the format, .I DIRECTIVE="directive text goes here" ). As well, the directives are case\-sensitive and should be given in ALL CAPS. It is important to understand that many of the DKMS directives are arrays whose index values are tied together. These array associations can be considered families, and there are currently three such families of directive arrays. .B MAKE[#] and .B MAKE_MATCH[#] make up one family. .B PATCH[#] and .B PATCH_MATCH[#] make up the second family. The third and largest family consists of .B BUILT_MODULE_NAME[#] , .B BUILT_MODULE_LOCATION[#] , .B DEST_MODULE_NAME[#] , .B DEST_MODULE_LOCATION[#] and .B STRIP[#] . When indexing these arrays when creating your .I dkms.conf , each family should start at index value 0. .TP .B PACKAGE_NAME= This directive is used to give the name associated with the entire package of modules. This is the same name that is used with the .B \-m option when building, adding, etc. and may not necessarily be the same as the .B MODULE_NAME. This directive must be present in every DKMS configuration file. .TP .B PACKAGE_VERSION= This directive is used to give the version associated with the entire package of modules being installed within that dkms package. This directive must be present in every DKMS configuration file. .TP .B BUILT_MODULE_NAME[#]= This directive gives the name of the module just after it is built. If your DKMS module package contains more than one module to install, this is a .B required directive for all of the modules. This directive should explicitly not contain any trailing ".o" or ".ko". Note that for each module within a dkms package, the numeric value of .B # must be the same for each of .B BUILT_MODULE_NAME , .B BUILT_MODULE_LOCATION , .B DEST_MODULE_NAME and .B DEST_MODULE_LOCATION and that the numbering should start at 0 (eg. .B BUILT_MODULE_NAME[0]="qla2200" BUILT_MODULE_NAME[1]="qla2300" ). .TP .B BUILT_MODULE_LOCATION[#]= This directive tells DKMS where to find your built module after it has been built. This pathname should be given relative to the root directory of your source files (where your .I dkms.conf file can be found). If unset, DKMS expects to find your .B BUILT_MODULE_NAME[#] in the root directory of your source files. Note that for each module within a dkms package, the numeric value of .B # must be the same for each of .B BUILT_MODULE_NAME , .B BUILT_MODULE_LOCATION , .B DEST_MODULE_NAME and .B DEST_MODULE_LOCATION and that the numbering should start at 0 (eg. .B BUILT_MODULE_LOCATION[0]="some/dir/" BUILT_MODULE_LOCATION[1]="other/dir/" ). .TP .B DEST_MODULE_NAME[#]= This directive can be used to specify the name of the module as it should be installed. This will rename the module from .B BUILT_MODULE_NAME[#] to .B DEST_MODULE_NAME[#]. This directive should explicitly not contain any trailing ".o" or ".ko". If unset, it is assumed to be the same value as .B BUILT_MODULE_NAME[#]. Note that for each module within a dkms package, the numeric value of .B # must be the same for each of .B BUILT_MODULE_NAME , .B BUILT_MODULE_LOCATION , .B DEST_MODULE_NAME and .B DEST_MODULE_LOCATION and that the numbering should start at 0 (eg. .B DEST_MODULE_NAME[0]="qla2200_6x" DEST_MODULE_NAME[1]="qla2300_6x" ). .TP .B DEST_MODULE_LOCATION[#]= This directive specifies the destination where a module should be installed to, once compiled. It also is used for finding original_modules. This is a .B required directive, except as noted below. This directive must start with the text "/kernel" which is in reference to .I @MODDIR@//kernel. Note that for each module within a dkms package, the numeric value of .B # must be the same for each of .B BUILT_MODULE_NAME , .B BUILT_MODULE_LOCATION , .B DEST_MODULE_NAME and .B DEST_MODULE_LOCATION and that the numbering should start at 0 (eg. .B DEST_MODULE_LOCATION[0]="/kernel/drivers/something/" DEST_MODULE_LOCATION[1]="/kernel/drivers/other/" ). .B DEST_MODULE_LOCATION is ignored on Fedora, Red Hat Enterprise Linux, SuSE Linux Enterprise Server, openSUSE and Ubuntu. Instead, the proper distribution-specific directory is used. .TP .B STRIP[#]= By default strip is considered to be "yes". If set to "no", DKMS will not run strip .B \-g against your built module to remove debug symbols from it. .B STRIP[0] is used as the default for any unset entries in the .B STRIP array. .TP .B MAKE[#]= The MAKE directive array tells DKMS which make command should be used for building your module. The default make command should be put into .B MAKE[0]. Other entries in the MAKE array will only be used if their corresponding entry in .B MAKE_MATCH[#] matches, as a regular expression (using grep -E), the kernel that the module is being built for. Note that if no value is placed in .B MAKE_MATCH[#] for any .B MAKE[#] where # > 0, then that .B MAKE directive is ignored. .B MAKE_MATCH[0] is optional and if it is populated, it will be used to determine if MAKE[0] should be used to build the module for that kernel. If multiple .B MAKE_MATCH directives match against the kernel being built for, the last matching .B MAKE[#] will be used to build your module. If no .B MAKE directive is specified or if no .B MAKE_MATCH matches the kernel being built for, DKMS will attempt to use a generic make command to build your module. .B KERNELRELEASE=$kernelver -j$parallel_jobs will be automatically appended to .B MAKE[#]. If you want to suppress this behavior, you can quote the make command: 'make'. .TP .B MAKE_MATCH[#]= See the above entry on .B MAKE[#] directives. This array should be populated with regular expressions which, when matched against the kernel being built for, will tell .B DKMS to use the corresponding make command in the .B MAKE[#] directive array to build your module. .TP .B NO_WEAK_MODULES= The .B NO_WEAK_MODULES directive, when set to "yes", prevents dkms from creating a symlink into the .B weak-updates directory. The weak modules facility was designed to eliminate the need to rebuild kernel modules when kernel upgrades occur and relies on the symbols within the kABI. Valid values are "yes" or "no". The kABI kernel module interface is currently supported on Red Hat Enterprise Linux (and derivatives), SUSE Linux Enterprise Server and openSUSE Leap; on other distributions this directive is ignored. .TP .B OBSOLETE_BY= This directive allows you to specify a kernel version that obsoletes the necessity for this particular DKMS module. This can be specified as a particular upstream kernel or an ABI bump of a kernel. For example, "2.6.24" would be an upstream kernel and "2.6.24\-16" would represent an ABI bump for a kernel. Both are valid in this area. Please consider using .B BUILD_EXCLUSIVE_KERNEL_MAX instead of .B OBSOLETE_BY as the former is a more general approach to solve the same problem. Please avoid the use of .B OBSOLETE_BY wherever possible. It's use indicates a lack of proper module versioning using .B MODULE_VERSION() tags in the module source itself. It is better to fix the .B MODULE_VERSION() tags than use .B OBSOLETE_BY. This also introduces a implicit distribution/version dependency on the package, as the value of .B OBSOLETE_BY is meaningful only in the context of a single distribution/version. .TP .B PATCH[#]= Use the PATCH directive array to specify patches which should be applied to your source before a build occurs. All patches are expected to be in .B \-p1 format and are applied with the patch .B \-p1 command. Each directive should specify the filename of the patch to apply, and all patches must be located in the patches subdirectory of your source directory ( .I /usr/src/\-/patches/ ). If any patch fails to apply, the build will be halted and the rejections can be inspected in .I /var/lib/dkms///build/. If a patch should only be applied conditionally, the .B PATCH_MATCH[#] array should be used, and a corresponding regular expression should be placed in .B PATCH_MATCH[#] which will alert dkms to only use that .B PATCH[#] if the regular expression matches the kernel which the module is currently being built for. .TP .B PATCH_MATCH[#]= See the above description for .B PATCH[#] directives. If you only want a patch applied in certain scenarios, the .B PATCH_MATCH array should be utilized by giving a regular expression which matches the kernels you intend the corresponding .B PATCH[#] to be applied to before building that module. .TP .B AUTOINSTALL= If this directive is set to "yes" then the DKMS autoinstaller service will automatically try to install this module on any kernel you boot into. See the section on .B DKMS AUTOINSTALLER for more information. Valid values are "yes" or "no". .TP .B BUILD_DEPENDS[#]= This optional directive is an array that allows you to specify other modules as dependencies for your module. Each array element should be the .B PACKAGE_NAME of another module that is managed by dkms. Do not specify a version or architecture in the dependency. A missing dependency requires the parameter .OP --force to still attempt the build of the module. .TP .B BUILD_DEPENDS_REBUILD= If this directive is set to .B yes then the module which has .B BUILD_DEPENDS being set, will get rebuilt every time a dependency changes version. This is usually provided in a specific .I /etc/dkms/.conf on a per installation basis. To keep track of the dependency change, the version of the module that was used at build time is recorded in the file .I /var/lib/dkms//-/.dep_. As soon as the module version changes, this is compared and the dependent module is rebuilt. With the parameter .I --force the dependency is not tracked. .TP .B BUILD_EXCLUSIVE_KERNEL= This optional directive allows you to specify a regular expression which defines the subset of kernels which DKMS is allowed to build your module for. If the kernel being built for does not match against this regular expression (or does not the satisfy the constraints of any other .B BUILD_EXCLUSIVE_* directive), the build will error out with exit code 77. Note that .B dkms autoinstall will ignore this type of error condition and simply skip the respective modules. For example, if you set it as ="^2\.4.*", your module would not be built for 2.6 or later kernels. .TP .B BUILD_EXCLUSIVE_KERNEL_MIN= and .B BUILD_EXCLUSIVE_KERNEL_MAX= These optional directives allow one to specify the minimal and maximal kernel versions supported by the module. If one (or both) of these are defined, the module will not be built for kernels outside the specified version limits. For example, if you set .B BUILD_EXCLUSIVE_KERNEL_MIN as "=3.5", your module would be built for e.g. "3.5-rc2", "3.6.18" or other later versions but not for "3.4.999" or earlier kernels. Similarly, if you set .B BUILD_EXCLUSIVE_KERNEL_MAX as ="4.12", your module would be built for e.g. "4.11.999", "3.9-rc5" or other earlier versions, but not for "4.12-rc1" or later kernels. .TP .B BUILD_EXCLUSIVE_ARCH= This optional directive functions very similarly to .B BUILD_EXCLUSIVE_KERNEL except that it matches against the kernel architecture. For example, if you set it to ="i.86", your module would not be built for ia32e, x86_64, amd64, s390, etc. .TP .B BUILD_EXCLUSIVE_CONFIG= This optional directive allows you to specify a space separated list of kernel configuration options ("CONFIG_FOO") that must be enabled in the targeted kernels ".config" file (either to be compiled in or to be built as a module) or absent (if prefixed with an exclamation mark, e.g. "!CONFIG_BAR") in order to build the module. For example, if you set it as ="CONFIG_PCI !CONFIG_PREEMPT_RT", your module would only be built for kernels that have PCI enabled, but the RT patchset disabled. .TP .B POST_ADD= The name of the script to be run after an .B add is performed. The path should be given relative to the root directory of your source. .TP .B POST_BUILD= The name of the script to be run after a .B build is performed. The path should be given relative to the root directory of your source. .TP .B POST_INSTALL= The name of the script to be run after an .B install is performed. The path should be given relative to the root directory of your source. .TP .B POST_REMOVE= The name of the script to be run after a .B remove is performed. The path should be given relative to the root directory of your source. .TP .B PRE_BUILD= The name of the script to be run before a .B build is performed. The path should be given relative to the root directory of your source. .TP .B PRE_INSTALL= The name of the script to be run before an .B install is performed. The path should be given relative to the root directory of your source. If the script exits with a non\-zero value, the install will be aborted. This is typically used to perform a custom version comparison. .PP .SH DKMS.CONF VARIABLES Within your DKMS configuration file, you can use certain variables which will be replaced at run\-time with their values. .TP .B $kernelver This variable can be used within a directive definition and during use, the actual kernel version in question will be substituted in its place. This is especially useful in .B MAKE commands when specifying which INCLUDE statements should be used when compiling your module (eg. MAKE="make all INCLUDEDIR=@MODDIR@/${kernelver}/build/include"). .TP .B $kernel_source_dir This variable holds the value of the location of your kernel source directory. Usually, this will be .IR @MODDIR@/$kernelver/build , unless otherwise specified with the .B \-\-kernelsourcedir option. .SH DKMS.CONF OVERRIDES You can override directives provided in the module-provided .I dkms.conf files. Every time after a .I dkms.conf file is read, dkms will look for and read the following files in order: .PP .I /etc/dkms/.conf .br .I /etc/dkms/\-.conf .br .I /etc/dkms/\-\-.conf .br .I /etc/dkms/\-\-\-.conf .PP You can use these files to override settings in the module-provided .I dkms.conf file. .SH FRAMEWORK.CONF MAIN CONFIGURATION The .B /etc/dkms/framework.conf configuration file controls how the overall DKMS framework handles. It is sourced in every time the .B dkms command is run. Mainly it can currently be used to set different default values for the variables. The file contains descriptions for each directive it supports. Additionally to .B /etc/dkms/framework.conf , any file matching the glob .B /etc/dkms/framework.conf.d/*.conf will be loaded as well. .TP .B dkms_tree, source_tree, install_tree, tmp_location Control which folders DKMS uses for components and artifacts. .TP .B verbose Can be set to anything but a null value to enable verbose output of external commands executed in DKMS. .TP .B symlink_modules Controls whether binary modules are copied to @MODDIR@ or if only symlinks are created there. Note that these variables can also be manipulated on the command line with .B \-\-dkmstree , .B \-\-sourcetree , .B \-\-installtree and .B \-\-symlink-modules options. .TP .B autoinstall_all_kernels Used by the common postinst for DKMS modules. It controls if the build should be done for all installed kernels or only for the current and latest installed kernel. It has no command line equivalent. .TP .B sign_file This is the path of the .B sign-file kernel binary that is used to sign the kernel modules. The variable .B $kernelver can be used in path to represent the target kernel version. The path for the binary depends on the distribution. .TP .B mok_signing_key, mok_certificate Location of the key and certificate files used for Secure boot. The variable .B $kernelver can be used in path to represent the target kernel version. NOTE: If any of the files specified by .B mok_signing_key and .B mok_certificate are non-existant, dkms will re-create both files. .B mok_signing_key can also be a "pkcs11:..." string for PKCS#11 engine, as long as the .B sign-file program supports it. .TP .B modprobe_on_install Automatically load the built modules upon successful installation. .TP .B parallel_jobs Run no more than this number of jobs in parallel. .TP .B compress_gzip_opts, compress_xz_opts, compress_zstd_opts Control how modules are compressed. By default, the highest available level of compression is used. .TP .B post_transaction If the directive is set to any non null-value, the content of the directive will be executed with any command that change the content of the kernel modules folder, that is .B dkms autoinstall, dkms install and .B dkms remove/unbuild/uninstall. Can be used to trigger a global .B initrd rebuild or to call a script that performs some other tasks (calling .B kexec, triggering the restart of services not contained in a DKMS package, etc.). The command is constructed with the shell built-in .B eval and the variable .B $kernelver can be used to represent the target kernel version. Some examples: Regenerate the ram disk for the target kernel: .B post_transaction="dracut --force --kver $kernelver" (Red Hat style) or .B post_transaction="update-initramfs -k $kernelver" (Debian style). Launch an arbitrary script: .B post_transaction="/path/to/script.sh" Restart a service: .B post_transaction="systemctl restart something.service" Regenerate the ram disk for all installed kernels, ignoring the kernel version passed as the parameter: .B post_transaction="dracut --force --regenerate-all" (Red Hat style) or .B post_transaction="update-initramfs -k all" (Debian style). .SH DKMS AUTOINSTALLER The DKMS autoinstaller service (which can be .B dkms_autoinstaller or .B dkms.service depending on your distribution) is a boot\-time service automatically installs any module which has .B AUTOINSTALL="yes" set in its .I dkms.conf file. The service works quite simply and if multiple versions of a module are in your system's DKMS tree, it will not do anything and instead explain that manual intervention is required. .SH AUTHOR Gary Lerhaupt, Emil Velikov, Simone Caronni, Xu Zhen .SH WEBPAGE .I https://github.com/dell/dkms dkms-3.2.0/dkms.bash-completion.in000066400000000000000000000051551500670340200170260ustar00rootroot00000000000000# shellcheck shell=bash # shellcheck disable=SC2207 # Based on the completion from the Mandriva dkms package. # This function completes available kernels _kernels() { COMPREPLY=( $( cd @MODDIR@ && compgen -d -- "$cur" ) ) } # complete on full directory names under $1 _subdirectories() { COMPREPLY=( $( cd "$1" && compgen -d -- "$cur" ) ) } # complete on $2 part of filenames matching pattern $1 under /usr/src _filename_parts() { # shellcheck disable=SC1003 # TODO: figure out what is going on here COMPREPLY=( $( command ls -F /usr/src/ 2>/dev/null | grep -E '^'"$1"'/$' \ | sed -r -e 's/^([^-]+)-(.+)\/$/\'"$2"'/' | grep "^$cur" ) ) } _dkms() { local cur prev command module i COMPREPLY=() cur=${COMP_WORDS[COMP_CWORD]} if [[ $COMP_CWORD -eq 1 ]] ; then COMPREPLY=( $( compgen -W "add remove build unbuild install uninstall autoinstall \ match mktarball ldtarball generate_mok \ status" -- "$cur" ) ) else prev=${COMP_WORDS[COMP_CWORD-1]} command=${COMP_WORDS[1]} case $prev in -a) COMPREPLY=( $( compgen -W "$(uname -m)" -- "$cur" ) ) return 0 ;; -m) if [ "$command" = 'add' ]; then _filename_parts '.*-.*' 1 else _subdirectories /var/lib/dkms fi return 0 ;; -v) for (( i=1; i < COMP_CWORD; i++ )); do if [[ "${COMP_WORDS[i]}" == -m ]]; then module=${COMP_WORDS[i+1]} break fi done if [ -n "$module" ]; then if [ "$command" = 'add' ]; then _filename_parts "$module-.*" 2 else _subdirectories "/var/lib/dkms/$module" fi return 0 fi ;; -k|--templatekernel) _kernels return 0 ;; -c|--spec|--archive|--config) _filedir return 0 ;; --kernelsourcedir|--dkmstree|--sourcetree|--installtree) _filedir -d return 0 ;; esac if [[ "$cur" == -* ]]; then case $command in add) options='-c --rpm_safe_upgrade' ;; remove) options='--rpm_safe_upgrade' ;; build) options='--config --force' ;; unbuild) options='' ;; install) options='--force' ;; uninstall) options='' ;; autoinstall) options='' ;; match) options='--templatekernel' ;; mktarball) options='--source-only --binaries-only' ;; ldtarball) options='--archive --force' ;; status) options='' ;; generate_mok) options='' ;; esac options="$options -m -v -k -a --arch -q --quiet -V \ --version --all --kernelsourcedir \ --directive" COMPREPLY=( $( compgen -W "$options" -- "$cur" ) ) fi fi } complete -F _dkms dkms dkms-3.2.0/dkms.in000066400000000000000000003631741500670340200137530ustar00rootroot00000000000000#!/bin/bash # # Dynamic Kernel Module Support (DKMS) # Copyright (C) 2003-2008 Dell, Inc. # by Gary Lerhaupt, Matt Domsch, & Mario Limonciello # Copyright (C) 2012 by Darik Horn # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Exit status values and error messages used by dkms: # (as parameters to die, diewarn, report_build_problem, exit) # # 0: global: SUCCESS # 0: remove_module(): Remove cancelled because --rpm_safe_upgrade scenario detected. # 1: ldtarball: You must be root to use this command with the --force option. # 1: check_root(): You must be root to use this command. # 1: check_rw_dkms_tree(): No write access to DKMS tree at ... # 1: mktemp_or_die(): Unable to make temporary file/directory. # 1: check_module_args(): Arguments and are not specified. # 1: run_match(): Invalid number of parameters passed. # 1: global: If more than one arch is specified on the command line, then there "must be an equal number of kernel versions also specified (1:1 relationship). # 2: global: Unknown option: ... # 2: global: You cannot specify a kernel version and also specify --all on the command line. # 2: run_match(): The templatekernel and the specified kernel version are the same. # 2: add_module(): Could not find module source directory. # 2: load_tarball(): ... does not exist. # 3: global: You cannot specify an arch and also specify --all on the command line. # 3: load_tarball(): Tarball does not appear to be a correctly formed DKMS archive. No dkms.conf found within it. # 3: run_match(): The module: $module is not located in the DKMS tree. # 3: add_module(): You cannot add the same module/version combo more than once. # 3: prepare_build(): This module/version has already been built on: ... # 3: module_is_added_or_die(): The module/version combo: ... is not located in the DKMS tree. # 4: global: Cannot specify more than one action. # 4: distro_version(): System is missing os-release file. # 4: read_conf(): Could not locate dkms.conf file. # 4: have_one_kernel(): The action ... does not support multiple kernel version parameters on the command line. # 4: module_is_broken_and_die(): ... is broken! # 5: check_all_is_banned(): The action ... does not support the --all parameter. # 5: prepare_build(): Patch ... as specified in dkms.conf contains '..' path component. # 5: prepare_build(): Patch ... as specified in dkms.conf cannot be found in ... # 5: install: This module/version combo is already installed for kernel ... # 6: prepare_build(): Application of patch ... failed. # 6: install: You cannot install a module onto a non-existant kernel. # 6: install: Installation aborted. # 6: install: Install Failed (depmod problems). Module rolled back to built state. # 6: make_tarball(): Modules must already be in the built state before using mktarball. # 6: make_tarball(): Failed to make tarball. # 7: load_tarball(): No valid dkms.conf in dkms_source_tree or dkms_binaries_only. # 7: actual_build(): Build of ... failed for: ... # 8: load_tarball(): ... is already added! # 8: global: You have specified both --binaries-only and --source-only. # 8: read_conf_or_die(): Bad conf file. # 8: prepare_build(): The directory $source_dir does not appear to have module source located within it. # 9: add_source_tree(): ... must contain a dkms.conf file! # 9: make_tarball(): Missing write permissions for ... # 9: load_tarball(): Unable to install ... using rpm. # 10: add_source_tree(): Malformed dkms.conf file. Cannot load source tree. # 10: build: Bad return status for module build on kernel: ... # 11: autoinstall: One or more modules failed to install during autoinstall. # 12: setup_kernels_arches(): Could not determine architecture. # 13: build: Aborting build of module ... for kernel ... due to missing BUILD_DEPENDS: ... # 14: kernel_preinst/prerm: dkms kernel_preinst/prerm for kernel ... failed for module(s) ... # 15: gloabl: a call to cd failed # 16: setup_kernels_arches()/do_build()/do_install(): empty $kernelver or $arch # 21: prepare_kernel(): Your kernel headers for kernel ... cannot be found ... # 77: skipped due to BUILD_EXCLUSIVE # 101: install: pre_install failed, aborting install. shopt -s extglob # All of the variables we will accept from dkms.conf. # Does not include directives # The last group of variables has been deprecated readonly dkms_conf_variables="PACKAGE_NAME PACKAGE_VERSION POST_ADD POST_BUILD POST_INSTALL POST_REMOVE PRE_BUILD PRE_INSTALL BUILD_DEPENDS BUILD_EXCLUSIVE_ARCH BUILD_EXCLUSIVE_CONFIG BUILD_EXCLUSIVE_KERNEL BUILD_EXCLUSIVE_KERNEL_MIN BUILD_EXCLUSIVE_KERNEL_MAX build_exclude OBSOLETE_BY MAKE MAKE_MATCH PATCH PATCH_MATCH patch_array BUILT_MODULE_NAME built_module_name BUILT_MODULE_LOCATION built_module_location DEST_MODULE_NAME dest_module_name DEST_MODULE_LOCATION dest_module_location STRIP strip AUTOINSTALL NO_WEAK_MODULES BUILD_DEPENDS_REBUILD CLEAN REMAKE_INITRD MODULES_CONF MODULES_CONF_OBSOLETES MODULES_CONF_ALIAS_TYPE MODULES_CONF_OBSOLETE_ONLY" show_deprecation_warnings=0 # All of the variables not related to signing we will accept from framework.conf. readonly dkms_framework_nonsigning_variables="source_tree dkms_tree install_tree tmp_location verbose symlink_modules autoinstall_all_kernels modprobe_on_install parallel_jobs compress_gzip_opts compress_xz_opts compress_zstd_opts post_transaction" # All of the signing related variables we will accept from framework.conf. readonly dkms_framework_signing_variables="sign_file mok_signing_key mok_certificate" # The post transaction command we will accept from framework.conf readonly dkms_framework_post_transaction="post_transaction" # Some important regular expressions. Requires bash 3 or above. # Any poor souls still running bash 2 or older really need an upgrade. readonly mv_re='^([^/]*)/(.*)$' # Areas that will vary between Linux and other OS's _get_kernel_dir() { if [[ ! $ksourcedir_fromcli ]]; then KVER=$1 DIR="$install_tree/$KVER/build" echo "$DIR" else echo "$kernel_source_dir" fi } _check_kernel_dir() { DIR=$(_get_kernel_dir "$1") [[ -e "$DIR/include" ]] return $? } on_exit() { local exitcode_on_exit=$? # must be one line or $? captures rc from `local` local j j="$(jobs -p)" [[ $j ]] && kill "$j" 2>/dev/null [[ $make_tarball_rm_temp_dir_name ]] && eval "$make_tarball_rm_temp_dir_name" [[ $load_tarball_rm_temp_dir_name ]] && eval "$load_tarball_rm_temp_dir_name" exit $exitcode_on_exit } unset make_tarball_rm_temp_dir_name load_tarball_rm_temp_dir_name trap on_exit EXIT # Run a command that we may or may not want to be detailed about. invoke_command() { # $1 = command to be executed using eval. # $2 = Description of command to run # $3 = Redirect command output (including stderr) to this file # $4 = background, if you want print . each 3 seconds while command runs local cmd local cmd_description local cmd_output_file local cmd_mode local exitval local progresspid cmd="$1" cmd_description="$2" cmd_output_file="$3" cmd_mode="$4" exitval=0 [[ $verbose ]] && echo -e "$cmd" || echo -en "$cmd_description..." if [[ $cmd_mode == background && ! $verbose && $package_name != dkms*_test ]]; then while true ; do sleep 3 echo -n "." done & progresspid=$! fi if [[ $cmd_output_file ]]; then local t_start local t_end # shellcheck disable=SC2129 echo "" >> "$cmd_output_file" echo -e "$cmd_description" >> "$cmd_output_file" echo -e "# command: $cmd" >> "$cmd_output_file" t_start=$SECONDS ( eval "$cmd" ) >> "$cmd_output_file" 2>&1 exitval=$? t_end=$SECONDS # shellcheck disable=SC2129 echo -e "\n# exit code: $exitval" >> "$cmd_output_file" echo "# elapsed time: $(date -u -d "0 $t_end sec - $t_start sec" +%T)" >> "$cmd_output_file" echo "----------------------------------------------------------------" >> "$cmd_output_file" elif [[ ! $cmd_output_file && $cmd_mode = background && ! $verbose ]]; then ( eval "$cmd" ) >/dev/null 2>&1 exitval=$? else ( eval "$cmd" ) exitval=$? fi if [[ $progresspid ]]; then kill -9 "$progresspid" >/dev/null 2>&1 wait "$progresspid" 2>/dev/null fi if (( exitval > 0 )); then echo -en "(bad exit status: $exitval)" # Print the failing command without the clunky redirection [[ ! $verbose ]] && echo -e "\nFailed command:\n$1" else echo " done." fi return "$exitval" } error() ( exec >&2 echo "" echo -n "Error! " for s in "$@"; do echo "$s"; done ) warn() ( exec >&2 echo -n "Warning: " for s in "$@"; do echo "$s"; done ) deprecated() ( exec >&2 echo -n "Deprecated feature: " for s in "$@"; do echo "$s"; done ) # Print an error message and die with the passed error code. die() { # $1 = error code to return with # rest = strings to print before we exit. ret=$1 shift error "$@" [[ $die_is_fatal = yes ]] && exit "$ret" || return "$ret" } # Print a warning message and die with the passed error code. diewarn() { # $1 = error code to return with # rest = strings to print before we exit. ret=$1 shift warn "$@" [[ $die_is_fatal = yes ]] && exit "$ret" || return "$ret" } mktemp_or_die() { local t t=$(mktemp "$@") && echo "$t" && return [[ $* = *-d* ]] && die 1 "Unable to make temporary directory." die 1 "Unable to make temporary file." } show_usage() { echo "Usage: $0 [action] [options]" echo " [action] = { add | remove | build | unbuild | install | uninstall | match |" echo " autoinstall | mktarball | ldtarball | status | generate_mok |" echo " kernel_preinst | kernel_postinst | kernel_prerm }" echo " [options] = [-m module] [-v module-version] [-k kernel-version] [-a arch]" echo " [-c dkms.conf-location] [-q] [--force] [--force-version-override] [--all]" echo " [--templatekernel=kernel] [--directive='cli-directive=cli-value']" echo " [--config=kernel-include/config/auto.conf-location] [--archive=tarball-location]" echo " [--kernelsourcedir=source-location] [--rpm_safe_upgrade]" echo " [--dkmstree path] [--sourcetree path] [--installtree path]" echo " [--binaries-only] [--source-only] [--verbose]" echo " [--no-depmod] [--modprobe-on-install] [-j number] [--version] [--help]" } VER() { # $1 = kernel version string # Pad all numbers in $1 so that they have at least three digits, e.g., # 2.6.9-1cvs200409091247 => 002.006.009-001cvs200409091247 # The result should compare correctly as a string. echo "$1" | sed -e 's:\([^0-9]\)\([0-9]\):\1 \2:g' \ -e 's:\([0-9]\)\([^0-9]\):\1 \2:g' \ -e 's:\(.*\): \1 :' \ -e 's: \([0-9]\) : 00\1 :g' \ -e 's: \([0-9][0-9]\) : 0\1 :g' \ -e 's: ::g' } # Find out how many CPUs there are so that we may pass an appropriate -j # option to make. Ignore hyperthreading for now. get_num_cpus() { # use nproc(1) from coreutils 8.1-1+ if available, otherwise single job if [[ -x /usr/bin/nproc ]]; then nproc else echo "1" fi } # Finds a .ko or .ko.xz based on a directory and module name # must call set_module_suffix first compressed_or_uncompressed() { # module dir = $1 # module = $2 local test1 local test2 test1="$1/$2$module_uncompressed_suffix" test2="$1/$2$module_uncompressed_suffix$module_compressed_suffix" if [[ -e "$test1" ]]; then echo "$test1" elif [[ -e "$test2" ]]; then echo "$test2" fi } # Finds .ko or .ko.xz based on a tree and module name # must call set_module_suffix first find_module() { # tree = $1 # module = $2 find "$1" -name "$2$module_uncompressed_suffix" -type f -o -name "$2$module_suffix" -type f return $? } # Figure out the correct module suffix for the kernel we are currently dealing # with, which may or may not be the currently installed kernel. Do not use modules.dep # as it might not be available (in Red Hat removal is triggered with kernel-core but modules.dep # is contained in kernel-modules-core). set_module_suffix() { # $1 = the kernel to base the module_suffix on kernel_test="${1:-$(uname -r)}" module_uncompressed_suffix=".ko" find "$install_tree/$kernel_test/" -name "*.ko.gz" 2>/dev/null | grep -q . && module_compressed_suffix=".gz" find "$install_tree/$kernel_test/" -name "*.ko.xz" 2>/dev/null | grep -q . && module_compressed_suffix=".xz" find "$install_tree/$kernel_test/" -name "*.ko.zst" 2>/dev/null | grep -q . && module_compressed_suffix=".zst" module_suffix="$module_uncompressed_suffix$module_compressed_suffix" } set_kernel_source_dir_and_kconfig() { if [[ ! $ksourcedir_fromcli ]]; then # $1 = the kernel to base the directory on kernel_source_dir="$(_get_kernel_dir "$1")" fi if [[ ! $kconfig_fromcli ]]; then if [[ -e "${kernel_source_dir}/include/config/auto.conf" ]]; then kernel_config="${kernel_source_dir}/include/config/auto.conf" else kernel_config="${kernel_source_dir}/.config" fi fi } check_all_is_banned() { if [[ $all ]]; then die 5 "The action $1 does not support the --all parameter." fi } # A little test function for DKMS commands that only work on one kernel. have_one_kernel() { check_all_is_banned "$1" if (( ${#kernelver[@]} != 1 )); then [[ $1 =~ kernel_(preinst|postinst|prerm) ]] && die 4 "The action $1 requires exactly one kernel version parameter on the command line." die 4 "The action $1 does not support multiple kernel version parameters on the command line." fi } # Set up the kernelver and arch arrays. You must have a 1:1 correspondence -- # if there is an entry in kernelver[$i], there must also be an entry in arch[$i] # Note the special casing for the status action -- the status functions just # report on what we already have, and will break with the preprocessing that # this function provides. setup_kernels_arches() { # If all is set, use dkms status to fill the arrays if [[ $all && $1 != status ]]; then local i i=0 while read -r line; do [[ $line ]] || continue line=${line#*/}; line=${line#*/}; # (I would leave out the delimiters in the status output # in the first place.) kernelver[i]=${line%/*} arch[i]=${line#*/} i=$((i + 1)) done <<< "$(module_status_built "$module" "$module_version" | sort -V)" fi # Set default kernel version and arch, if none set (but only --all isn't set) if [[ $1 != status ]]; then if [[ ${#kernelver[@]} -eq 0 && ! $all ]]; then kernelver[0]=$(uname -r) fi if [[ ${#arch[@]} -eq 0 ]]; then case "$running_distribution" in debian* | ubuntu* | arch* | gentoo*) arch[0]=$(uname -m) ;; *) kernelver_rpm=$(rpm -qf "$install_tree/${kernelver[0]}" 2>/dev/null | \ grep -v "not owned by any package" | grep kernel | head -n 1) if ! arch[0]=$(rpm -q --queryformat "%{ARCH}" "$kernelver_rpm" 2>/dev/null); then arch[0]=$(uname -m) # shellcheck disable=SC2010 # TODO: replace ls | grep if [[ ${arch[0]} = x86_64 ]] && [[ -r /proc/cpuinfo ]] && grep -q Intel /proc/cpuinfo && ls "$install_tree/${kernelver[0]}/build/configs" 2>/dev/null | grep -q "ia32e"; then arch[0]="ia32e" fi fi ;; esac fi if [[ ${#arch[@]} -eq 0 ]]; then die 12 "Could not determine architecture." fi fi # If only one arch is specified, make it so for all the kernels if ((${#arch[@]} == 1 && ${#kernelver[@]} > 1)); then while ((${#arch[@]} < ${#kernelver[@]})); do arch[${#arch[@]}]=${arch[0]} done fi if [[ $1 != status ]]; then local i for ((i=0; i < ${#kernelver[@]}; i++)); do [[ ${kernelver[i]} ]] || die 16 "Empty kernelver[$i]" done for ((i=0; i < ${#arch[@]}; i++)); do [[ ${arch[i]} ]] || die 16 "Empty arch[$i]" done fi } do_depmod() { if [[ $no_depmod ]]; then return fi # $1 = kernel version if [[ ${current_os} != Linux ]] ; then return fi if [[ ! -f $install_tree/$1/modules.dep ]]; then # if the corresponding linux image $1 is not installed # do not create modules.dep echo "Skipping depmod because '$install_tree/$1/modules.dep' is missing." return fi if [[ -f /boot/System.map-$1 ]]; then depmod -a "$1" -F "/boot/System.map-$1" else depmod -a "$1" fi if [[ -f $install_tree/$1/modules.dep && ! -s $install_tree/$1/modules.dep ]]; then # if modules.dep is empty, we just removed the last kernel module from # no longer installed kernel $1, so do not leave stale depmod files around rm -fv "${install_tree:?}/$1/"modules.{alias,dep,devname,softdep,symbols,weakdep,*.bin} rmdir --ignore-fail-on-non-empty "${install_tree:?}/$1" [[ -d $install_tree/$1 ]] || echo "removed directory $install_tree/$1" fi } # Grab distro information from os-release. distro_version() { for f in /etc/os-release /usr/lib/os-release; do if [[ -e $f ]]; then ( # shellcheck disable=SC1090 . "$f" if [[ "$ID" = "ubuntu" ]]; then # ID_LIKE=debian in ubuntu echo "$ID" elif [[ ${#ID_LIKE[@]} != 0 ]]; then echo "${ID_LIKE[0]}" else echo "$ID" fi ) return fi done die 4 "System is missing os-release file." } override_dest_module_location() { local orig_location orig_location="$1" [[ ${addon_modules_dir} ]] && echo "/${addon_modules_dir}" && return case "$running_distribution" in fedora* | rhel* | ovm*) echo "/extra" && return ;; sles* | suse* | opensuse*) echo "/updates" && return ;; debian* | ubuntu*) echo "/updates/dkms" && return ;; arch*) echo "/updates/dkms" && return ;; *) ;; esac echo "$orig_location" } # Source a file safely. # We want to ensure that the .conf file we source does not stomp all over # parts of the environment we don't want them to. This makes it so that # it is harder to accidentally corrupt our environment. conf files can # still deliberately trash the environment by abusing dkms_directive env # variables or by crafting special values that will make eval do evil things. safe_source() { # $1 = file to source # $@ = environment variables to echo out local to_source_file to_source_file="$1"; shift # shellcheck disable=SC2206 # we intentionally split the string into a multi-element array declare -a -r export_envs=( $@ ) # shellcheck disable=SC2034 # false positive local -r CR=$(echo -e '\r') local tmpfile tmpfile=$(mktemp_or_die) ( exec >"$tmpfile" # shellcheck disable=SC1090 . "$to_source_file" >/dev/null # This is really ugly, but a neat hack # Remember, in bash 2.0 and greater all variables are really arrays. for _export_env in "${export_envs[@]}"; do # shellcheck disable=SC1083,SC2294 for _i in $(eval echo \${!"${_export_env}"[@]}); do eval echo '$_export_env[$_i]=\"${'"${_export_env}"'[$_i]%$CR}\"' done done # handle DKMS_DIRECTIVE stuff specially. for directive in $(set | grep ^DKMS_DIRECTIVE | cut -d = -f 2-3); do directive_name=${directive%%=*} directive_value=${directive#*=} echo "$directive_name=\"$directive_value\"" done ) # shellcheck disable=SC1090 . "$tmpfile" rm "${tmpfile:?}" (( show_deprecation_warnings )) || return if (( ${#CLEAN[@]} )); then case "$CLEAN" in true|/bin/true|/usr/bin/true) ;; *) deprecated "CLEAN ($to_source_file)" ;; esac fi (( ${#REMAKE_INITRD[@]} )) && deprecated "REMAKE_INITRD ($to_source_file)" (( ${#MODULES_CONF[@]} )) && deprecated "MODULES_CONF ($to_source_file)" (( ${#MODULES_CONF_OBSOLETES[@]} )) && deprecated "MODULES_CONF_OBSOLETES ($to_source_file)" (( ${#MODULES_CONF_ALIAS_TYPE[@]} )) && deprecated "MODULES_CONF_ALIAS_TYPE ($to_source_file)" (( ${#MODULES_CONF_OBSOLETE_ONLY[@]} )) && deprecated "MODULES_CONF_OBSOLETE_ONLY ($to_source_file)" } # Source a dkms.conf file and perform appropriate postprocessing on it. # Do our best to not repeatedly source the same .conf file -- this can happen # when chaining module installation functions or autoinstalling. read_conf() { # $1 kernel version (required) # $2 arch (required) # $3 dkms.conf location (optional) local return_value local read_conf_file return_value=0 read_conf_file="$dkms_tree/$module/$module_version/source/dkms.conf" # Set variables supported in dkms.conf files (eg. $kernelver) local kernelver local arch kernelver="$1" arch="$2" set_kernel_source_dir_and_kconfig "$1" # Find which conf file to check [[ $conf ]] && read_conf_file="$conf" [[ $3 ]] && read_conf_file="$3" [[ -r $read_conf_file ]] || die 4 "Could not locate dkms.conf file." \ "File: $read_conf_file does not exist." [[ $last_mvka = $module/$module_version/$1/$2 && \ $last_mvka_conf = $(readlink -f "$read_conf_file") ]] && return # Clear variables and arrays for var in $dkms_conf_variables; do unset "$var" done # Source in the dkms.conf. # Allow for user-specified overrides in order of specificity. local _conf_file for _conf_file in \ "$read_conf_file" \ "/etc/dkms/$module.conf" \ "/etc/dkms/$module-$module_version.conf" \ "/etc/dkms/$module-$module_version-$1.conf" \ "/etc/dkms/$module-$module_version-$1-$2.conf" \ "/etc/dkms/$module--$1.conf" \ "/etc/dkms/$module--$1-$2.conf" \ ; do [[ -e $_conf_file ]] && safe_source "$_conf_file" "$dkms_conf_variables" done # Source in the directive_array for directive in "${directive_array[@]}"; do directive_name=${directive%%=*} directive_value=${directive#*=} export "$directive_name"="$directive_value" echo "DIRECTIVE: $directive_name=\"$directive_value\"" done # Set variables package_name="$PACKAGE_NAME" package_version="$PACKAGE_VERSION" # shellcheck disable=SC2153 post_add="$POST_ADD" # shellcheck disable=SC2153 post_build="$POST_BUILD" # shellcheck disable=SC2153 post_install="$POST_INSTALL" # shellcheck disable=SC2153 post_remove="$POST_REMOVE" # shellcheck disable=SC2153 pre_build="$PRE_BUILD" # shellcheck disable=SC2153 pre_install="$PRE_INSTALL" # shellcheck disable=SC2153 obsolete_by="$OBSOLETE_BY" # Fail if no PACKAGE_NAME if [[ ! $package_name ]]; then echo "dkms.conf: Error! No 'PACKAGE_NAME' directive specified.">&2 return_value=1 fi # Fail if no PACKAGE_VERSION if [[ ! $package_version ]]; then echo "dkms.conf: Error! No 'PACKAGE_VERSION' directive specified.">&2 return_value=1 fi # Determine number of modules local s num_modules=0 # shellcheck disable=SC2153 for s in ${#BUILT_MODULE_NAME[@]} \ ${#BUILT_MODULE_LOCATION[@]} \ ${#DEST_MODULE_NAME[@]} \ ${#DEST_MODULE_LOCATION[@]}; do ((s > num_modules)) && num_modules=$s done # Set module naming/location arrays local index for ((index=0; index < num_modules; index++)); do # Set values built_module_name[index]=${BUILT_MODULE_NAME[index]} built_module_location[index]=${BUILT_MODULE_LOCATION[index]} dest_module_name[index]=${DEST_MODULE_NAME[index]} dest_module_location[index]=${DEST_MODULE_LOCATION[index]} # shellcheck disable=SC2153 case ${STRIP[index]} in [nN]*) strip[index]="no" ;; [yY]*) strip[index]="yes" ;; '') strip[index]=${strip[0]:-yes} ;; esac # If unset, set by defaults [[ ! ${built_module_name[$index]} ]] && \ ((num_modules == 1)) && \ built_module_name[index]=$PACKAGE_NAME [[ ! ${dest_module_name[$index]} ]] && \ dest_module_name[index]=${built_module_name[index]} [[ ${built_module_location[$index]} && \ ${built_module_location[$index]:(-1)} != / ]] && \ built_module_location[index]="${built_module_location[index]}/" # FAIL if no built_module_name if [[ ! ${built_module_name[$index]} ]]; then echo "dkms.conf: Error! No 'BUILT_MODULE_NAME' directive specified for record #$index." >&2 return_value=1 fi # FAIL if built_module_name ends in .o or .ko case ${built_module_name[$index]} in *.o|*.ko) echo "dkms.conf: Error! 'BUILT_MODULE_NAME' directive ends in '.o' or '.ko' in record #$index." >&2 return_value=1 ;; esac # FAIL if dest_module_name ends in .o or .ko case ${dest_module_name[$index]} in *.o|*.ko) echo "dkms.conf: Error! 'DEST_MODULE_NAME' directive ends in '.o' or '.ko' in record #$index." >&2 return_value=1 ;; esac # Override location for specific distributions dest_module_location[index]="$(override_dest_module_location "${dest_module_location[index]}")" # Fail if no DEST_MODULE_LOCATION if [[ ! ${DEST_MODULE_LOCATION[$index]} ]]; then echo "dkms.conf: Error! No 'DEST_MODULE_LOCATION' directive specified for record #$index.">&2 return_value=1 fi # Fail if bad DEST_MODULE_LOCATION case ${DEST_MODULE_LOCATION[$index]} in /kernel*) ;; /updates*) ;; /extra*) ;; *) echo "dkms.conf: Error! Directive 'DEST_MODULE_LOCATION' does not begin with">&2 echo "'/kernel', '/updates', or '/extra' in record #$index.">&2 return_value=1 ;; esac done # Array length sanity check for s in ${#built_module_name[@]} \ ${#built_module_location[@]} \ ${#dest_module_name[@]} \ ${#dest_module_location[@]}; do if ((s != num_modules)); then echo "dkms.conf: Error! Module name/location array length mismatch.">&2 return_value=1 fi done # Get the correct make command [[ ${MAKE_MATCH[0]} ]] || make_command="${MAKE[0]}" for ((index=0; index < ${#MAKE[@]}; index++)); do [[ ${MAKE[$index]} && ${MAKE_MATCH[$index]} && \ $1 =~ ${MAKE_MATCH[$index]} ]] && \ make_command="${MAKE[$index]}" done # Use the generic make command if not specified [[ ! $make_command ]] && make_command="make -C $kernel_source_dir M=$dkms_tree/$module/$module_version/build" # Check if clang was used to compile or lld was used to link the kernel. if [[ -e $kernel_source_dir/vmlinux ]]; then if readelf -p .comment "$kernel_source_dir/vmlinux" 2>&1 | grep -q clang; then make_command="${make_command} LLVM=1" fi elif [[ -e "${kernel_config}" ]]; then if grep -q CONFIG_CC_IS_CLANG=y "${kernel_config}"; then make_command="${make_command} LLVM=1" fi fi # Set patch_array (including kernel specific patches) local count count=0 for ((index=0; index < ${#PATCH[@]}; index++)); do if [[ ${PATCH[$index]} && (! ${PATCH_MATCH[$index]} || $1 =~ ${PATCH_MATCH[$index]}) ]]; then patch_array[count]="${PATCH[index]}" count=$((count+1)) fi done # Set build_exclude [[ $obsolete_by && ! $BUILD_EXCLUSIVE_KERNEL_MAX ]] && BUILD_EXCLUSIVE_KERNEL_MAX=$obsolete_by [[ $BUILD_EXCLUSIVE_KERNEL && ! $1 =~ $BUILD_EXCLUSIVE_KERNEL ]] && build_exclude="yes" [[ $BUILD_EXCLUSIVE_KERNEL_MIN && "$(VER "$1")" < "$(VER "$BUILD_EXCLUSIVE_KERNEL_MIN")" ]] && build_exclude="yes" [[ $BUILD_EXCLUSIVE_KERNEL_MAX && "$(VER "$1")" > "$(VER "$BUILD_EXCLUSIVE_KERNEL_MAX")" ]] && build_exclude="yes" [[ $BUILD_EXCLUSIVE_ARCH && ! $2 =~ $BUILD_EXCLUSIVE_ARCH ]] && build_exclude="yes" if [[ $BUILD_EXCLUSIVE_CONFIG && -e "${kernel_config}" ]]; then local kconf for kconf in $BUILD_EXCLUSIVE_CONFIG ; do case "$kconf" in !*) grep -q "^${kconf#!}=[ym]" "${kernel_config}" && build_exclude="yes" ;; *) grep -q "^${kconf}=[ym]" "${kernel_config}" || build_exclude="yes" ;; esac done fi # Helper function to check yes/no values check_yes_no_value() { local var_name="$1" local var_value="$2" case "$var_value" in "") ;; [Yy][Ee][Ss]) ;; [Nn][Oo]) eval "$var_name=''" ;; *) echo "dkms.conf: Error! Unsupported $var_name value '$var_value'" >&2 return_value=1 ;; esac } # Check for allowed values in boolean variables check_yes_no_value "AUTOINSTALL" "$AUTOINSTALL" check_yes_no_value "BUILD_DEPENDS_REBUILD" "$BUILD_DEPENDS_REBUILD" check_yes_no_value "NO_WEAK_MODULES" "$NO_WEAK_MODULES" ((return_value == 0)) && last_mvka="$module/$module_version/$1/$2" && last_mvka_conf="$(readlink -f "$read_conf_file")" return $return_value } # read_conf() with additional dkms.conf checks that should prevent # add/build/install but not uninstall/unbuild/remove of bad modules. read_conf_strict() { show_deprecation_warnings=1 read_conf "$@" || return $? show_deprecation_warnings=0 local index local names local return_value return_value=0 # Warn if no modules are specified if ((num_modules == 0)); then echo "dkms.conf: Warning! Zero modules specified." >&2 fi # FAIL on duplicate modules in BUILT_MODULE_NAME[] names= for ((index=0; index < num_modules; index++)); do local m m="${built_module_location[index]}${built_module_name[index]}" case " $names " in *" $m "*) echo "dkms.conf: Error! Duplicate module '$m' in 'BUILT_MODULE_NAME[$index]'." >&2 return_value=1 ;; esac names="$names $m" done # FAIL on duplicate modules in DEST_MODULE_NAME[] names= for ((index=0; index < num_modules; index++)); do local m m=${dest_module_name[index]} case " $names " in *" $m "*) echo "dkms.conf: Error! Duplicate module '$m' in 'DEST_MODULE_NAME[$index]'." >&2 return_value=1 ;; esac names="$names $m" done return $return_value } # Source specified variables from dkms framework configuration files. read_framework_conf() { for i in /etc/dkms/framework.conf /etc/dkms/framework.conf.d/*.conf; do [[ -e "$i" ]] && safe_source "$i" "$@" done } # Little helper function for parsing the output of modinfo. get_module_verinfo(){ local ver local srcver local checksum local vals vals= while read -ra vals; do [[ ${#vals[@]} -eq 0 ]] && continue case "${vals[0]}" in version:) ver="${vals[1]}" checksum="${vals[2]}" ;; srcversion:) srcver="${vals[1]}" ;; esac done <<< "$(modinfo "$1")" echo -E "${ver}" # Use obsolete checksum info if srcversion is not available echo -E "${srcver:-$checksum}" } # Compare two modules' version # Output: # "==": They are the same version and the same srcversion # "=": They are the same version, but not the same srcversion # ">": 1st one is newer than 2nd one # "<": 1st one is older than 2nd one # "?": Cannot determine # Returns 0 if same version, otherwise 1 compare_module_version() { readarray -t ver1 <<< "$(get_module_verinfo "$1")" readarray -t ver2 <<< "$(get_module_verinfo "$2")" if [[ "${ver1[0]}" = "${ver2[0]}" ]]; then if [[ "${ver1[1]}" = "${ver2[1]}" ]]; then echo "==" else echo "=" fi return 0 elif [[ ${#ver1[@]} -eq 0 ]] || [[ ${#ver2[@]} -eq 0 ]]; then echo "?" elif [[ "$(VER "${ver1[0]}")" > "$(VER "${ver2[0]}")" ]]; then echo ">" else echo "<" fi return 1 } # Perform some module version sanity checking whenever we are installing # modules. check_version_sanity() { # $1 = kernel_version # $2 = arch # $3 = obs by kernel version # $4 = dest_module_name local lib_tree local i lib_tree="$install_tree/$1" i=0 if [[ $3 ]]; then # Magic split into array syntax saves trivial awk and cut calls. local -a obs local -a my local obsolete obs=("${3//-/ }") my=("${1//-/ }") obsolete=0 if [[ ${#obs[@]} -gt 0 && ${#my[@]} -gt 0 ]]; then if [[ $(VER "${obs[0]}") == $(VER "${my[0]}") && ! $force ]]; then # They get obsoleted possibly in this kernel release if [[ ! ${obs[1]} ]]; then # They were obsoleted in this upstream kernel obsolete=1 elif [[ $(VER "${my[1]}") > $(VER "${obs[1]}") ]]; then # They were obsoleted in an earlier ABI bump of the kernel obsolete=1 elif [[ $(VER "${my[1]}") = $(VER "${obs[1]}") ]]; then # They were obsoleted in this ABI bump of the kernel obsolete=1 fi elif [[ $(VER "${my[0]}") > $(VER "${obs[0]}") && ! $force ]]; then # They were obsoleted in an earlier kernel release obsolete=1 fi fi if ((obsolete == 1)); then echo "" >&2 echo "Module has been obsoleted due to being included in kernel $3." >&2 echo "We will avoid installing for future kernels above $3." >&2 echo "You may override by specifying --force." >&2 return 1 fi fi set_module_suffix "$1" read -ra kernels_module <<< "$(find_module "$lib_tree" "${4}")" [[ ${#kernels_module[@]} -eq 0 ]] && return 0 if [[ "$force_version_override" == "true" ]]; then # Skip the following version checking code. return 0 fi if [[ ${kernels_module[1]} ]]; then warn "Cannot do version sanity checking because multiple ${4}$module_suffix modules were found in kernel $1." return 0 fi local dkms_module dkms_module=$(compressed_or_uncompressed "$dkms_tree/$module/$module_version/$1/$2/module/" "${4}") local cmp_res cmp_res="$(compare_module_version "${kernels_module}" "${dkms_module}")" if [[ "${cmp_res}" = ">" ]]; then if [[ ! "$force" ]]; then error "Module version $(get_module_verinfo "${dkms_module}" | head -n 1) for $4${module_suffix}" \ "is not newer than what is already found in kernel $1 ($(get_module_verinfo "${kernels_module}" | head -n 1))." \ "You may override by specifying --force." return 1 fi elif [[ "${cmp_res}" = "==" ]]; then if [[ ! "$force" ]]; then # if the module has neither version nor srcversion/checksum, check the binary files instead local verinfo verinfo="$(get_module_verinfo "${dkms_module}")" if [[ "$(echo "$verinfo" | tr -d '[:space:]')" ]] || diff "${kernels_module}" "${dkms_module}" &>/dev/null; then verinfo=$(echo "$verinfo" | head -n 1) if [[ $verinfo ]]; then echo "Module ${kernels_module} already installed at version ${verinfo}, override by specifying --force" >&2 else echo "Module ${kernels_module} already installed (unversioned module), override by specifying --force" >&2 fi return 1 fi fi fi return 0 } check_module_args() { [[ $module && $module_version ]] && return die 1 "Arguments and are not specified." \ "Usage: $1 / or" \ " $1 -m / or" \ " $1 -m -v " } read_conf_or_die() { read_conf "$@" && return die 8 "Bad conf file."\ "File: ${3:-$conf} does not represent a valid dkms.conf file." } read_conf_strict_or_die() { read_conf_strict "$@" && return die 8 "Bad conf file."\ "File: ${3:-$conf} does not represent a valid dkms.conf file." } run_build_script() { # $1 = script type # $2 = script to run # $3 = (optional) logfile for script output local script_type local run [[ $2 ]] || return 0 case "$1" in pre_build|post_build) script_type='build' ;; *) script_type='source' ;; esac run="$dkms_tree/$module/$module_version/$script_type/$2" if [[ -x ${run%% *} ]]; then if [[ $3 ]]; then local res res=0 invoke_command "cd $dkms_tree/$module/$module_version/$script_type/ && $run" "Running the $1 script" "$3" background || res=$? if [[ $res != 0 ]]; then echo "Consult $3 for more information." exit "$res" fi else echo "Running the $1 script:" ( cd "$dkms_tree/$module/$module_version/$script_type/" || exit 15 exec $run ) fi else echo "" warn "The $1 script is not executable." fi } # Register a DKMS-ified source tree with DKMS. # This function is smart enough to register the module if we # passed a source tree or a tarball instead of relying on the source tree # being unpacked into /usr/src/$module-$module_version. add_module() { # If $archive is set and $module and $module_version are not, # try loading the tarball passed first. if [[ $archive_location && ! $module && ! $module_version ]]; then load_tarball elif [[ $try_source_tree && ! $module && ! $module_version ]]; then add_source_tree "$try_source_tree" fi # Check that we have all the arguments check_module_args add # Do stuff for --rpm_safe_upgrade if [[ $rpm_safe_upgrade ]]; then local pppid local lock_name pppid=$(awk '/PPid:/ {print $2}' /proc/$PPID/status) lock_name=$(mktemp_or_die "$tmp_location/dkms_rpm_safe_upgrade_lock.$pppid.XXXXXX") echo "$module-$module_version" >> "$lock_name" ps -o lstart --no-headers -p "$pppid" 2>/dev/null >> "$lock_name" fi # Check that this module-version hasn't already been added if is_module_added "$module" "$module_version"; then die 3 "DKMS tree already contains: $module/$module_version" \ "You cannot add the same module/version combo more than once." fi local source_conf source_conf=${conf:-"$source_tree/$module-$module_version/dkms.conf"} # Check that /usr/src/$module-$module_version exists if ! [[ -d $source_tree/$module-$module_version ]]; then die 2 "Could not find module source directory." \ "Directory: $source_tree/$module-$module_version does not exist." fi # Check the conf file for sanity read_conf_strict_or_die "$kernelver" "$arch" "$source_conf" # Create the necessary dkms tree structure echo "Creating symlink $dkms_tree/$module/$module_version/source -> $source_tree/$module-$module_version" mkdir -p "$dkms_tree/$module/$module_version/build" ln -s "$source_tree/$module-$module_version" "$dkms_tree/$module/$module_version/source" # Run the post_add script run_build_script post_add "$post_add" } # Prepare a kernel source or include tree for compiling a module. # Most modern-ish distros do not require this function at all, # so it will be removed in a future release. prepare_kernel() { # $1 = kernel version to prepare # Check that kernel-source exists _check_kernel_dir "$1" || { die 21 "Your kernel headers for kernel $1 cannot be found at $install_tree/$1/build or $install_tree/$1/source." \ "Please install the linux-headers-$1 package or use the --kernelsourcedir option to tell DKMS where it's located." } } prepare_mok() { if [[ ! $mok_signing_key ]]; then # No custom key specified, use the default key created by update-secureboot-policy for Ubuntu # Debian's update-secureboot-policy has no --new-key option case "$running_distribution" in ubuntu* ) mok_signing_key="/var/lib/shim-signed/mok/MOK.priv" mok_certificate="/var/lib/shim-signed/mok/MOK.der" if [[ ! -f ${mok_signing_key} || ! -f ${mok_certificate} ]]; then if [[ ! -x "$(command -v update-secureboot-policy)" ]]; then echo "Binary update-secureboot-policy not found, modules won't be signed" return 1 fi # update-secureboot-policy won't create new key if $mok_certificate exists if [[ -f ${mok_certificate} ]]; then rm -f "${mok_certificate:?}" fi echo "Certificate or key are missing, generating them using update-secureboot-policy..." SHIM_NOTRIGGER=y update-secureboot-policy --new-key &>/dev/null update-secureboot-policy --enroll-key fi ;; gentoo* ) # If the usual Gentoo/Portage environment variables are set, use those. mok_signing_key=${MODULES_SIGN_KEY} mok_certificate=${MODULES_SIGN_CERT} # If still empty, attempt to read the signing configuration set for portage. if [[ ! $mok_signing_key && -f /etc/portage/make.conf ]]; then mok_signing_key=$(grep "^MODULES_SIGN_KEY=" /etc/portage/make.conf | cut -f2 -d= | sed 's/"//g') fi if [[ ! $mok_certificate && -f /etc/portage/make.conf ]]; then mok_certificate=$(grep "^MODULES_SIGN_CERT=" /etc/portage/make.conf | cut -f2 -d= | sed 's/"//g') fi if [[ ! $mok_signing_key && -f ${kernel_config} ]]; then mok_signing_key=$(grep "^CONFIG_MODULE_SIG_KEY=" "${kernel_config}" | cut -f2 -d= | sed 's/"//g') # Kernel module signing facility requires PEM files containing both # the key and the certificate, so in this case both will be the same. mok_certificate=${mok_signing_key} fi ;; esac fi if [[ ! $mok_signing_key ]]; then mok_signing_key="/var/lib/dkms/mok.key" fi echo "Signing key: $mok_signing_key" if [[ ! $mok_certificate ]]; then mok_certificate="/var/lib/dkms/mok.pub" fi echo "Public certificate (MOK): $mok_certificate" # scripts/sign-file.c in kernel source also supports using "pkcs11:..." as private key if [[ $mok_signing_key != "pkcs11:"* ]] && [[ ! -f $mok_signing_key || ! -f $mok_certificate ]]; then echo "Certificate or key are missing, generating self signed certificate for MOK..." if ! command -v openssl >/dev/null; then echo "openssl not found, can't generate key and certificate." return 1 fi # Requires OpenSSL >= 1.1.1 for -addext openssl req -new -x509 -nodes -days 36500 -subj "/CN=DKMS module signing key" \ -newkey rsa:2048 -keyout "$mok_signing_key" \ -addext "extendedKeyUsage=codeSigning" \ -outform DER -out "$mok_certificate" > /dev/null 2>&1 if [[ ! -f ${mok_signing_key} ]]; then echo "Key file ${mok_signing_key} not found and can't be generated, modules won't be signed" return 1 fi fi if [[ ! -f ${mok_certificate} ]]; then echo "Certificate file ${mok_certificate} not found and can't be generated, modules won't be signed" return 1 fi return 0 } prepare_signing() { # Lazy source in signing related configuration read_framework_conf "$dkms_framework_signing_variables" do_signing=0 if [[ ! -f ${kernel_config} ]]; then echo "Kernel config ${kernel_config} not found, modules won't be signed" return fi if ! grep -q "^CONFIG_MODULE_SIG_HASH=" "${kernel_config}"; then echo "The kernel is built without module signing facility, modules won't be signed" return fi sign_hash=$(grep "^CONFIG_MODULE_SIG_HASH=" "${kernel_config}" | cut -f2 -d= | sed 's/"//g') if [[ ! ${sign_file} ]]; then case "$running_distribution" in debian* ) sign_file="/usr/lib/linux-kbuild-${kernelver%.*}/scripts/sign-file" ;; ubuntu* ) sign_file="$(command -v kmodsign)" if [[ ! -x "${sign_file}" ]]; then sign_file="/usr/src/linux-headers-$kernelver/scripts/sign-file" fi ;; gentoo* ) sign_file="/usr/src/linux-$kernelver/scripts/sign-file" ;; esac if [[ ! -f ${sign_file} ]]; then sign_file="$install_tree/$kernelver/build/scripts/sign-file" fi fi echo "Sign command: $sign_file" if [[ ! -f ${sign_file} || ! -x ${sign_file} ]]; then echo "Binary ${sign_file} not found, modules won't be signed" return fi if prepare_mok; then do_signing=1 fi } # Build a module that has been registered with DKMS. do_build() { [[ $kernelver && $arch ]] || die 16 "do_build: Empty \$kernelver or \$arch" # If the module has not been added, try to add it. if ! is_module_added "$module" "$module_version" ; then add_module echo "" fi local -r source_dir="$dkms_tree/$module/$module_version/source" local -r build_dir="$dkms_tree/$module/$module_version/build" local -r kernelver_dir="$dkms_tree/$module/$module_version/$kernelver" local -r base_dir="$kernelver_dir/$arch" local -r build_log="$build_dir/make.log" local bd local bd_missing local status local mvka local count local index # Check that the module has not already been built for this kernel [[ -d $base_dir ]] && die 3 \ "This module/version has already been built on: $kernelver" \ "Directory $base_dir already exists. Use the dkms remove function before trying to build again." # Read the conf file set_module_suffix "$kernelver" read_conf_strict_or_die "$kernelver" "$arch" # Error out if build_exclude is set [[ $build_exclude ]] && diewarn 77 \ "The $base_dir/dkms.conf"\ "for module $module/$module_version includes a BUILD_EXCLUSIVE directive"\ "which does not match this kernel/arch/config."\ "This indicates that it should not be built." # Error out if source_tree is basically empty (binary-only dkms tarball w/ --force check) # shellcheck disable=SC1083,SC2012 # TODO: use find instead of ls (($(ls "$source_dir" | wc -l | awk {'print $1'}) < 2)) && die 8 \ "The directory $source_dir does not appear to have module source located within it."\ "Build halted." prepare_kernel_and_signing if [[ -f $kernel_source_dir/.kernelvariables ]]; then CC=$(echo -e "show-%:\n\t@echo \$(\$*)\ninclude $kernel_source_dir/.kernelvariables" | make -f - show-CC) export CC else unset CC fi if [[ -e "${kernel_config}" ]]; then local cc cc=$(sed -n 's|^CONFIG_CC_VERSION_TEXT="\([^ ]*\) .*"|\1|p' "${kernel_config}") if command -v "$cc" >/dev/null; then CC="$cc" KERNEL_CC="$cc" export CC export KERNEL_CC fi if grep -q 'CONFIG_CC_IS_CLANG=y' "${kernel_config}"; then local cc cc=clang if command -v "$cc" >/dev/null; then CC="$cc" KERNEL_CC="$cc" export CC export KERNEL_CC fi fi if grep -q 'CONFIG_LD_IS_LLD=y' "${kernel_config}"; then local ld ld=ld.lld if command -v "$ld" >/dev/null; then LD="$ld" KERNEL_LD="$ld" export LD export KERNEL_LD fi fi fi # Check for missing BUILD_DEPENDS bd_missing= # shellcheck disable=SC2153 for bd in "${BUILD_DEPENDS[@]}"; do while read -r status mvka; do [[ $status ]] || continue [[ $status = installed ]] && continue 2 done <<< "$(module_status "$bd" "*" "$kernelver" "$arch")" bd_missing="$bd_missing $bd" done if [[ $bd_missing ]]; then if [[ $force ]]; then warn "Trying to build module $module/$module_version for kernel $kernelver ($arch) despite of missing BUILD_DEPENDS:$bd_missing." else die 13 "Aborting build of module $module/$module_version for kernel $kernelver ($arch) due to missing BUILD_DEPENDS:$bd_missing."\ "You may override by specifying --force." fi fi # Set up temporary build directory for build rm -rf "${build_dir:?}" cp -a "$source_dir/" "$build_dir" echo "DKMS (@RELEASE_STRING@) make.log for $module/$module_version for kernel $kernelver ($arch)" >> "$build_log" date >> "$build_log" cd "$build_dir" || exit 15 # Apply any patches for p in "${patch_array[@]}"; do [[ patches/$p == *"/../"* ]] && \ report_build_problem 5 \ "Patch $p as specified in dkms.conf contains '..' path component." [[ ! -e $build_dir/patches/$p ]] && \ report_build_problem 5 \ "Patch $p as specified in dkms.conf cannot be" \ "found in $build_dir/patches/." invoke_command "patch -p1 < ./patches/$p" "Applying patch $p" "$build_log" background || \ report_build_problem 6 "Application of patch $p failed." \ "Consult $build_log for more information." done # Run the pre_build script run_build_script pre_build "$pre_build" "$build_log" local the_make_command the_make_command="${make_command/#make/make -j$parallel_jobs KERNELRELEASE=$kernelver}" invoke_command "$the_make_command" "Building module(s)" "$build_log" background || \ report_build_problem 10 "Bad return status for module build on kernel: $kernelver ($arch)" \ "Consult $build_log for more information." # Make sure all the modules built successfully for ((count=0; count < num_modules; count++)); do [[ -e ${built_module_location[$count]}${built_module_name[$count]}$module_uncompressed_suffix ]] && continue report_build_problem 7 \ "Build of ${built_module_location[$count]}${built_module_name[$count]}$module_uncompressed_suffix failed for: $kernelver ($arch)" \ "Make sure the name and location of the generated module are correct," \ "or consult $build_log for more information." done # Build success, so create DKMS structure for a built module mkdir -p "$kernelver_dir" local -r tmp_base_dir=$(mktemp_or_die -d "$kernelver_dir/.tmp_${arch}_XXXXXX") mkdir -p "$tmp_base_dir/log" [[ $kernel_config ]] && cp -f "$kernel_config" "$tmp_base_dir/log/" # Save a copy of the new module mkdir -p "$tmp_base_dir/module" if [[ -f "$build_dir/Module.symvers" ]] ; then cp -f "$build_dir/Module.symvers" "$tmp_base_dir/module/Module.symvers" fi for ((count=0; count < num_modules; count++)); do local the_module local built_module local compressed_module the_module="$build_dir/${built_module_location[$count]}${built_module_name[$count]}" built_module="$the_module$module_uncompressed_suffix" compressed_module="$the_module$module_suffix" if [[ ! -f $built_module ]]; then warn "$built_module has disappeared" continue fi if [[ ${strip[$count]} != no ]] && [[ ${CC} == "clang" ]]; then llvm-strip -g "$built_module" elif [[ ${strip[$count]} != no ]]; then strip -g "$built_module" fi if (( do_signing )); then echo "Signing module $built_module" if ! signing_command_output=$("$sign_file" "$sign_hash" "$mok_signing_key" "$mok_certificate" "$built_module" 2>&1); then warn "Failed to sign module '$built_module'!" "$signing_command_output" fi fi if [[ $module_compressed_suffix = .gz ]]; then # shellcheck disable=SC2086 # splitting is intentional gzip $compress_gzip_opts -f "$built_module" || compressed_module="" elif [[ $module_compressed_suffix = .xz ]]; then # shellcheck disable=SC2086 # splitting is intentional xz $compress_xz_opts -f "$built_module" || compressed_module="" elif [[ $module_compressed_suffix = .zst ]]; then # shellcheck disable=SC2086 # splitting is intentional zstd $compress_zstd_opts -f "$built_module" || compressed_module="" fi if [[ $compressed_module ]]; then cp -f "$compressed_module" "$tmp_base_dir/module/${dest_module_name[$count]}$module_suffix" else cp -f "$built_module" "$tmp_base_dir/module/${dest_module_name[$count]}$module_uncompressed_suffix" fi done # Validate build completeness for ((index=0; index < num_modules; index++)); do local m local f m=${dest_module_name[index]} f=$(compressed_or_uncompressed "$tmp_base_dir/module" "$m") [[ $f && -f $f ]] || die 7 "Missing module '$m' in $tmp_base_dir/module" done # Rename the temporary directory chmod 0755 "$tmp_base_dir" mv -T "$tmp_base_dir" "$base_dir" || die 7 "do_build: final mv failed ($?)" # Run the post_build script, requires accessible $mvka/module/ run_build_script post_build "$post_build" "$build_log" cd - >/dev/null || exit 15 # Save the log file mv -f "$build_log" "$base_dir/log/make.log" 2>/dev/null # Clean the build directory rm -rf "${build_dir:?}" # After successful build, save dependency versions if [[ $BUILD_DEPENDS_REBUILD ]] && [[ ! $force ]]; then mkdir -p "$base_dir" for bd in "${BUILD_DEPENDS[@]}"; do local dep_version dep_version=$(module_status "$bd" "*" "$kernelver" "$arch" | while read -r status mvka; do [[ $status ]] || continue IFS='/' read -r m v k a <<< "$mvka" echo "$v" done | sort -V | tail -n1) [[ $dep_version ]] && echo "$dep_version" > "$base_dir/.dep_${bd}" done fi } prepare_kernel_and_signing() { [[ $prepared_kernel = "$kernelver/$arch" ]] && return set_kernel_source_dir_and_kconfig "$kernelver" prepare_kernel "$kernelver" prepare_signing prepared_kernel="$kernelver/$arch" echo "" } # Force the installation of a module if this is listed # in the files in $forced_modules_dir, if any force_installation() { forced_modules_dir="/usr/share/dkms/modules_to_force_install" to_force="" if [[ -d $forced_modules_dir ]]; then for elem in "$forced_modules_dir/"*; do if [[ -e $elem ]]; then to_force="$to_force $(cat "$elem")" fi done for elem in $to_force; do if [[ ${1} = "${elem}" ]]; then echo "force" return 0 elif [[ ${1}_version-override = "${elem}" ]]; then echo "version-override" return 0 fi done fi return 1 } # Install a previously built module # There are huge swaths of code here that special-case for various distros. # They should be split into their own functions. do_install() { [[ $kernelver && $arch ]] || die 16 "do_install: Empty \$kernelver or \$arch" # If the module has not been built, try to build it first. is_module_built "$module" "$module_version" "$kernelver" "$arch" || do_build local -r base_dir="$dkms_tree/$module/$module_version/$kernelver/$arch" local -r lib_tree="$install_tree/$kernelver" local -r original_module_backup_dir="$dkms_tree/$module/original_module/$kernelver/$arch" local -r active_link="$dkms_tree/$module/kernel-$kernelver-$arch" local count local index local symlink [[ $symlink_modules ]] && symlink="-s" # Save the status of $force local -r tmp_force="$force" # If the module is set to be force-installed local ret ret=$(force_installation "$module") if [[ "$ret" == "force" ]]; then force="true" echo "Forcing installation of $module" elif [[ "$ret" == "version-override" ]]; then force_version_override="true" echo "Forcing version override of $module" fi # Make sure that kernel exists to install into [[ -e $install_tree/$kernelver ]] || die 6 \ "The directory $install_tree/$kernelver doesn't exist." \ "You cannot install a module onto a non-existant kernel." # Read the conf file set_module_suffix "$kernelver" read_conf_strict_or_die "$kernelver" "$arch" # Validate build completeness for ((index=0; index < num_modules; index++)); do local m local f m=${dest_module_name[index]} f=$(compressed_or_uncompressed "$base_dir/module" "$m") [[ $f && -f $f ]] || die 6 "Missing module $m in $base_dir/module" done # Check that its not already installed (kernel symlink) is_module_installed "$module" "$module_version" "$kernelver" "$arch" && die 5 \ "This module/version combo is already installed for kernel $kernelver ($arch)." # If upgrading using rpm_safe_upgrade, go ahead and force the install # else we can wind up with the first half of an upgrade failing to install anything, # while the second half of the upgrade, the removal, then succeeds, leaving us with # nothing installed. [[ $rpm_safe_upgrade ]] && force="true" # Save the original_module if one exists, none have been saved before, and this is the first module for this kernel local any_module_installed if ! run_build_script pre_install "$pre_install" && ! [[ $force ]]; then die 101 "pre_install failed, aborting install." \ "You may override by specifying --force." fi for ((count=0; count < num_modules; count++)); do # Check this version against what is already in the kernel check_version_sanity "$kernelver" "$arch" "$obsolete_by" "${dest_module_name[$count]}" || continue local m local installed_modules local module_count local original_copy m=${dest_module_name[$count]} installed_modules=$(find_module "$lib_tree" "$m") module_count=${#installed_modules[@]} original_copy=$(compressed_or_uncompressed "$original_module_backup_dir" "$m") if [[ -L $active_link && $original_copy ]]; then echo "An original module was already stored during a previous install" elif [[ ! -L $active_link ]]; then local original_module local found_original local archive_pref1 local archive_pref2 local archive_pref3 local archive_pref4 original_module="" found_original="" archive_pref1=$(compressed_or_uncompressed "$lib_tree/extra" "$m") archive_pref2=$(compressed_or_uncompressed "$lib_tree/updates" "$m") archive_pref3=$(compressed_or_uncompressed "$lib_tree${dest_module_location[$count]}" "$m") archive_pref4="" ((module_count == 1)) && archive_pref4=${installed_modules[0]} for original_module in $archive_pref1 $archive_pref2 $archive_pref3 $archive_pref4; do [[ -f $original_module ]] || continue echo "Found pre-existing $original_module, archiving for uninstallation" mkdir -p "$original_module_backup_dir" mv -f "$original_module" "$original_module_backup_dir/" echo "$original_module" > "$original_module_backup_dir/${original_module##*/}.origin" found_original="yes" break done if [[ ! $found_original ]] && ((module_count > 1)); then echo "Multiple original modules exist, so none will be put back in place during a later uninstall" echo "All instances will be stored for reference purposes in $original_module_backup_dir/collisions/" fi fi if ((module_count > 1)); then echo "Multiple same named modules! $module_count named $m$module_suffix in $lib_tree/" for module_dup in $(find_module "$lib_tree" "$m"); do dup_tree="${module_dup#"${lib_tree}"}"; dup_name="${module_dup##*/}" dup_tree="${dup_tree/"${dup_name}"}" mkdir -p "$original_module_backup_dir/collisions/$dup_tree" mv -f "$module_dup" "$original_module_backup_dir/collisions/$dup_tree/" echo "$module_dup" > "$original_module_backup_dir/collisions/$dup_tree/$dup_name.origin" done fi # Copy module to its location local toinstall local dest_dir local dest_name toinstall=$(compressed_or_uncompressed "$base_dir/module" "$m") dest_dir="$install_tree/$kernelver${dest_module_location[$count]}" dest_name=${toinstall##*/} echo "Installing $dest_dir/$dest_name" mkdir -p "$dest_dir" cp -f $symlink "$toinstall" "$dest_dir/$dest_name" || die 6 "Copying '$toinstall' failed" any_module_installed=1 done if ((num_modules > 0)) && [[ ! "${any_module_installed}" ]]; then die 6 "Installation aborted." fi # Create the kernel- symlink to designate this version as active rm -f "$active_link" ln -s "$module_version/$kernelver/$arch" "$active_link" # Add to kabi-tracking if [[ ! $NO_WEAK_MODULES ]]; then if [[ ${weak_modules_add} ]]; then echo "Adding linked weak modules..." list_each_installed_module "$module" "$kernelver" "$arch" | ${weak_modules_add} fi fi # Run the post_install script run_build_script post_install "$post_install" invoke_command "do_depmod $kernelver" "Running depmod" '' background || { do_uninstall "$kernelver" "$arch" die 6 "Problems with depmod detected. Automatically uninstalling this module." \ "Install Failed (depmod problems). Module rolled back to built state." exit 6 } if [[ $modprobe_on_install ]] && [[ $kernelver = "$(uname -r)" ]]; then # Make the newly installed modules available immediately find /sys/devices -name modalias -print0 | xargs -0 cat | sort -u | xargs modprobe -a -b -q if [[ -f /lib/systemd/system/systemd-modules-load.service ]]; then systemctl restart systemd-modules-load.service fi fi # Restore the status of $force force="$tmp_force" # First check and rebuild any modules with updated dependencies check_and_rebuild_dependent_modules "${kernelver[0]}" "${arch[0]}" } # List each kernel object that has been installed for a particular module. list_each_installed_module() { # $1 = module # $2 = kernel version # $3 = arch local count local real_dest_module_location local mod for ((count=0; count < num_modules; count++)); do real_dest_module_location="$(find_actual_dest_module_location "$1" "$count" "$2" "$3")" mod=$(compressed_or_uncompressed "$install_tree/$2${real_dest_module_location}" "${dest_module_name[$count]}") echo "$mod" done } # Check if either the module source, or the symlink pointing to it is missing # A module can only be in this broken state, if the user or a faulty program # messed up. The module then is considered volatile, because there is no reliable # way to tell if files in the source tree are still in a valid state. # Therefore any action (except 'add', if only the symlink is missing) # to operate on the module has to be refused. # Manual intervention by the user is required to return to a sane state. is_module_broken() { [[ $1 && $2 ]] || return 1 [[ -d $dkms_tree/$1/$2 ]] || return 2 [[ -L $dkms_tree/$1/$2/source && ! -d $dkms_tree/$1/$2/source ]] && return [[ ! -L $dkms_tree/$1/$2/source && -d $source_tree/$1-$2/ ]] && return } is_module_added() { [[ $1 && $2 ]] || return 1 [[ -d $dkms_tree/$1/$2 ]] || return 2 [[ -L $dkms_tree/$1/$2/source && -d $dkms_tree/$1/$2/source ]] || return 2 } is_module_built() { [[ $1 && $2 && $3 && $4 ]] || return 1 local d d="$dkms_tree/$1/$2/$3/$4" [[ -d $d/module ]] || return 1 } # This assumes we have already checked to see if the module has been built. _is_module_installed() { [[ $1 && $2 && $3 && $4 ]] || return 1 local d local k d="$dkms_tree/$1/$2/$3/$4" k="$dkms_tree/$1/kernel-$3-$4" [[ -L $k && $(readlink -f "$k") = "$d" ]] } # This does not. is_module_installed() { is_module_built "$@" && _is_module_installed "$@"; } maybe_add_module() ( is_module_added "$1" "$2" && { echo "Module $1/$2 already added." return 0 } module="$1" module_version="$2" add_module ) maybe_build_module() ( is_module_built "$1" "$2" "$3" "$4" && { if [[ "$force" = "true" ]]; then do_unbuild "$3" "$4" else echo "Module $1/$2 already built for kernel $3 ($4), skip." \ "You may override by specifying --force." return 0 fi } module="$1" module_version="$2" kernelver="$3" arch="$4" do_build ) maybe_install_module() ( is_module_installed "$1" "$2" "$3" "$4" && { if [[ "$force" = "true" ]]; then do_uninstall "$3" "$4" echo "" else echo "Module $1/$2 already installed on kernel $3 ($4), skip." \ "You may override by specifying --force." return 0 fi } module="$1" module_version="$2" kernelver="$3" arch="$4" do_install ) build_module() { local i for ((i=0; i < ${#kernelver[@]}; i++)); do maybe_build_module "$module" "$module_version" "${kernelver[$i]}" "${arch[$i]}" done } install_module() { local i for ((i=0; i < ${#kernelver[@]}; i++)); do maybe_install_module "$module" "$module_version" "${kernelver[$i]}" "${arch[$i]}" done } possible_dest_module_locations() { # $1 = count # There are two places an installed module may really be: # 1) "$install_tree/$kernelver/${dest_module_location[$count]}/${dest_module_name[$count]}$module_suffix" # 2) "$install_tree/$kernelver/${DEST_MODULE_LOCATION[$count]}/${dest_module_name[$count]}$module_suffix" # override_dest_module_location() is what controls whether or not they're the same. local location location[0]="${dest_module_location[$count]}" [[ ${DEST_MODULE_LOCATION[$count]} != "${dest_module_location[$count]}" ]] && \ location[1]="${DEST_MODULE_LOCATION[$count]}" echo "${location[@]}" } find_actual_dest_module_location() { local module local count local kernelver local arch local locations module=$1 count=$2 kernelver=$3 arch=$4 locations=$(possible_dest_module_locations "$count") local l local dkms_owned local installed dkms_owned=$(compressed_or_uncompressed "${dkms_tree}/${module}/kernel-${kernelver}-${arch}/module" "${dest_module_name[$count]}") for l in $locations; do installed=$(compressed_or_uncompressed "${install_tree}/${kernelver}${l}" "${dest_module_name[${count}]}") if [[ $installed ]] && compare_module_version "${dkms_owned}" "${installed}" &>/dev/null; then echo "${l}" return 0 fi done } # Remove compiled DKMS modules from any kernels they are installed in. do_uninstall() { # $1 = kernel version # $2 = arch local -r original_module_backup_dir="$dkms_tree/$module/original_module/$1/$2" echo "Module $module/$module_version for kernel $1 ($2):" # Read the conf file set_module_suffix "$1" read_conf_or_die "$1" "$2" # If kernel- symlink points to this module, check for original_module and put it back local was_active local kernel_symlink local real_dest_module_location was_active="" kernel_symlink=$(readlink -f "$dkms_tree/$module/kernel-$1-$2") if [[ $kernel_symlink = $dkms_tree/$module/$module_version/$1/$2 ]]; then was_active="true" echo "Before uninstall, this module version was ACTIVE on this kernel." # remove kabi-tracking if last instance removed if [[ ! $NO_WEAK_MODULES ]]; then if [[ ${weak_modules_remove} ]] && (module_status_built "$module" "$module_version" | grep -q "installed"); then echo "Removing linked weak modules..." list_each_installed_module "$module" "$1" "$2" | ${weak_modules_remove} fi fi for ((count=0; count < num_modules; count++)); do local m m=${dest_module_name[$count]} real_dest_module_location="$(find_actual_dest_module_location "$module" "$count" "$1" "$2")" if [[ ${real_dest_module_location} ]]; then echo "Deleting $install_tree/$1${real_dest_module_location}/$m$module_suffix" rm -f "${install_tree:?}/$1${real_dest_module_location}/$m$module_uncompressed_suffix"* dir_to_remove="${real_dest_module_location#/}" while [[ ${dir_to_remove} != "${dir_to_remove#/}" ]]; do dir_to_remove="${dir_to_remove#/}" done case "$running_distribution" in debian* | ubuntu* | arch* | gentoo*) (if cd "$install_tree/$1"; then rmdir -p --ignore-fail-on-non-empty "${dir_to_remove}"; fi || true) ;; *) (if cd "$install_tree/$1"; then rpm -qf "${dir_to_remove}" >/dev/null 2>&1 || rmdir -p --ignore-fail-on-non-empty "${dir_to_remove}"; fi || true) ;; esac else echo "Module $m$module_suffix was not found within $install_tree/$1/" fi if [[ -d $original_module_backup_dir ]]; then local origin_file while IFS= read -r origin_file do [[ $origin_file ]] || continue local original_module original_module=${origin_file%.origin} [[ -f $original_module ]] || continue local original_location original_location=$(head -n 1 "$origin_file") case $original_location in "$install_tree/$1/"*) echo "Restoring archived original module $original_location" mkdir -p "${original_location%/*}" mv -f "$original_module" "$original_location" rm -f "$origin_file" ;; *) warn "Bad original location '$original_location' in $origin_file" ;; esac done <<< "$(find "$original_module_backup_dir" -type f -name "$m.*.origin")" find "${original_module_backup_dir%/*}" -type d -empty -delete fi local origmod origmod=$(compressed_or_uncompressed "$original_module_backup_dir" "$m") if [[ $origmod ]]; then # Module was archived by older dkms versions without creating .origin echo "Restoring archived original module" mkdir -p "$install_tree/$1${DEST_MODULE_LOCATION[$count]}/" mv -f "$origmod" "$install_tree/$1${DEST_MODULE_LOCATION[$count]}/" 2>/dev/null fi done rm -f "${dkms_tree:?}/$module/kernel-$1-$2" else echo "This module version was INACTIVE for this kernel." fi # Run the post_remove script run_build_script post_remove "$post_remove" # Run depmod because we changed $install_tree if [[ ! $delayed_depmod ]]; then invoke_command "do_depmod $1" "Running depmod" '' background else touch "$dkms_tree/depmod-pending-$1-$2" fi # Delete the original_module if nothing for this kernel is installed anymore if [[ $was_active && -d $dkms_tree/$module/original_module/$1/$2 ]]; then echo "Removing original module(s) from DKMS tree for kernel $1 ($2)" rm -rf "${dkms_tree:?}/$module/original_module/$1/$2" 2>/dev/null [[ $(find "$dkms_tree/$module/original_module/$1/"* -maxdepth 0 -type d 2>/dev/null) ]] || rm -rf "${dkms_tree:?}/$module/original_module/$1" fi [[ $(find "$dkms_tree/$module/original_module/"* -maxdepth 0 -type d 2>/dev/null) ]] || rm -rf "${dkms_tree:?}/$module/original_module" } module_is_broken_and_die() { is_module_broken "$module" "$module_version" && die 4 "$module/$module_version is broken!"\ "Missing the source directory or the symbolic link pointing to it."\ "Manual intervention is required!" } module_is_added_or_die() { is_module_added "$module" "$module_version" || die 3 \ "The module/version combo: $module/$module_version is not located in the DKMS tree." } maybe_unbuild_module() { is_module_built "$module" "$module_version" "$1" "$2" || { echo "Module $module/$module_version is not built for kernel $1 ($2)."\ "Skipping..." return 0 } do_unbuild "$1" "$2" } maybe_uninstall_module() { is_module_installed "$module" "$module_version" "$1" "$2" || { echo "Module $module/$module_version is not installed for kernel $1 ($2)."\ "Skipping..." return 0 } do_uninstall "$1" "$2" } uninstall_module() { local i for ((i=0; i < ${#kernelver[@]}; i++)); do [[ $i = 0 ]] || echo "" maybe_uninstall_module "${kernelver[$i]}" "${arch[$i]}" done } do_unbuild() { # Delete or "unbuild" the $kernel_version/$arch_used part of the tree rm -rf "${dkms_tree:?}/$module/$module_version/$1/$2" [[ $(find "${dkms_tree:?}/$module/$module_version/$1/"* -maxdepth 0 -type d 2>/dev/null) ]] || \ rm -rf "${dkms_tree:?}/$module/$module_version/$1" } # Remove the built module, w/o removing/unregistering it. # This uninstalls any installed modules along the way unbuild_module() { local i for ((i=0; i < ${#kernelver[@]}; i++)); do [[ $i = 0 ]] || echo "" maybe_uninstall_module "${kernelver[$i]}" "${arch[$i]}" maybe_unbuild_module "${kernelver[$i]}" "${arch[$i]}" done } # Unregister a DKMS module. This uninstalls any installed modules along the way. remove_module() { # Clean up leftover temporary directories rm -rf "${dkms_tree:?}/$module/$module_version"/*/.tmp_* find "$dkms_tree/$module/$module_version/" -maxdepth 1 -type d -empty -delete # Do --rpm_safe_upgrade check (exit out and don't do remove if inter-release RPM upgrade scenario occurs) if [[ $rpm_safe_upgrade ]]; then local pppid local time_stamp pppid=$(awk '/PPid:/ {print $2}' /proc/$PPID/status) time_stamp=$(ps -o lstart --no-headers -p "$pppid" 2>/dev/null) for lock_file in "$tmp_location/dkms_rpm_safe_upgrade_lock.$pppid".*; do [[ -f $lock_file ]] || continue lock_head=$(head -n 1 "$lock_file" 2>/dev/null) lock_tail=$(tail -n 1 "$lock_file" 2>/dev/null) [[ $lock_head = $module-$module_version && $time_stamp && $lock_tail = "$time_stamp" ]] || continue rm -f "${lock_file:?}" die 0 "Remove cancelled because --rpm_safe_upgrade scenario detected." done fi local i for ((i=0; i < ${#kernelver[@]}; i++)); do maybe_uninstall_module "${kernelver[$i]}" "${arch[$i]}" maybe_unbuild_module "${kernelver[$i]}" "${arch[$i]}" echo "" done # Delete the $module_version part of the tree if no other $module_version/$kernel_version dirs exist if ! find "$dkms_tree/$module/$module_version/"* -maxdepth 0 -type d 2>/dev/null | grep -Eqv "(build|tarball|driver_disk|rpm|deb|source)$"; then echo "Deleting module $module/$module_version completely from the DKMS tree." rm -rf "${dkms_tree:?}/$module/$module_version" fi # Get rid of any remnant directories if necessary # shellcheck disable=SC2012 # TODO: use find instead if (($(ls "$dkms_tree/$module" | wc -w | awk '{print $1}') == 0)); then rm -rf "${dkms_tree:?}/$module" 2>/dev/null fi } # Given a kernel object, figure out which DKMS module it is from. find_module_from_ko() { local ko local basename_ko ko="$1" basename_ko="${ko##*/}" local module local kernellink for kernellink in "$dkms_tree"/*/kernel-*; do [[ -L $kernellink ]] || continue module=${kernellink#"${dkms_tree}/"} module=${module%/kernel-*} diff "$kernellink/module/${basename_ko}" "${ko}" >/dev/null 2>&1 || continue rest=$(readlink "$kernellink") echo "$module/$rest" return 0 done return 1 } # Check to see if modules meeting the passed parameters are weak-installed. # This function's calling convention is different from the usual DKMS status # checking functions -- the kernel version we usually have is the one we are currently # running on, not necessarily the one we compiled the module for. module_status_weak() { # $1 = module, $2 = module version, $3 = kernel version weak installed to, # $4 = kernel arch, $5 = kernel version built for [[ $NO_WEAK_MODULES ]] || return 1 [[ $weak_modules_add ]] && [[ $weak_modules_remove ]] || return 1 local m local v local k local a local kern local weak_ko local mod local installed_ko local f local ret local oifs ret=1 oifs=$IFS local -A already_found for weak_ko in "$install_tree/"*/weak-updates/*; do [[ -e $weak_ko ]] || continue if [[ -L $weak_ko ]]; then installed_ko="$(readlink -f "$weak_ko")" else continue fi IFS=/ read -r m v k a <<< "$(IFS=$oifs find_module_from_ko "$weak_ko")" [[ $m ]] || continue kern=${weak_ko#"${install_tree}/"} kern=${kern%/weak-updates/*} [[ $m = "${1:-*}" && $v = "${2:-*}" && $k = "${5:-*}" && $a = "${4:-*}" && $kern = "${3:-*}" ]] || continue already_found[$m/$v/$kern/$a/$k]+=${weak_ko##*/}" " done # Check to see that all ko's are present for each module for mod in "${!already_found[@]}"; do IFS=/ read -r m v k a kern <<< "$mod" # ensure each module is weak linked # shellcheck disable=SC2044 # TODO: use find + -exec instead for installed_ko in $(find "$dkms_tree/$m/$v/$kern/$a/module" -type f); do [[ ${already_found[$mod]} != *"$installed_ko"* ]] && continue 2 done ret=0 echo "installed-weak $mod" done return $ret } # Print the requested status lines for weak-installed modules. do_status_weak() { local mvka local m local v local k local a local kern local status while read -r status mvka; do [[ $status ]] || continue IFS=/ read -r m v k a kern <<< "$mvka" echo "$m, $v, $k, $a: installed-weak from $kern" done <<< "$(module_status_weak "$@")" } # Spit out all the extra status information that people running DKMS are # interested in, but that the DKMS internals do not usually care about. module_status_built_extra() ( set_module_suffix "$3" read_conf "$3" "$4" "$dkms_tree/$1/$2/source/dkms.conf" [[ -d $dkms_tree/$1/original_module/$3/$4 ]] && echo -n " (Original modules exist)" for ((count=0; count < num_modules; count++)); do tree_mod=$(compressed_or_uncompressed "$dkms_tree/$1/$2/$3/$4/module" "${dest_module_name[$count]}") if [[ ! $tree_mod ]]; then echo -n " (Built modules are missing in the kernel modules folder)" break elif _is_module_installed "$@"; then real_dest="$(find_actual_dest_module_location "$1" $count "$3" "$4")" real_dest_mod=$(compressed_or_uncompressed "$install_tree/$3${real_dest}" "${dest_module_name[$count]}") if ! diff -q "$tree_mod" "$real_dest_mod" >/dev/null 2>&1; then echo -n " (Differences between built and installed modules)" break fi fi done ) # Return a list of all the modules that are either built or installed. # This and list_module_version_combos do some juggling of $IFS to ensure that # we do not get word splitting where it would be inconvenient. module_status_built() { local ret local directory local ka local k local a local state local oifs ret=1 oifs="$IFS" IFS='' for directory in "$dkms_tree/$1/$2/"${3:-+([0-9]).*}/${4:-*}; do IFS="$oifs" ka="${directory#"${dkms_tree}/${1}/${2}/"}" k="${ka%/*}" a="${ka#*/}" is_module_built "$1" "$2" "$k" "$a" || continue ret=0 state="built" _is_module_installed "$1" "$2" "$k" "$a" && state="installed" echo "$state $1/$2/$k/$a" IFS='' done IFS="$oifs" return $ret } # Return a list of all module/version combos known to DKMS. list_module_version_combos() { local ret local modv local directory local oifs ret=1 oifs="$IFS" IFS='' for directory in "$dkms_tree/"${1:-*}/${2:-*}; do IFS="$oifs" [[ -d $directory ]] || continue modv="${directory#"${dkms_tree}/"}" # skip /kernel-- -> // symlinks [[ $modv != */kernel-*-* ]] || continue echo "$modv" ret=0 IFS='' done IFS="$oifs" return $ret } # Return the status of all modules that have been added, built, or installed. module_status() { local ret local m local v ret=1 while IFS='/' read -r m v; do [[ $m ]] || continue is_module_broken "$m" "$v" && { echo "broken $m/$v"; continue; } is_module_added "$m" "$v" || continue ret=0 module_status_built "$m" "$v" "$3" "$4" || echo "added $m/$v" done <<< "$(list_module_version_combos "$1" "$2")" return $ret } # Print out the status in the format that people who call DKMS expect. # Internal callers should use the module_status functions, as their output # is easier to parse. do_status() { local status local mvka local m local v local k local a while read -r status mvka; do IFS=/ read -r m v k a <<< "$mvka" case $status in broken) echo "$m/$v: $status" error "$m/$v: Missing the module source directory or the symbolic link pointing to it."\ "Manual intervention is required!" ;; added) echo "$m/$v: $status" ;; built|installed) echo -n "$m/$v, $k, $a: $status" module_status_built_extra "$m" "$v" "$k" "$a" echo ;; esac done <<< "$(module_status "$@")" } # Show all our status in the format that external callers expect, even # though it is slightly harder to parse. show_status() { local j if ((${#kernelver[@]} == 0)); then do_status "$module" "$module_version" "$kernelver" "$arch" do_status_weak "$module" "$module_version" "$kernelver" "$arch" else for ((j=0; j < ${#kernelver[@]}; j++)); do do_status "$module" "$module_version" "${kernelver[$j]}" "${arch[$j]}" do_status_weak "$module" "$module_version" "${kernelver[$j]}" "${arch[$j]}" done fi } make_tarball() { # Read the conf file read_conf_or_die "$kernelver" "$arch" local -r temp_dir_name=$(mktemp_or_die -d "$tmp_location/dkms.XXXXXX") make_tarball_rm_temp_dir_name="rm -rf ${temp_dir_name:?}" mkdir -p "$temp_dir_name/dkms_main_tree" if [[ $source_only ]]; then kernel_version_list="source-only" else local i for ((i=0; i<${#kernelver[@]}; i++)); do local intree_module_dir="$dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}" local temp_module_dir="$temp_dir_name/dkms_main_tree/${kernelver[$i]}" if ! [[ -d "$intree_module_dir" ]]; then die 6 "No modules built for ${kernelver[$i]} (${arch[$i]})." \ "Modules must already be in the built state before using mktarball." fi set_module_suffix "${kernelver[$i]}" echo "Marking modules for ${kernelver[$i]} (${arch[$i]}) for archiving..." if [[ ! $kernel_version_list ]]; then kernel_version_list="kernel${kernelver[$i]}-${arch[$i]}" else kernel_version_list="${kernel_version_list}-kernel${kernelver[$i]}-${arch[$i]}" fi mkdir -p "$temp_module_dir" cp -rf "$intree_module_dir" "$temp_module_dir" done fi local -r source_dir="$dkms_tree/$module/$module_version/source" # Copy the source_tree or make special binaries-only structure if [[ $binaries_only ]]; then local -r binary_only_dir="$temp_dir_name/dkms_binaries_only" echo "" echo "Creating tarball structure to specifically accomodate binaries." mkdir "$binary_only_dir" echo "$module" > "$binary_only_dir/PACKAGE_NAME" echo "$module_version" > "$binary_only_dir/PACKAGE_VERSION" [[ ! $conf ]] && conf="$source_dir/dkms.conf" cp -f "$conf" "$binary_only_dir/" 2>/dev/null else echo "" echo "Marking $source_dir for archiving..." mkdir -p "$temp_dir_name/dkms_source_tree" cp -rf "$source_dir/"* "$temp_dir_name/dkms_source_tree" fi # shellcheck disable=SC1083 if (( $(echo "$kernel_version_list" | wc -m | awk {'print $1'}) > 200 )); then kernel_version_list="manykernels" fi local tarball_name local tarball_dest tarball_name="$module-$module_version-$kernel_version_list.dkms.tar.gz" tarball_dest="$dkms_tree/$module/$module_version/tarball/" if [[ $archive_location ]]; then tarball_name="${archive_location##*/}" if [[ ${archive_location%/*} != "$archive_location" ]]; then tarball_dest="${archive_location%/*}" fi fi echo "" echo "Tarball location: $tarball_dest/$tarball_name" if [[ ! -d $tarball_dest ]]; then if ! mkdir -p "$tarball_dest" 2>/dev/null; then die 9 "Missing write permissions for $tarball_dest." fi fi [[ -w $tarball_dest ]] || die 9 "Missing write permissions for $tarball_dest." if ! tar -C "$temp_dir_name" -caf "$tarball_dest/$tarball_name" . 2>/dev/null; then die 6 "Failed to make tarball." fi eval "$make_tarball_rm_temp_dir_name" unset make_tarball_rm_temp_dir_name } # A tiny helper function to make sure dkms.conf describes a valid package. get_pkginfo_from_conf() { [[ -f $1 && $1 = *dkms.conf ]] || return read_conf_or_die "$kernelver" "$arch" "$1" [[ $PACKAGE_NAME && $PACKAGE_VERSION ]] } # Unpack a DKMS tarball from a few different supported formats. # We expect $archive_location to have been passed either as a raw argument or # with --archive. load_tarball() { # Error out if $archive_location does not exist if [[ ! -e $archive_location ]]; then die 2 "$archive_location does not exist." fi # If it is an .rpm file. install it with rpm, run an autoinstall, and then exit. if [[ $archive_location = *.rpm ]]; then if rpm -Uvh "$archive_location"; then autoinstall exit $? else die 9 "Unable to install $archive_location using rpm." \ "Check to ensure that your system can install .rpm files." fi fi # Untar it into $tmp_location local -r temp_dir_name=$(mktemp_or_die -d "$tmp_location/dkms.XXXXXX") load_tarball_rm_temp_dir_name="rm -rf ${temp_dir_name:?}" tar -xaf "$archive_location" -C "$temp_dir_name" if [[ ! -d $temp_dir_name/dkms_main_tree ]]; then # Tarball was not generated from mktarball. # Just find the dkms.conf file and load the source. conf=$(find "$temp_dir_name/" -name dkms.conf 2>/dev/null | head -n 1) if [[ ! $conf ]]; then die 3 "Tarball does not appear to be a correctly formed DKMS archive. No dkms.conf found within it." fi add_source_tree "${conf%dkms.conf}" return fi # Make sure its a sane tarball. Sane ones will have one of the two # directories we test for. for loc in dkms_source_tree dkms_binaries_only ''; do if [[ ! $loc ]]; then die 7 "No valid dkms.conf in dkms_source_tree or dkms_binaries_only." \ "$archive_location is not a valid DKMS tarball." fi local conf conf="$temp_dir_name/$loc/dkms.conf" [[ -f $conf ]] || continue if ! get_pkginfo_from_conf "$conf"; then echo >&2 echo "Malformed dkms.conf, refusing to load." >&2 continue fi if is_module_added "$PACKAGE_NAME" "$PACKAGE_VERSION" && \ [[ ! $force ]]; then die 8 "$PACKAGE_NAME/$PACKAGE_VERSION is already added!" \ "Aborting." fi # Success! break done module="$PACKAGE_NAME"; module_version="$PACKAGE_VERSION" echo "" echo "Loading tarball for $module/$module_version" case $loc in dkms_source_tree) add_source_tree "$temp_dir_name/dkms_source_tree" ;; dkms_binaries_only) #if there is a source tree on the system already, don't build a binaries stub if [[ ! -d $source_tree/$module-$module_version ]]; then local -r source_dir="$dkms_tree/$module/$module_version/source" echo "Creating $source_dir" mkdir -p "$source_dir" echo "Copying dkms.conf to $source_dir ..." cp -rf "$temp_dir_name/dkms_binaries_only/dkms.conf" "$source_dir" fi ;; esac # At this point, the source has been copied to the appropriate location # and registered with dkms, or a binary-only config has been noted. # Now, add any included precompiled modules. # Load precompiled modules. for directory in "$temp_dir_name/dkms_main_tree"/*/*; do [[ -d $directory ]] || continue local -r kernel_arch_to_load=${directory/*dkms_main_tree\/} local -r dkms_dir_location=$dkms_tree/$module/$module_version/$kernel_arch_to_load if [[ -d $dkms_dir_location && ! $force ]]; then warn "$dkms_dir_location already exists. Skipping..." else echo "Loading $dkms_dir_location..." rm -rf "${dkms_dir_location:?}" mkdir -p "$dkms_dir_location" cp -rf "$directory/"* "$dkms_dir_location/" fi done eval "$load_tarball_rm_temp_dir_name" unset load_tarball_rm_temp_dir_name [[ $loc != dkms_binaries_only ]] || [[ -d $source_tree/$module-$module_version ]] } run_match() { set_kernel_source_dir_and_kconfig "$kernelver" # Error if $template_kernel is unset if [[ ! $template_kernel ]]; then die 1 "Invalid number of parameters passed." \ "Usage: match --templatekernel= -k " \ " or: match --templatekernel= -k " fi # Error out if $template_kernel = $kernel_version if [[ $template_kernel = "$kernelver" ]]; then die 2 "The templatekernel and the specified kernel version are the same." fi # Read in the status of template_kernel local template_kernel_status template_kernel_status=$(do_status '' '' "$template_kernel" "$arch" | grep ": installed") # If $module is set, grep the status only for that module if [[ $module ]]; then # Make sure that its installed in the first place if ! [[ -d $dkms_tree/$module/ ]]; then die 3 "The module: $module is not located in the DKMS tree." fi template_kernel_status=$(echo "$template_kernel_status" | grep "^$module,") fi echo "" echo "Matching modules in kernel: $kernelver ($arch)" echo "to the configuration of kernel: $template_kernel ($arch)" # Prepare the kernel just once but only if there is actual work to do if [[ ! $template_kernel_status ]]; then echo "" echo "There is nothing to be done for this match." return 0 fi prepare_kernel "$kernelver" # Iterate over the kernel_status and match kernel to the template_kernel while read -r template_line; do # shellcheck disable=SC1083 template_module=$(echo "$template_line" | awk {'print $1'} | sed 's/,$//') # shellcheck disable=SC1083 template_version=$(echo "$template_line" | awk {'print $2'} | sed 's/,$//') # Print out a match header echo "Module: $template_module" echo "Version: $template_version" # Continue if the status is broken, as there is nothing we can do if is_module_broken "$template_module" "$template_version"; then error "$template_module/$template_version is broken!"\ "Missing the source directory or the symbolic link pointing to it."\ "Manual intervention is required!" continue fi maybe_build_module "$template_module" "$template_version" "$kernelver" "$arch" maybe_install_module "$template_module" "$template_version" "$kernelver" "$arch" done <<< "$template_kernel_status" } report_build_problem() { # If apport is on the system, files a build problem if [[ -x /usr/share/apport/apport ]] && command -v python3 >/dev/null; then python3 /usr/share/apport/package-hooks/dkms_packages.py -m "$module" -v "$module_version" -k "${kernelver[0]}" fi die "$@" } # Little helper function for reading args from the commandline. # It automatically handles -a b and -a=b variants, and returns 1 if # we need to shift $3. read_arg() { # $1 = arg name # $2 = arg value # $3 = arg parameter local rematch rematch='^[^=]*=(.*)$' if [[ $2 =~ $rematch ]]; then read -r "$1" <<< "${BASH_REMATCH[1]}" else read -r "$1" <<< "$3" # There is no way to shift our callers args, so # return 1 to indicate they should do it instead. return 1 fi } # A couple of helper functions for parsing out our most common arguments. # This one allows you to pass -k kernel.version-extra/arch instead of # -k kernel-version.extra -a arch. # This makes it harder to pass mismatching numbers of kernel/arch pairs, because # they are all passed at the same time. parse_kernelarch(){ if [[ $1 =~ $mv_re ]]; then kernelver[${#kernelver[@]}]="${BASH_REMATCH[1]}" arch[${#arch[@]}]="${BASH_REMATCH[2]}" else kernelver[${#kernelver[@]}]="$1" fi } # This allows you to pass module and module_version information on the commandline # in a more convenient form. Instead of the mostly mandatory and annoying # -m module -v module_version, you can use either -m module/module_version, # or just a raw module/module_version with no -m parameter. # This vastly improves readability and discoverability of # commands on the commandline. parse_moduleversion(){ if [[ $1 =~ $mv_re ]]; then module="${BASH_REMATCH[1]}" module_version="${BASH_REMATCH[2]}" else module="$1" fi } check_root() { [[ $(id -u) = 0 ]] && return die 1 "You must be root to use this command." } check_rw_dkms_tree() { [[ -w "$dkms_tree" ]] && return die 1 "No write access to DKMS tree at ${dkms_tree}" } # Add a passed source tree to the default source location. # We will check the dkms.conf file to make sure it is valid # beforehand. add_source_tree() { local from from=$(readlink -f "$1") if ! [[ $from && -f $from/dkms.conf ]]; then die 9 "$1 must contain a dkms.conf file!" fi check_root setup_kernels_arches if ! get_pkginfo_from_conf "$from/dkms.conf" ; then die 10 "Malformed dkms.conf file. Cannot load source tree." fi module="$PACKAGE_NAME" module_version="$PACKAGE_VERSION" if [[ $force && -d $source_tree/$module-$module_version ]]; then echo >&2 echo "Forcing install of $module/$module_version" rm -rf "${source_tree:?}/$module-$module_version" fi # We are already installed, just return. case $from in "$source_tree/$module-$module_version") return ;; "$dkms_tree/$module/$module_version/source") return ;; "$dkms_tree/$module/$module_version/build") return ;; esac mkdir -p "$source_tree/$module-$module_version" cp -fr "$from"/* "$source_tree/$module-$module_version" } # This code used to be in dkms_autoinstaller. # Moving it into the main dkms script gets rid of a fair amount of duplicate # functionality, and makes it much easier to reinstall DKMS kernel modules # by hand if dkms_autoinstaller is not used. autoinstall() { if [[ -f /etc/dkms/no-autoinstall ]]; then echo "Automatic installation of modules has been disabled." return fi local status local mv local mvka local m local v local k local a local progress local next_depends local -a to_install local -a next_install local -a known_modules local -a installed_modules local -a skipped_modules local -a failed_modules local -A build_depends local -A latest # Walk through our list of installed and built modules, and create # a list of modules and their latest version. while read -r status mvka; do [[ $status ]] || continue IFS='/' read -r m v k a <<< "$mvka" # If the module status is broken there is nothing that can be done if [[ $status = broken ]]; then error "$m/$v is broken! Missing the source directory or the symbolic link pointing to it."\ "Manual intervention is required!" continue fi if [[ ! ${latest[$m]} ]]; then known_modules[${#known_modules[@]}]="$m" latest[$m]="$v" elif [[ ("$(VER "$v")" > "$(VER "${latest["$m"]}")") ]]; then latest["$m"]="$v" fi done <<< "$(module_status)" # Walk through our list of known modules, and create # a list of modules that need to be reinstalled. for m in "${known_modules[@]}"; do v="${latest["$m"]}" # If the module is already installed or weak-installed, skip it. if _is_module_installed "$m" "$v" "${kernelver[0]}" "${arch[0]}"; then installed_modules[${#installed_modules[@]}]="$m" continue fi if module_status_weak "$m" "$v" "${kernelver[0]}" "${arch[0]}" >/dev/null; then installed_modules[${#installed_modules[@]}]="$m" continue fi # If the module does not want to be autoinstalled, skip it. module=$m module_version=$v read_conf_or_die "${kernelver[0]}" "${arch[0]}" "$dkms_tree/$m/$v/source/dkms.conf" if [[ ! $AUTOINSTALL ]]; then continue fi # Otherwise, autoinstall the latest version we have hanging around. to_install[${#to_install[@]}]="$m/$v" build_depends["$m"]="${BUILD_DEPENDS[*]}" done [[ ${#to_install[@]} -eq 0 ]] && return 0 while true; do progress=0 next_install=( ) # Step 1: Remove installed modules from all dependency lists. for m in "${!build_depends[@]}"; do next_depends= for d in ${build_depends[$m]}; do for i in "${installed_modules[@]}" "${skipped_modules[@]}"; do [[ "$d" = "$i" ]] && continue 2 done next_depends+="$d " done build_depends[$m]="${next_depends%% }" done # Step 2: Install modules that have an empty dependency list. for modv in "${to_install[@]}"; do IFS=/ read -r m v <<< "$modv" if [[ ! ${build_depends[$m]} ]]; then is_module_built "$m" "$v" "${kernelver[0]}" "${arch[0]}" || prepare_kernel_and_signing echo "Autoinstall of module $m/$v for kernel ${kernelver[0]} (${arch[0]})" (module="$m" module_version="$v" kernelver="${kernelver[0]}" arch="${arch[0]}" install_module) status=$? if (( status == 0 )); then installed_modules[${#installed_modules[@]}]="$m" progress=$((progress +1)) elif (( status == 77 )); then skipped_modules[${#skipped_modules[@]}]="$m" progress=$((progress +1)) else failed_modules[${#failed_modules[@]}]="$m($status)" fi echo "" else next_install[${#next_install[@]}]="$modv" fi done wait # Step 3: Remove modules that install was attempted for # during Step 2 from the job queue. to_install=( "${next_install[@]}" ) # Step 4: Keep going if at least one module was installed during # this iteration. (( progress > 0 )) || break; done if (( ${#installed_modules[@]} > 0 )); then echo "Autoinstall on ${kernelver[0]} succeeded for module(s) ${installed_modules[*]}." fi if (( ${#skipped_modules[@]} > 0 )); then echo "Autoinstall on ${kernelver[0]} was skipped for module(s) ${skipped_modules[*]}." fi if (( ${#failed_modules[@]} > 0 )); then echo "Autoinstall on ${kernelver[0]} failed for module(s) ${failed_modules[*]}." fi for mv in "${to_install[@]}"; do IFS=/ read -r m v <<< "$mv" echo "$m/$v autoinstall failed due to missing dependencies: ${build_depends[$m]}." done if (( ${#failed_modules[@]} > 0 || ${#to_install[@]} > 0 )); then die 11 "One or more modules failed to install during autoinstall." \ "Refer to previous errors for more information." fi } # This is roughly the inverse action to 'autoinstall'. It is supposed to be # called before upgrade of a kernel to first remove all modules that are # currently built or installed for that kernel to ensure they get rebuilt # by kernel_postinst later on. # Upon initial installation of a kernel this is a no-op. # # Ideally we should only mark them as needing a rebuild instead of removing # them right away, but such functionality is yet to be implemented. kernel_preinst() { local m local v local failed have_one_kernel kernel_prerm # run depmod only once after uninstalling all dkms modules delayed_depmod=1 while IFS='/' read -r m v; do is_module_built "$m" "$v" "${kernelver[0]}" "${arch[0]}" || continue read_conf_or_die "${kernelver[0]}" "${arch[0]}" "$dkms_tree/$m/$v/source/dkms.conf" [[ $AUTOINSTALL ]] || continue echo "dkms: removing module $m/$v for kernel ${kernelver[0]} (${arch[0]})" >&2 (module="$m" module_version="$v" unbuild_module) || failed="$failed $m/$v($?)" done <<< "$(list_module_version_combos)" if [[ -f $dkms_tree/depmod-pending-${kernelver[0]}-${arch[0]} ]]; then rm -f "${dkms_tree:?}/depmod-pending-${kernelver[0]}-${arch[0]}" invoke_command "do_depmod $1" "Running depmod" '' background fi delayed_depmod= # clean leftover empty directories [[ ! -d $install_tree/${kernelver[0]} ]] || find "$install_tree/${kernelver[0]}" -type d -empty -delete [[ ! $failed ]] || die 14 "dkms kernel_preinst for kernel ${kernelver[0]} (${arch[0]}) failed for module(s)$failed." } # A wrapper for 'autoinstall', to be used in combination with 'kernel_prerm'. kernel_postinst() { local m local v local failed have_one_kernel kernel_postinst autoinstall } # This is roughly the inverse action to 'autoinstall'. It is supposed to be # called upon removal of a kernel to also remove all modules (including # those with AUTOINSTALL="") that were built or installed for that kernel. # # Compromise on using 'unbuild' to remove the module when a kernel is being # removed. The 'remove' command is too destructive. The 'uninstall' command # leaves built files around that have no other trigger to 'unbuild' them. # (Triggering 'unbuild' on kernel header removal would not be a good idea # because that would also cause the module to be uninstalled for the kernel, # even though only the headers are being removed.) kernel_prerm() { local m local v local failed have_one_kernel kernel_prerm # run depmod only once after uninstalling all dkms modules delayed_depmod=1 while IFS='/' read -r m v; do [[ $m ]] || continue is_module_built "$m" "$v" "${kernelver[0]}" "${arch[0]}" || continue echo "dkms: removing module $m/$v for kernel ${kernelver[0]} (${arch[0]})" >&2 (module="$m" module_version="$v" unbuild_module) || failed="$failed $m/$v($?)" echo "" done <<< "$(list_module_version_combos)" if [[ -f $dkms_tree/depmod-pending-${kernelver[0]}-${arch[0]} ]]; then rm -f "${dkms_tree:?}/depmod-pending-${kernelver[0]}-${arch[0]}" invoke_command "do_depmod $1" "Running depmod" '' background fi delayed_depmod= # clean leftover empty directories [[ ! -d $install_tree/${kernelver[0]} ]] || find "$install_tree/${kernelver[0]}" -type d -empty -delete [[ ! $failed ]] || die 14 "dkms kernel_prerm for kernel ${kernelver[0]} (${arch[0]}) failed for module(s)$failed." } # Check if a module's dependencies have been updated check_dependencies_updated() { local module=$1 local module_version=$2 # $1 = module # $2 = module version # $3 = kernel version # $4 = arch local deps_updated=0 # Read the module's configuration set_module_suffix "$3" read_conf_strict_or_die "$3" "$4" # Check each dependency for bd in "${BUILD_DEPENDS[@]}"; do # Get the latest version of the dependency local dep_version dep_version=$(module_status "$bd" "*" "$3" "$4" | while read -r status mvka; do [[ $status ]] || continue IFS='/' read -r m v k a <<< "$mvka" echo "$v" done | sort -V | tail -n1) # If dependency is not installed, skip it [[ $dep_version ]] || continue # Check if dependency's version has changed since last build local dep_version_file="$dkms_tree/$module/$module_version/$3/$4/.dep_${bd}" if [[ -f "$dep_version_file" ]]; then local old_version old_version=$(cat "$dep_version_file") if [[ "$old_version" != "$dep_version" ]]; then deps_updated=1 break fi else deps_updated=1 break fi done return $deps_updated } # Check and rebuild all modules with updated dependencies check_and_rebuild_dependent_modules() { # $1 = kernel version # $2 = arch local -a modules_to_rebuild local -a rebuilt_modules local progress=1 # First pass: collect all modules that need rebuilding while read -r status mvka; do [[ $status ]] || continue IFS='/' read -r m v k a <<< "$mvka" # Skip if not built for this kernel/arch [[ "$k" = "$1" && "$a" = "$2" ]] || continue # Read module's configuration by passing module and version of the dependent module) module=$m module_version=$v read_conf_or_die "$1" "$2" # Skip if no BUILD_DEPENDS, BUILD_DEPENDS_REBUILD is not set or --force is passed [[ ${#BUILD_DEPENDS[@]} -eq 0 ]] || [[ -z $BUILD_DEPENDS_REBUILD ]] || [[ $force ]] && continue # Check if dependencies have been updated if ! check_dependencies_updated "$m" "$v" "$1" "$2"; then modules_to_rebuild+=("$m/$v") fi done <<< "$(module_status)" # Second pass: rebuild modules in dependency order while (( progress > 0 )); do progress=0 local -a next_rebuild # Remove already rebuilt modules from dependency lists for mv in "${modules_to_rebuild[@]}"; do IFS=/ read -r m v <<< "$mv" module=$m module_version=$v read_conf_or_die "$1" "$2" # Check if all dependencies are satisfied # shellcheck disable=SC2034 local can_rebuild=1 for bd in "${BUILD_DEPENDS[@]}"; do local dep_found=0 for rm in "${rebuilt_modules[@]}"; do IFS=/ read -r dm <<< "$rm" [[ "$dm" = "$bd" ]] && dep_found=1 && break done if (( ! dep_found )); then can_rebuild=0 break fi done if (( ! can_rebuild )); then module=$m module_version=$v echo "" echo "Rebuilding module $m/$v due to updated dependencies" echo "" do_uninstall "$1" "$2" do_unbuild "$1" "$2" if do_build; then do_install rebuilt_modules+=("$m/$v") progress=1 fi else next_rebuild+=("$m/$v") fi done modules_to_rebuild=("${next_rebuild[@]}") done # Report any modules that couldn't be rebuilt if (( ${#modules_to_rebuild[@]} > 0 )); then echo "Warning: The following modules could not be rebuilt due to dependency cycles:" for mv in "${modules_to_rebuild[@]}"; do echo " $mv" done fi } ############################# #### #### #### Program Starts Here #### #### #### ############################# # Ensure files and directories we create are readable to anyone, # since we aim to build as a non-root user umask 022 # Unset environment variables that may interfere with the build unset CC CXX CFLAGS CXXFLAGS LDFLAGS # Set important variables # shellcheck disable=SC2034 # not used now, might use later current_kernel=$(uname -r) current_os=$(uname -s) running_distribution=$(distro_version) || exit dkms_tree="/var/lib/dkms" source_tree="/usr/src" install_tree="@MODDIR@" tmp_location=${TMPDIR:-/tmp} verbose="" symlink_modules="" # Set compression defaults compress_gzip_opts="" compress_xz_opts="--check=crc32 --lzma2=dict=1MiB" compress_zstd_opts="-q --rm -T0" # Check that we can write temporary files tmpfile=$(mktemp_or_die) echo "Hello, DKMS!" > "$tmpfile" if [[ "$(cat "$tmpfile")" != "Hello, DKMS!" ]]; then warn "dkms will not function properly without some free space in \$TMPDIR ($tmp_location)." fi rm -f "${tmpfile:?}" # These can come from the environment or the config file # shellcheck disable=SC1091 [[ ! ${ADDON_MODULES_DIR} && -e /etc/sysconfig/module-init-tools ]] && . /etc/sysconfig/module-init-tools addon_modules_dir="${ADDON_MODULES_DIR}" # Source in configuration not related to signing read_framework_conf "$dkms_framework_nonsigning_variables" # Clear out command line argument variables module="" module_version="" template_kernel="" conf="" kernel_config="" kconfig_fromcli="" archive_location="" kernel_source_dir="" ksourcedir_fromcli="" action="" force="" force_version_override="" binaries_only="" source_only="" all="" module_suffix="" module_uncompressed_suffix="" module_compressed_suffix="" rpm_safe_upgrade="" declare -a directive_array=() kernelver=() arch=() weak_modules_add='' weak_modules_remove='' last_mvka='' last_mvka_conf='' try_source_tree='' die_is_fatal="yes" no_depmod="" delayed_depmod="" prepared_kernel="none" action_re='^(remove|(auto|un)?install|match|mktarball|(un)?build|add|status|ldtarball|generate_mok|kernel_(preinst|postinst|prerm))$' # Parse command line arguments while (($# > 0)); do case $1 in --module*|-m) read_arg _mv "$1" "$2" || shift # shellcheck disable=SC2154 parse_moduleversion "$_mv" ;; -v) read_arg module_version "$1" "$2" || shift ;; --kernelver*|-k) read_arg _ka "$1" "$2" || shift # shellcheck disable=SC2154 parse_kernelarch "$_ka" ;; --templatekernel*) read_arg template_kernel "$1" "$2" || shift ;; -c) read_arg conf "$1" "$2" || shift ;; --quiet|-q) exec >/dev/null 2>&1 ;; --version|-V) echo "@RELEASE_STRING@" exit 0 ;; --no-initrd) # This is an old option, consume and warn deprecated "--no-initrd" ;; --no-clean-kernel) # This is an old option, consume and warn deprecated "--no-clean-kernel" ;; --no-prepare-kernel) # This is an old option, consume and warn deprecated "--no-prepare-kernel" ;; --binaries-only) binaries_only="binaries-only" ;; --source-only) source_only="source-only" ;; --force) force="true" ;; --force-version-override) force_version_override="true" ;; --all) all="true" ;; --verbose) verbose="true" ;; --rpm_safe_upgrade) rpm_safe_upgrade="true" ;; --dkmstree*) read_arg dkms_tree "$1" "$2" || shift ;; --sourcetree*) read_arg source_tree "$1" "$2" || shift ;; --installtree*) read_arg install_tree "$1" "$2" || shift ;; --symlink-modules) symlink_modules="true" ;; --config*) read_arg kernel_config "$1" "$2" || shift kconfig_fromcli="true" ;; --archive*) read_arg archive_location "$1" "$2" || shift ;; --arch*|-a) read_arg _aa "$1" "$2" || shift # shellcheck disable=SC2154 arch[${#arch[@]}]="$_aa" ;; --kernelsourcedir*) read_arg kernel_source_dir "$1" "$2" || shift ksourcedir_fromcli="true" ;; --directive*) read_arg _da "$1" "$2" || shift # shellcheck disable=SC2154 directive_array[${#directive_array[@]}]="$_da" ;; --no-depmod) no_depmod="true" ;; --modprobe-on-install) modprobe_on_install="true" ;; --debug) PS4='${BASH_SOURCE}@${LINENO}(${FUNCNAME[0]}): ' export PS4 set -x ;; -j) read_arg parallel_jobs "$1" "$2" || shift ;; --help|-h) show_usage exit 0 ;; -*) error "Unknown option: $1" show_usage exit 2 ;; *) if [[ $1 =~ $action_re ]]; then [[ $action ]] && die 4 "Cannot specify more than one action." action="$1" # Add actions to the action list elif [[ -f $1 && $1 = *dkms.conf ]]; then try_source_tree="${1%dkms.conf}./" # Flag as a source tree elif [[ -d $1 && -f $1/dkms.conf ]]; then try_source_tree="$1" # ditto elif [[ -f $1 ]]; then archive_location="$1" # It is a file, assume it is an archive. elif [[ ! $module ]]; then parse_moduleversion "$1" # Assume it is a module/version pair. else warn "I do not know how to handle $1." fi ;; esac shift done # Sanity checking # Error out if binaries-only is set and source-only is set if [[ $binaries_only && $source_only ]]; then die 8 "You have specified both --binaries-only and --source-only." \ "You cannot do this." fi # Error if # of arches doesn't match # of kernels if (( ${#kernelver[@]} != ${#arch[@]} && \ ${#arch[@]} > 1 )); then die 1 "If more than one arch is specified on the command line, then there" \ "must be an equal number of kernel versions also specified (1:1 relationship)." fi # Check that kernel version and all aren't both set simultaneously if [[ ${#kernelver[@]} -gt 0 && $all ]]; then die 2 "You cannot specify a kernel version and also specify" \ "--all on the command line." fi # Check that arch and all aren't both set simultaneously if [[ ${#arch[@]} -gt 0 && $all ]]; then die 3 "You cannot specify an arch and also specify" \ "--all on the command line." fi # Default to -j parallel_jobs=${parallel_jobs:-$(get_num_cpus)} # Make sure we're not passing -j0 to make; treat -j0 as just "-j" [[ "$parallel_jobs" = 0 ]] && parallel_jobs="" # Require explicit --kernelver argument [[ $action =~ kernel_(preinst|postinst|prerm) ]] && have_one_kernel "$action" setup_kernels_arches "$action" # Since initramfs/initrd rebuild is not requested, skip it with Redhat's weak-modules if [[ ! $NO_WEAK_MODULES ]]; then case "$running_distribution" in rhel*) weak_modules_add='/usr/sbin/weak-modules --no-initramfs --add-modules' weak_modules_remove='/usr/sbin/weak-modules --no-initramfs --remove-modules' ;; sles* | suse* | opensuse*) # shellcheck disable=SC2016 weak_modules_add='/usr/lib/module-init-tools/weak-modules2 --add-kernel-modules ${kernelver}' # shellcheck disable=SC2016 weak_modules_remove='/usr/lib/module-init-tools/weak-modules2 --remove-kernel-modules ${kernelver}' ;; *) ;; esac fi # Execute post-transaction command if set and log its output execute_post_transaction() { # Blank the log file before starting : > "$dkms_tree/post_transaction.log" # Lazy source in post_transaction related configuration read_framework_conf "$dkms_framework_post_transaction" invoke_command "$post_transaction" "Executing post-transaction command" "$dkms_tree/post_transaction.log" background } case "$action" in remove | unbuild | uninstall) check_module_args "$action" module_is_broken_and_die module_is_added_or_die if [[ $action = uninstall ]]; then check_root else check_rw_dkms_tree fi "${action}_module" ret=$? # Execute post_transaction command if set if [[ $ret -eq 0 && -n "$post_transaction" ]]; then execute_post_transaction fi exit $ret ;; add | build | install) check_all_is_banned "$action" # TODO: fix/enable --all [[ $action != add ]] && module_is_broken_and_die if [[ $action = install ]]; then check_root else check_rw_dkms_tree fi "${action}_module" ret=$? # Execute post_transaction command if set if [[ $ret -eq 0 && -n "$post_transaction" && $action = install ]]; then execute_post_transaction fi exit $ret ;; autoinstall) have_one_kernel "$action" check_root && autoinstall ret=$? # Execute post_transaction command if set if [[ $ret -eq 0 && -n "$post_transaction" ]]; then execute_post_transaction fi exit $ret ;; match) check_root && have_one_kernel "match" && run_match ;; mktarball) check_module_args mktarball module_is_broken_and_die module_is_added_or_die make_tarball ;; status) show_status ;; ldtarball) # Make sure they're root if we're using --force if [[ $(id -u) != 0 ]] && [[ $force = true ]]; then die 1 "You must be root to use this command with the --force option." fi load_tarball && add_module ;; generate_mok) read_framework_conf "$dkms_framework_signing_variables" prepare_mok ;; kernel_preinst | kernel_postinst | kernel_prerm) check_root && have_one_kernel "$action" && "$action" ;; *) error "Unknown action specified: \"$action\"" show_usage ;; esac # vim: et:ts=4:sw=4 dkms-3.2.0/dkms.service.in000066400000000000000000000004341500670340200153750ustar00rootroot00000000000000[Unit] Description=Builds and install new kernel modules through DKMS Documentation=man:dkms(8) Before=network-pre.target graphical.target [Service] Type=oneshot RemainAfterExit=true ExecStart=@SBINDIR@/dkms autoinstall --verbose --kernelver %v [Install] WantedBy=multi-user.target dkms-3.2.0/dkms.zsh-completion.in000066400000000000000000000111561500670340200167130ustar00rootroot00000000000000#compdef dkms # Based on the completion from the zsh-users/zsh repository. local curcontext="$curcontext" ign cmds opts ret=1 local -a state line expl args subcmds dirs local -A opt_args subcmds=( 'add:add a module/version combination to the tree for builds and installs' 'remove:remove a module from the tree' 'build:compile a module for a kernel' 'unbuild:undoes the build of a module' "install:install a build module for it's corresponding kernel" 'uninstall:uninstall a module for a kernel' 'autoinstall:try to install the latest revision of all modules that have been installed for other kernel revisions' 'match:install every module that is installed for a template kernel for another kernel' 'mktarball:tar up files in the DKMS tree for a specific module' 'ldtarball:extract a tarball created with mktarball into the DKMS tree' 'status:display the current status of modules, versions and kernels within the tree' 'generate_mok:generate the MOK keys outside of the first build' ) args=( '(--all)*'{-a,--arch}'[specify system architecture]:architecture:->architectures' '(1)-m[specify module]:module:->modules' '(1)-v[specify module version]:version' {-q,--quiet}'[suppress output]' '*--directive=:directive' '--dkmstree=:path:_directories' '--installtree=:path:_directories' '--sourcetree=:path:_directories' '--force-version-override' '1: : _describe -t commands command subcmds' ) cmd=${${${subcmds%%:*}:*words}[1]} if [[ -n $cmd ]]; then curcontext="${curcontext%:*}-$cmd:" else # Exclude sub-commands based on any options specified so far. # shellcheck disable=SC1073,SC1058,SC1072,SC1009 # for loop too long TODO: fix for cmds opts in \ '(remove|build|install|uninstall|match|status|mktarball)' 'k' \ '(add|remove)' '-_safe_upgrade' \ 'mktarball' '-(source|binary)-only' \ '(match|build)' '(k|-no-(prepare|clean)-kernel|-kernelsourcedir)' \ '(|un)install' '-no-(depmod|initrd)' \ '(add|build|install|ldtarball)' '-force' \ 'match' '-templatekernel' \ '(mktarball|ldtarball)' '-archive' \ '(match|build)' '(j*|-no-(prepare|clean)-kernel|-kernelsourcedir)' \ '(remove|build|install|status|mktarball)' '-all' \ 'build' '-config' do [[ -n ${(M)words:#-${~opts}*} ]] && subcmds=( ${(M)subcmds:#${~cmds}:*} ) done args+=( '(1 -)'{-V,--version}'[display version information]' ) ign='!' # hide some uncommon options but handle their arguments fi case $cmd in remove|build|install|uninstall|mktarball|status) args+=( ': :->modules' ) ;| |remove|(un|)build|install|uninstall|match|status|mktarball) args+=( '(--all)*-k[specify kernel version]:kernel:->kernels' ) ;| |add|remove) args+=( "${ign}--rpm_safe_upgrade" ) ;| |(mk|ld)tarball) args+=( "${ign}--archive=:tarball:_files -g '*.tar(-.)'" ) ;| |mktarball) args+=( "${ign}(--source-only --binaries-only)--"{source,binaries}-only ) ;| |match|build) args+=( # TODO: check ignore needed in absence of parameters "${ign}--no-prepare-kernel" "${ign}--no-clean-kernel" '--kernelsourcedir=:directory:_directories' "${ign}-j+[specify maximum number of jobs to use when building]:jobs" ) ;| |(|un)install) args+=( "${ign}--no-depmod" "${ign}--no-initrd" ) ;| |add) args+=( '-c[specify location of dkms.conf file]:location:_files' ) ;| |remove|(un|)build|install|status) args+=( '(-a --arch -k)--all[specify all relevant kernels/arches]' ) ;| |build) args+=( "${ign}--config=:kernel config file:_files" ) ;| |add|build|install|ldtarball) args+=( '--force[force overwriting of extant files]' ) ;| |match) args+=( "${ign}--templatekernel=:kernel:->kernels" ) ;| add) args+=( '3:path:_directories' '4:tarball:_files -g "*.tar(-.)"' ) ;; install) args+=( '3:rpm file:_files -g "*.rpm(-.)"' ) ;; generate_mok) args=() ;; esac _arguments -C $args && ret=0 case $state in modules) dirs=( ${(e)opt_args[--dkmstree]:-/var/lib/dkms}/*/*(/) ) dirs=( ${${(M)dirs%/*/*}#/} ) _description modules expl module _multi_parts -i "$expl[@]" / dirs && ret=0 ;; kernels) if compset -P 1 '*/'; then _description architectures expl architecture compadd "$expl[@]" @MODDIR@/$IPREFIX/build/arch/*(/:t) && ret=0 else compset -S '/*' dirs=( @MODDIR@/*(/:t) ) _description -V kernels expl kernel compadd "$expl[@]" -r "/ \t\n\-" ${(on)dirs} && ret=0 fi ;; architectures) _description architectures expl architecture compadd "$expl[@]" /lib/modules/$(uname -r)/build/arch/*(/:t) && ret=0 ;; esac return ret dkms-3.2.0/dkms_apport.py000077500000000000000000000077221500670340200153570ustar00rootroot00000000000000#!/usr/bin/env python3 # # Dynamic Kernel Module Support (DKMS) # Copyright (C) 2009 Dell, Inc. # by Mario Limonciello # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # import apport from apport.hookutils import * import sys import subprocess, optparse from datetime import datetime optparser = optparse.OptionParser('%prog [options]') optparser.add_option('-m', help="Specify the DKMS module to find the package for", action='store', type='string', dest='module') optparser.add_option('-v', help="Specify the DKMS version to find the package for", action='store', type='string', dest='version') optparser.add_option('-k', help="Specify the kernel version", action='store', type='string', dest='kernel') options=optparser.parse_args()[0] if not options.module or not options.version: sys.stderr.write('ERROR (dkms apport): both -m and -v are required\n') sys.exit(2) package=packaging.get_file_package('/usr/src/' + options.module + '-' + options.version) if package is None: sys.stderr.write('ERROR (dkms apport): binary package for %s: %s not found\n' % (options.module,options.version)) sys.exit(1) if options.kernel: # TODO: Ubuntu specific kernel_package = "linux-headers-" + options.kernel supported_kernel = True try: supported_kernel = apport.packaging.is_distro_package(kernel_package) except ValueError as e: if str(e) == 'package %s does not exist' % kernel_package: supported_kernel = False if not supported_kernel: sys.stderr.write('ERROR (dkms apport): kernel package %s is not supported\n' % (kernel_package)) sys.exit(1) make_log=os.path.join('/var','lib','dkms',options.module,options.version,'build','make.log') report = apport.Report('Package') try: version = packaging.get_version(package) except ValueError: version = '(not installed)' if version is None: version = '(not installed)' report['Package'] = '%s %s' % (package, version) try: report['SourcePackage'] = apport.packaging.get_source(package) except ValueError: sys.stderr.write('ERROR (dkms apport): unable to determine source package for %s\n' % package) sys.exit(3) if report['SourcePackage'] == 'fglrx-installer': fglrx_make_log = os.path.join('/var','lib','dkms',options.module,options.version,'build','make.sh.log') attach_file_if_exists(report, fglrx_make_log, 'FglrxBuildLog') report['PackageVersion'] = version report['Title'] = "%s %s: %s kernel module failed to build" % (package, version, options.module) attach_file_if_exists(report, make_log, 'DKMSBuildLog') if 'DKMSBuildLog' in report: this_year = str(datetime.today().year) if 'Segmentation fault' in report['DKMSBuildLog']: sys.stderr.write('ERROR (dkms apport): There was a segmentation fault when trying to build the module\n') sys.exit(1) for line in report['DKMSBuildLog'].split('\n'): if ': error:' in line: report['DuplicateSignature'] = 'dkms:%s:%s:%s' % (package, version, line.strip()) break if options.kernel: report['DKMSKernelVersion'] = options.kernel try: with apport.fileutils.make_report_file(report) as f: report.write(f) except (IOError, OSError) as e: apport.fatal('Cannot create report: ' + str(e)) dkms-3.2.0/dkms_autoinstaller.in000066400000000000000000000023501500670340200167030ustar00rootroot00000000000000#!/bin/sh # # dkms_autoinstaller - A service to automatically install DKMS modules for new kernels. # # chkconfig: 345 04 04 # description: Compiles and install kernel modules automatically for new \ # kernels at boot. ### BEGIN INIT INFO # Provides: dkms_autoinstaller dkms # Default-Start: 3 4 5 # Default-Stop: 0 1 2 6 # Required-Start: $local_fs # Required-Stop: $local_fs # Short-Description: DKMS kernel modules installer service # Description: A service to automatically install DKMS modules for new kernels. ### END INIT INFO exec="@SBINDIR@/dkms" MODDIR="@MODDIR@" test -f $exec || exit 0 case "$1" in start) if [ -n "$2" ]; then kernel="$2" else kernel=$(uname -r) fi if [ ! -d "$MODDIR/$kernel/build/include" ]; then echo "Automatic installation of modules for kernel $kernel was skipped since the kernel headers for this kernel do not seem to be installed." else dkms autoinstall --kernelver "$kernel" res=$? test $res = 0 fi ;; stop|restart|force-reload|status|reload) # There is no stop action, this and the 04 priority during stop is # added to make RHEL chkconfig happy. # Ignore others on debian/ubuntu too ;; *) echo "Usage: $0 {start}" exit 2 esac dkms-3.2.0/dkms_common.postinst.in000066400000000000000000000205501500670340200171710ustar00rootroot00000000000000#!/bin/sh # Copyright (C) 2002-2005 Flavio Stanchina # Copyright (C) 2005-2006 Aric Cyr # Copyright (C) 2007 Mario Limonciello # Copyright (C) 2009 Alberto Milone set -e MODDIR="@MODDIR@" _get_kernel_dir() { KVER=$1 DIR="$MODDIR/$KVER/build" echo "$DIR" } _check_kernel_dir() { DIR=$(_get_kernel_dir "$1") test -e "$DIR/include" return $? } # Check the existence of a kernel named as $1 _is_kernel_name_correct() { if [ -e "$MODDIR/$1" ]; then echo yes else echo no fi } # Get the most recent kernel on Debian based systems. This keeps # into account both the version and the ABI. If the current kernel # is the most recent kernel then the function will print a null string. _get_newest_kernel_debian() { NEWEST_KERNEL= NEWEST_VERSION= NEWEST_ABI= for kernel in /boot/config-*; do [ -f "$kernel" ] || continue KERNEL=${kernel#*-} KERNEL_VERSION=${KERNEL%%-*} ABI=${KERNEL#*-} ABI=${ABI%%-*} if [ -z "$NEWEST_KERNEL" ]; then # The 1st time get a version which is bigger than $1 COMPARE_TO=$1 else # Get the biggest version COMPARE_TO="$NEWEST_VERSION-$NEWEST_ABI" fi # if $kernel is greater than $COMPARE_TO if [ "$(dpkg --compare-versions "$KERNEL_VERSION-$ABI" ge "$COMPARE_TO" && echo "yes" || \ echo "no")" = "yes" ]; then NEWEST_KERNEL=$KERNEL NEWEST_VERSION=$KERNEL_VERSION NEWEST_ABI=$ABI fi done echo "$NEWEST_KERNEL" } # Get the most recent kernel in Rhel based systems. _get_newest_kernel_rhel() { rpm -q --qf="%{VERSION}-%{RELEASE}.%{ARCH}\n" --whatprovides kernel | tail -n 1 } # Get the newest kernel on Debian and Rhel based systems. get_newest_kernel() { NEWEST_KERNEL= # Try Debian first as rpm can be installed in Debian based distros if [ -e /usr/bin/dpkg ]; then # If DEB based CURRENT_VERSION=${CURRENT_KERNEL%%-*} CURRENT_ABI=${CURRENT_KERNEL#*-} # shellcheck disable=SC2034 # not used now, might use it later CURRENT_FLAVOUR=${CURRENT_ABI#*-} CURRENT_ABI=${CURRENT_ABI%%-*} NEWEST_KERNEL=$(_get_newest_kernel_debian "$CURRENT_VERSION-$CURRENT_ABI") elif command -v rpm >/dev/null 2>&1; then # If RPM based NEWEST_KERNEL=$(_get_newest_kernel_rhel) fi # Make sure that kernel name that we extracted corresponds to an installed # kernel if [ -n "$NEWEST_KERNEL" ] && [ "$(_is_kernel_name_correct "$NEWEST_KERNEL")" = "no" ]; then NEWEST_KERNEL= fi echo "$NEWEST_KERNEL" } NAME=$1 VERSION=$2 TARBALL_ROOT=$3 ARCH=$4 UPGRADE=$5 if [ -z "$NAME" ] || [ -z "$VERSION" ]; then echo "Need NAME, and VERSION defined" echo "ARCH is optional" exit 1 fi if [ -f /etc/dkms/no-autoinstall ]; then echo "autoinstall for dkms modules has been disabled." exit 0 fi # read framework configuration options for fwcf in /etc/dkms/framework.conf /etc/dkms/framework.conf.d/*.conf ; do if [ -f "$fwcf" ] && [ -r "$fwcf" ]; then # shellcheck disable=SC1090 . "$fwcf" fi done # shellcheck disable=SC2012 # suggests to use find here instead, but that is not equivalent KERNELS=$(ls -dv "$MODDIR"/*/build 2>/dev/null | sed 's|'"$MODDIR"'/\(.*\)/build|\1|' || true) CURRENT_KERNEL=$(uname -r) #We never want to keep an older version side by side to prevent conflicts if [ -e "/var/lib/dkms/$NAME/$VERSION" ]; then echo "Removing old $NAME/$VERSION DKMS files..." dkms remove -m "$NAME" -v "$VERSION" --all fi #Load new files, by source package and by tarball if [ -f "$TARBALL_ROOT/$NAME-$VERSION.dkms.tar.gz" ]; then if ! dkms ldtarball --archive "$TARBALL_ROOT/$NAME-$VERSION.dkms.tar.gz"; then echo "" echo "" echo "Unable to load DKMS tarball $TARBALL_ROOT/$NAME-$VERSION.dkms.tar.gz." echo "Common causes include: " echo " - You must be using DKMS 2.1.0.0 or later to support binaries only" echo " distribution specific archives." echo " - Corrupt distribution specific archive" echo "" echo "" exit 2 fi elif [ -d "/usr/src/$NAME-$VERSION" ]; then echo "Loading new $NAME/$VERSION DKMS files..." dkms add -m "$NAME" -v "$VERSION" > /dev/null fi dkms_conf="/var/lib/dkms/$NAME/$VERSION/source/dkms.conf" autoinstall=$(bash -c 'AUTOINSTALL=; . "'"$dkms_conf"'" >/dev/null 2>&1; echo $AUTOINSTALL') if [ -z "$autoinstall" ]; then echo "Not building the $NAME module which does not have AUTOINSTALL enabled." exit 0 fi dkms_conf="/var/lib/dkms/$NAME/$VERSION/source/dkms.conf" autoinstall=$(bash -c 'AUTOINSTALL=; . "'"$dkms_conf"'" >/dev/null 2>&1; echo $AUTOINSTALL') if [ -z "$autoinstall" ]; then echo "Not building the $NAME module which does not have AUTOINSTALL enabled." exit 0 fi # On 1st installation, let us look for a directory # in $MODDIR which matches $(uname -r). If none # is found it is possible that buildd is being used # and that uname -r is giving us the name of the # kernel used by the buildd machine. # # If this is the case we try to build the kernel # module for each kernel which has a directory in # $MODDIR. Furthermore we will have to tell # DKMS which architecture it should build the module # for (e.g. if the buildd machine is using a # 2.6.24-23-xen 64bit kernel). # # NOTE: if the headers are not installed then the # module won't be built, as usual # Here we look for the most recent kernel so that we can # build the module for it (in addition to doing it for the # current kernel). NEWEST_KERNEL=$(get_newest_kernel) if [ -z "$autoinstall_all_kernels" ]; then # If the current kernel is installed on the system or chroot if [ "$(_is_kernel_name_correct "$CURRENT_KERNEL")" = "yes" ]; then if [ -n "$NEWEST_KERNEL" ] && [ "${CURRENT_KERNEL}" != "${NEWEST_KERNEL}" ]; then KERNELS="$CURRENT_KERNEL $NEWEST_KERNEL" else KERNELS=$CURRENT_KERNEL fi # The current kernel is not useful as it's not installed else echo "It is likely that $CURRENT_KERNEL belongs to a chroot's host" # Let's use only the newest kernel if this is not a first installation # otherwise build for all kernels if [ -n "$NEWEST_KERNEL" ] && [ -n "$UPGRADE" ]; then KERNELS="$NEWEST_KERNEL" fi fi fi # Take care of displaying newline separated list echo "Building for $KERNELS" | tr '\n' ',' \ | sed -e 's/,/, /g; s/, $/\n/; s/, \([^,]\+\)$/ and \1/' if [ -n "$ARCH" ]; then echo "Building for architecture $ARCH" fi for KERNEL in $KERNELS; do echo "" dkms_status=$(dkms status -m "$NAME" -v "$VERSION" -k "$KERNEL" ${ARCH:+-a "$ARCH"}) if [ "$(echo "$KERNEL" | grep -c "BOOT")" -gt 0 ]; then echo "Module build and install for $KERNEL was skipped as " echo "it is a BOOT variant" continue fi #if the module isn't yet built, try to build it if [ "$(echo "$dkms_status" | grep -c ": built")" -eq 0 ]; then if [ ! -L "/var/lib/dkms/$NAME/$VERSION/source" ]; then echo "This package appears to be a binaries-only package" echo " you will not be able to build against kernel $KERNEL" echo " since the package source was not provided" continue fi if _check_kernel_dir "$KERNEL"; then echo "Building initial module $NAME/$VERSION for $KERNEL" res=0 dkms build -m "$NAME" -v "$VERSION" -k "$KERNEL" ${ARCH:+-a "$ARCH"} || res=$? case "$res" in 77) # skipped due to BUILD_EXCLUSIVE continue ;; 0) ;; *) exit $res ;; esac dkms_status=$(dkms status -m "$NAME" -v "$VERSION" -k "$KERNEL" ${ARCH:+-a "$ARCH"}) else echo "Module build for kernel $KERNEL was skipped since the" echo "kernel headers for this kernel do not seem to be installed." fi fi #if the module is built (either pre-built or just now), install it if [ "$(echo "$dkms_status" | grep -c ": built")" -eq 1 ] && [ "$(echo "$dkms_status" | grep -c ": installed")" -eq 0 ]; then dkms install -m "$NAME" -v "$VERSION" -k "$KERNEL" ${ARCH:+-a "$ARCH"} fi done # vim: et:ts=4:sw=4 dkms-3.2.0/dkms_framework.conf.in000066400000000000000000000047501500670340200167440ustar00rootroot00000000000000# This configuration file modifies the behavior of DKMS (Dynamic Kernel Module # Support) and is sourced in by DKMS every time it is run. # Additionally to /etc/dkms/framework.conf, any file matching the glob # /etc/dkms/framework.conf.d/*.conf will be loaded as well. # Source Tree Location (default: /usr/src): # source_tree="/usr/src" # DKMS Tree Location (default: /var/lib/dkms): # dkms_tree="/var/lib/dkms" # Install Tree Location (default: @MODDIR@): # install_tree="@MODDIR@" # Temporary folder Location (default: /tmp): # tmp_location="/tmp" # Verbosity setting, will be active if set to a non-null value: # verbose="" # This creates symlinks from the install_tree into the dkms_tree instead of # copying the modules. This preserves some space on the costs of being less # safe. Symlinking will be active if set to a non-null value: # symlink_modules="" # Automatic installation and upgrade for all installed kernels if set to a # non-null value: # autoinstall_all_kernels="" # Location of the sign-file kernel binary. $kernelver can be used in path to # represent the target kernel version. (default: depends on distribution): # sign_file="/path/to/sign-file" # Location of the key and certificate files used for Secure boot. $kernelver # can be used in path to represent the target kernel version. # # NOTE: If any of the files specified by `mok_signing_key` and `mok_certificate` # are non-existent, dkms will re-create both files. # # mok_signing_key can also be a "pkcs11:..." string for PKCS#11 engine, as # long as the sign_file program supports it. # (default: /var/lib/dkms): # mok_signing_key=/var/lib/dkms/mok.key # mok_certificate=/var/lib/dkms/mok.pub # Automatically modprobe the built modules upon successful installation: # modprobe_on_install="true" # Limit the number of jobs run in parallel (default is the number of CPUs) # parallel_jobs=2 # Compression settings DKMS uses when compressing modules. The defaults are # used, for reasonable compression times. One might instead wish to use maximum # compression, at the expense of speed when compressing. # compress_gzip_opts="-6" # compress_xz_opts="--check=crc32 --lzma2=dict=1MiB -6" # compress_zstd_opts="-q --rm -T0 -3" # Command to run at the end of every DKMS transaction, for example after a new # kernel has been installed on the system and all modules have been succesfully # built and installed. # The command listed below is executed with the kernel version passed as a # parameter if set to any non null value: # post_transaction="" dkms-3.2.0/images/000077500000000000000000000000001500670340200137145ustar00rootroot00000000000000dkms-3.2.0/images/mok-key-1.png000066400000000000000000000116761500670340200161470ustar00rootroot00000000000000‰PNG  IHDR® ¦L‰ pHYsÄÄ•+pIDATxœíÝÉn+é}Æá‘Ôp†vOq^$«¬r[‚d•{ÈÞðBrYYIÛmwŸ>ƒD‹YÈPØI±(Eñ}ôâˆ"«>Ùü~ªjª. H5zîÏI @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD›ôÈÙ¸Æóú}Õ¸ª&'ÕÎ^W-ƵxòÁA_s¯Ca\Ísj^£ªùxr5o»ª³ªé¤~ÞÖuÕl 5öNÑÉÕŽÏ'o¯f“Q´³ÇÕÍëzÞœ 1>ègá­œÝ͛U‹vR§ó¶Æõí¼~<Ÿ¼¶¿k&µh_ ´ÂÞ)ÐÍšªf>kÏk:«yÕùéø|>oZÿ q:;x„Q#%y~“Åùhܵó·Uÿq^?¿jßU½©öÀkìû€Qý|rÚµíoþáWuòö¿Fã¿|wý?“æ‡Ï¯?b|ÐË|$IÙݸsúÏïûÓ?Îæ_~þæíbúiv5þû¿ùprþùìÓgóúa 5öN¦>L§õæì—磦{÷íßþÝošúzR¯¯F×CŒúé¨â¼q^u?k›E·øí¯~}v^_Ÿ\}ü4Õ7§è ¡w œœ~?ŸN>\OÏΧ‹YuuºµM7«î|ˆñì”ä´õiV_4õÇóÉ«æìß>N›jÞŸžÎ¯ÛûÞ;®¦ç5™œÔ—ó«y×Í«ªN¦íõépµ}ÌŸ{¼hÞÇx~³šÔÉ»Åô‹v~5úøÕéI;mæWׇ[cï8­o§õŸ³¶Õ›®[ŒO»öú»Iýå¼¾b|ÐK·Ëõ±ð'£r€€ç7©o¦Ó=9¯šŸ&³éìº&ŸNê³úÃ`kìiZ¿´¯Ûêf£«:­v:šÔ7³úãNQp@¤$‡`Z¿ŸÔ׳«nqÚΪ­MÚ·³úýpŸ ètYˆ& š€hR¢Iˆ& š€h.¢åØ\^þäË‹‹ŸÜxóå@+½]øí—ws;†íoß<à¡®£wyiÓ½—Û9ø濺7IoxàÊéù‘n×{;žo_÷­ÍËgC<ãðIØŸu3·xF@Õ'ãAk`Ë] ˤGåæpûíàû“âʃë÷o\¾å©æ× ‡¥ŸäˆõÊón­<\òà¶a;,/ÃI›ï¿ažóÑëç½3žå;ë'p€€csû^¿îHðýÉ`›ià‘Ç•×=ü©ÎQX7Çß9gâ©V´ná·_®üÖý—Çy¿¶ÿÍí›Ï¹?ž¾çdÀq“¡ óGß7ý§šA7xªyhÐùìÐΰ;´ñÀ‹æGëÎÁ‚—°îÚ¿–¶Ã·¶wÿ'}ÂŽ¹¿ú.|‡Álد³òyÑ°)Ç`e÷ ·Ÿ`ÃAý'¹ÿ¾ã·ŸvãGe xB>< €ý´6üÎ}ø…´Yßñ}82pTn÷“/ßRÍÁË'´ï¶“ùÁõ®;ª}g}/rÛ|4ýþxîß¾›åålsNƺû¯Ϻño³ümî¿rT«©êû®ÐMjÒVwyÙUÕÅÅhR£¶Z;àÅ9¨Yð Ïjßó¬ùBÂÔkÏ< ÈÊä{Fwvì?ûx “€ 8×à M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“mòÜà°\^Þ½åââ9Ʊ/·?ïÐ?æååamÉå'z»YÝ튖¿¼ó’»sãò—µ÷ìÐ^?{ø‰Û·›‹‹ÕïÔGf?o¯‡¶ ogÖ=?Å7+Z^ÝòHÌúëÚë‡ãc¯D;üIWÀÐì€ÿwyé7°aÙ¼p€ì`+·¿™Ý?¸¾òXï·o^õÊ…ÜφcÒZùØ;«î»ü•;Ã7,ÿÁ±m¹ý7Ü›¡>¸œå/ý­}Ë…oO¯×ϺûoXŃç:ôz]­ÛÎÕóÅ ½Ø+ÀVnߘîÓ]w¬·ïí›W}ÿÎëƳ³usü#—ûð;ÿî»ü¾ÛÃö¹ÿÝ–sÇ6Ûçf }'³Ý&¿å—J¯×ÏÊû/oŸû°Íó¸ÛóµîõOË^VÛüÛäS½›Ô[ÛA æi-ÿhù=þþCúÒ+íuòü¡€8´ñÀJR€Õz½e¯¼ñÎq÷ÛßWÞÞká¹?å¼”÷ñççͳ¹¼[{ UlY+ÇÓwl;ü,ë²nû¼”×9¤OàÁ=Ëïæën_iÃAÙ§µrÊy)û ^Ê8÷¯ïëg·×Û~yÀpœ+´=„ „“<¥Ûÿ—k®Ê[wû!Ø0å<Õ°‡þñyó&è»ý‡¾?lI ð+O/ßpûíôyû&µ|`ûÛ×Y¾¯3í·|ÓÜp”wËñoãþ¹â}·Ãò€·YκçkÝ·vXΓxp½O¸ü¾¯Ÿ•gøoùúßfùÛ?ï÷GO«©êûÿ\7©I[ÝåeWU£IÚjUhèwÏ}¾;› „'‚áí{ž5s´Ž©x^öÌsÜ\AÀQY¹ÿö-ÿÁõnyYOëÎE°žŽŒਠýý\s€¹çÙy 8b@4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD“M @4)ѤD›ôȨ­îæ7_·ÕI x¡LáM @4)ѤD“M @´.&ìçòòî-]à#—ð\îlŠÿ)nG{àãà‘ß+p;‘\\üéß÷ã`{{yù¨%o³êÇüf#<~;ì1ø^n˜Y8LÇ“CϵærŽÒs¦Àºcç+o_¾ñvgûýEÝYÈÅÅÚo-÷Ái¾×òŸJ¯íÓ÷öÍã_yðâeëÀ–šªYo9‰ÖCSÑ¥­»ýÁ•®ëƒ•3ßÊ1lóS<¸ümrcóûnŸ¶çƒÿÞðöÚtôÑMjÒVwyÙUÕÅÅhR£¶ÚáNïÛß^Ûåå^ðxËSi¯íÐw‹í¼…·œãcŸA€ãs<ç ™›_Ê×íEØÿÕ›ÇÀË%×¹y/³LÃÆÀËåÓ ÚKM¡?PèÉõð–÷_w·'ß>/nƒ°¥Á¯ ØðÁÃ}/Š»óÝuÇη<[~ÝòWêµüm²Íz½˜°¶Þ>ënwt`û¾‚`¬#ø8:ûN—z€`gvtÀ²¸Xþxƒ²K€x‰šþàVÜ^`™€hR¢Iˆ& š€hR¢Iˆ& ZïO×iW“W§ÿò~ö×o~ö»_ÿãÕµíäßÏÛ¯ÖT‘c8‚,²È&ÈbvY[’/$#7#N<ÓÓ×stá¥.Y¨¡æH¤DR¢¨‡üýp›¬zIUóÏ·ªHç¤UîzÀ“h9ä¦å›–@nZ¹i9ä¦å›–@nõ:WUQµñUDõ šÙID_E¿¥ÁÁêZÛ!OPE±ë!@´QF´U=n›.b1­ã‹&&³‡o¸FËËÁ÷ÑTGõ›ñ¬.cÐÌ>Vѵ1i‹ÁÓÏ¡÷\ÌæÚ¢Ûõ ¢oê¶MTñÓ6>Õo¦Ío‹:úæøáÛ­ÑònVDí¬9Šé,Úˆ£auÔ¶Eãÿ^δœ'( ¯Ù½º?*«®ißDüõQ|1n>DœFsùø W_G_Ôîiþê—þoþoYýâÃäoëâûw“wO9<¶ôš’ÍU“‡Ø½ï†ßÎÚOß¾é§×³qõ¯þôrpônvý¶ï¾á-/âr:ÓÑ•E÷á§öÏÿªˆÏë8—“§ žCçXOàyŒWà¸û¤)ú®ÿòÏ5:ŠÏGƒñÕu[ÆÇ›ÓÔ°FËÃïÚi}9™ŽŽ¦ý,ºöeSt³èŽž6x€]óZW ‰ëY¼/âÛ£ú¸ýÏ«iÅÅpØŽÛÿ½FËÇÓ£¨ëA|ÚŽÛ®k#"Óf2|ôõ¼ˆv× 5ÏcìÞ,ê|è§ï›v\^}64Ó¢O®½á-ÆO§ñ7³¦)ã´ëújØ5“¯ëøE_?aäð<ºõÞ` ¿£ ûØÙ½:~2þÁQD;*ëÙt6‰úz?›Å7ÝpeÓø²nNšèfå8†ÑLË:~2‹o×|“:À«ãµ ¯Á4¾ªãóÙ¸ë‡Í,šˆ²nÞÌâ«G?ØÍ©››–@nZ¹i9ä¦å›–@nZ¹yK%{îüüî%gg϶À'.jõÕÝ®hþ×;wíÎ…ó¿¾À8_­óóƒ¾ûóröÜíóøÙÙâ®å6O_Ôë_ÝüHd{™ûÁn™—Æ^5Õ„y9ä`Š ,c^ÎázàxóÙÙÝÏϵœù_·:o^qáŒgá™<>ËÎ$X¶ŠG÷?0žXùqû'8æ娇7ßœ0u§ ÷Øl9 Gò°›%¬[£Íê5Åûƒà~-¼þüãs?ä o²p<ë>η¿Þùö’y9‡bõyö¼ù+?e&}ÿ&ëî3ß`¥kÂýÚöῶñÀk¦åŠ…UÛU0n^ÌïÞÒ*VÌùÂñ¬;¶ î˲›,{|Òrš]¯ËQD¬þ¿~WGÝDw~ÞEÄÙYYGÙDã° M…ÇlØY¶ÈÎmxZlÑ}ì&å° Þ“l—~ö™—@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å[½ëÀs銢¨Ši×ED]ƒ*NÛ˜ìh<ýŽÖ»¯Š­.½Œ£..ª˜F”u]_ º®3á!-goŒŠˆ¦«#†Í 5Ý·eqÝvíŽÆã®ç5ÛêÒ‹ˆ²ì£ÿ´ë»>"ú2úYD±«íÖàé†=QEÓ—ÓhßEtQÔ³ö:¢™õuµ£y•<¯mÿÛ裛DEôe}Ú5M=˜ö³²ÝòþxZΞè¢ëÛˈë¨>®+GM7‹è†í–çs¼Œvë¯ÉFå`ÚõEùI7½ˆ¸nf—U|¶å•ÂóÐröDeÃã·õÕÇ6¢ì&ߟκ¦ÚѼªu¼üYmûïØE]ÅU?Dœ.»é[ÇËÉBËÙmœF¼lN«AÓŽgñé ŽgqÑFµ£Ù7ûœÚ趼†ÙiýîbÒŸÖo›¦ìÇ¿ßD—[^/<-go\ŒŽºéøoþݯþáðäo»ÉOÊ¿îG¿wù“ŒfúC xÃluù_Ÿ^tãÙIüƒ®ú/1ûÃñOÿÛñÉÏ®¯ÌËÉAËÙƒÁdüÍIüüdx=»xûoþôÛ&Ž'ñ®« ȼüym÷¼‡*þÎ(&e|ùËÿðÉàèòMüÑÅÕocø.¦ÛÞÏ@ËÙ³Iﮢ‹Y?¨ê1®£lãÒ¼j_l÷µQÓ¨›èÕ0fíEŒëx×LÛ)ØL 7-€Ü´rÓrÈMË 7-€Ü´rÓrÈMË 7-€Ü|†+lÑùù?Ÿ=uQO\³¸½GÏ5˜Wr¿ 5órØ–›ìýЪù®o¶¨eÿé)K^×óv÷%G{LËa+nC~ÃÔØûØá…l)ç^%Z/íÎŽåù=ðggwHÏ_ùÎ\?½~x9÷^6žÕïÅ£ËyàþÞ3°ûØáEÍD_XÙû—Ï憎¼ûý[¶œuÇó¨;×_¶œîï÷ X‹–@nö±Î'‡Ü´°‹r³^ˆ¹/°%Z[qç<²ç ù¶?æ…?yfçë…ýPD¬þ?PWGÝDw~ÞEÄÙYYGÙDã¯ÃkÜ>~†ëÃïÝZø¶±Xô°‡—¿ì­h1÷Žµ…'®?º¿}­÷ž=ºügÿPØM½Æí‡Ã³áv¨åì Û'Oaûá5Øp;tî{£î£?‰7Óúëˆ8‰Ï'qQWÑ/¼v»äröCÅZ×o—l?ÝvÏIËÙE_ýºi¿mÞDDW}õ›hÚÍâ«÷æ[û¬-ÚõnÐn?[<7-gOÔ1ŒöçeŒ‡£ID”Q—íÏËèû~ñü¬%g/Týp­ë1X¸ý4q½ÂsÒröDSÿ“(š¦‹öêßGĸú—QFôutKšm×é^k×ÝíRÖ‹·ŸæWÛúã*®#¢ˆã¢¸îã5},§åð¢nã½bÅç¯?|ýæ]jó ™ÿ¯ËnµìòÕ-[oú%EDD]£›Š› µœ ŠˆÕÿìꨛèÎÏ»ˆ8;+ë(›hì¨çuXðÉá°²2¢‹"þâ/ÿ2"þÙŸüIô7þÅ®ÆAÙ°³æåQ•]ß½íûYUUQôGE Šòcë{îÉ@Ë¢íê(?FD3DD_ŽûGç’숨«¨¢*ÞöÝ ïUñ6ªˆºÚõ°`%^u²7ÎüR4}ǃø¦>é#bØþÛYûY×N}#-ˆ¾Ž¦™”q4™"¢¾‰IÔá[OIAË"š¾Žbå(Æ1²Ž¢iúÞ¬¯›–s ¾úÙßÈv»–;K^vùêKxvóÈK¾¡ï‰wðÅxÍœûƺ}ê?;Ûb–-yõ5¾L¢nŠxûP¼äç¾,»ƒçç+ CÂ!´nH­­¾¸¶Á>vøAŠ€ÝN ÷ÞSv¹Âãó´âüüÇgÿÛÜ9»ìò¸·Gz{!¹ª…ë]x †´îý¿Úê+]¶}áQðGg!ç`ÙÇΡ[V¦;—]>¤y«›—Eúéë½½áýÓßžrÏé} ÓËÖ+ä2órÝüÔs­[½¼-­t•™ôê«^ñÁ|bzW|¼Ò4à~&oNö~=_7zóHnãñ¼‹?p—_Ïã/̼r¸™=ÏÚ<¯BžÅcç÷ŠûÂ0/‡˜ÕIi9D$ ùçš½ª=íÛ°Ê|ùºWBË9Pó'o¯òì¿ðdï¸w7îí ^x«e—?°Þ;–­÷þåZ8˜Íîïêæ—³ÊÚ—­W¹!"Šu¾²«£n¢;?ï"â쬬£l¢ñ‚€WÅ{“æy4Væù×`ÃíÐf {KÈá@8öÊ‹}ðzh9ìñ†d;ä¦å›–@nŽ—s ¾/ùÙ6/üîÎ._} Ï5’Õoøô1l¶Þ§|‘ùÆ7‡\ÌË9P·Oñ·ß¡¹Õµ¬xùS®¹åÌÓh¼ì³,ðŠŸ#á-‡Oý+Øê‹à)ìc‡U OÜÁ{IËáw¾(óöIÿþ'/¼<^êãY^ïÂ_8žg9½úã0µÕƒºl/úÂÁ?úø¯¶Þ²‰î懛ߛèì¹$ [*‡nYî$^vùüåmT¾_Çû+]e<+Žsá·ž<ýqXq½ Óû@§—­×ŒœC`^Ρ›Ÿb®u«ö”¯#Ûl9«Ì¤W_ÚZ_Ú¶ñûâ+Ø3ZYŸë—½­îΙޯáÞÝŒj³—M«,ùáû; ö’}ìÒw‹Í»Ýá| ßðýðý=§åðO÷@RZ{ò?Jeo¬rMÍÙ{ZΚ?I{•gù…'uÇ\'n—³ðíR O®¾ùë½c~½ Ï·¿3ž J¶p›=«›_Î*kÆû y«oò]uÝùyggee¼*ÞƒÄSØ~Ø© ;+Û–@nZ¹i9ä¦å›–@nZ¹i9{¢*¦ª8º./šbTŬ®êAŒ#º%ÿàGuL뺫¢oÊî:Ú*êˆqU^íz\°ß“Æžhûãˆã2ŠÓágM{ÝÆQôMÄ›"š…×ï_x|¼nM¼‰vÑ•Uœ«8n£m»ÂË>R0/gO ‹®¬bßµã¾m?Tq'WÊhþÛõxym¾‹“iUÖm3i'ãi\Tƒ~XxÉGæåì‰i_F;«¢Êf\vñ1®û">m—ÌËÍ·˜WÄgýõ7]×ŬªèÛYÛz†$ óröÄhtÅW££f<¾÷M\ Ú·Gñ6ªvñ?˜3ŠOêîèM´£úÝøº;:¾ˆøntt´ëqÁJ¼êdOL&MŒ>½3ë~Q ¯ùŸþáú×_¼ÿuq1\xýÆsæ”'¿ùí‡ëwGÔõÿk6ùû—×ÿ'†?›Œ'»¬DËÙ£²LßG|ñ¯ÿlRÆè*¾¯«£h¿j¢Xr ??ªãcTŸ5í—'ñI׳fT]LìÁ!Og쉾»Œ˜Åñ÷ãëÏ"¾‹£7ͬ,ãóåÇÅÍËùQŸv]'¯®êˆ:ŽšW}ÛFŒv=4xœ–³'¦7Ϲ×ï#ºˆObÑ9_ÕtÑFquúÃïã*"¦ž!I¹o›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹Õë\¹l¢»ùáæ÷&:¯`·”rÓrÈMË 7-€Ü´rÓrÈMË 7-€Ü´rÓrÈMË 7-€Ü´rÓrÈMË 7-€Ü´rÓrÈMË 7-€Ü´rÓrÈMË 7-€Ü´rÓrÈMË 7-€Ü´rÓrÈMË ·zõ«V1ì¢>þ÷‹Ù?>ýä·¿úï£kšú5Ÿ-¹… Ìëv=€WmR_•³ŸôÕ¬]\øÃ7£ÿz5ùƒ2¾ôÙ³ˆ8_u%å,ºQÄøͨºš\ôñæmùnÒ}ÓÄpáÕÛ5ÆÏþ«v=€W®ˆö¤|{Ù}qu4øürÖF «ÑÇvrüð ט—G9‰ââøø÷..o˸˜T&]e±øú]¿ÆÂÙwí²í€ÝpR}èºè㧗³áÉis5þmÏØòæg¿¹¾¸ŒxÑÃv2ýñ“è&Kn`&Æœ®Ùõ^¹ÓÉì˨Ñ´íÕåuÄi´ŸE\<|³uZÓáàítö]ÄwMÄ(ŠOëò¤hïMŸ…y9?¬·±œ&ê¾øl8è§Í‡ˆ*¢>mgý£Ç¬×zz½*º“*Þ÷E_};EMûuÄ`ós0¼¶xÌ×Ѧ×EU~ÒuQDQtuWÞlóØ«ï'í7uôo«ò(bZÑ÷ƒ(–œ¯Þ;o™9˶""¢,F]M×úbÚ÷&mSDÑÇû‡o¸FËÛöïE\eÑ÷'m;ŽAÑ7³"Þýtáõ•œy¥×vêú2Ši9uÓ.â8Š.ú²wß=|õö±_FDßõ7?ĬŒõ1ëcÙùÉö©ò£névÀ.úº›¶mÄ,ú"¢4ä±VËë5Ûì¬eæ­»ýš»¹FË›òl½eۥʜÆár€‡u+zÛïZ£åE¿ÞûÅ{ŸüÆœu·€C³ñÞËuŽ—?þ7XÎö°ë´¼XóÜ¥ÞñQ欻ýšM³¹FËû~Ýçb-çGëo?¬d–—Åz'³ùjæ­»ýš»¹F˵™§°ýl‰÷ @nZ¹i9ä¦å›–@nZ¹i9ä¶Îw«lopð^â»UúboÖòŸûýÆß’lË-ØË[3Ûô†k´|Vú@mØšM¿‚j–WÝÚp%ÀcÚØðXö-o‹éfë×oøFñuæå}µÙ:€Gµ›žÈ¾Î¼|ów¾Ûâsß 7-€Ü´rÓrÈMË ·ÿ0‹z<ãùIEND®B`‚dkms-3.2.0/images/mok-key-3.png000066400000000000000000000121321500670340200161350ustar00rootroot00000000000000‰PNG  IHDR£÷ ÁC pHYsÄÄ•+ IDATxœíÝYo[éyÀñçl$%ÛcÏL2À4ƒ´hÚ‹Þ4ýL Z èW(zÓA€ E>Vn´M2é’Lfñ¢…äÙzáԣȢǤ¹H~?øB¢y_ÿgyUDœTyè;¤ô™Ò@fJ™)=d¦ô™Ò@fJ™)=d¦ô™Ò@fJ™)=d¦ôY½þ"Ó*ª>>¨"¢n¢k#Æ*Æ­ÖÕ{òª(=ˆ>ʈ¾ªç}7DL#–u|»‹ED»Ù ×.}Ù<‹®šÕçm]FÓµ/ªúXôE³Ù`›FïÔl®/†C"Æ®ŽIßE÷ñbV?\v¿+껣ÍÖ·v釶ˆ(ú¶›Å²>b6©f}_t~C¸»ô¼ƒ²°¥ÈáÕ㬬†®ñ«Y|{Þ=xÝùæ+\w2¾]O†®ûù?ýè/š‡ÿ]Vß{¾øߺxöxñxãAÀ¶ô¥-N6W ¦.qxO'_µýû<——í¼ú‡¿9ofÛËG}<Ûl…k—¾ˆóå2L¿;+‹áùÇûƒŸñaÇór±Ù`›g‘xÞǸŽ†÷ºbÆÏ~ôãé,>œ6ó‹Ë¾Œ/§Çm`íÒ7“§ý²>_,§³åØÆ“±ìŠ¡a¶Ùn [ŠÜ]\¶ñ¤ˆ¯fõQ1ýÏ‹eÅÙdÒÏ7=v¾véçËYÔuï÷ó~úˆˆfÙ-&okÀVõ‡wš÷1¯:šçãòI×ÏË‹&M·,úùâbã®]úI|¼Œÿj»®ŒÃ0V“¡[|QÇ÷úøbãAÀ¶ ›\8 ¿W†£÷^-—ÿÑÌ"úiY·ËvõeŸ´ñå¦+\Ó2>«»ã.†¶œÇ$ºeYÇGm|µÑ¥ù·ˆ-Enƒe|^LJí|']]DYwÛø|ã»3Ñ2SzÈLé 3¥€Ì”2SzÈLé 3Â>œž~ýõÉÉ|{õö=èµ5¯º}Õ^Ýíê·×~„k7^ýöÚÏ»õx3ûô°?''¿ïÜ«Ú½ºeG·Öí«¼ìôÕZ¿Jø«ñ_Û&xýEéáðRVðÍíöFéáV¸åE¼ñtp'8OvzzÉðo<á}m‘WnɃz¸=ìÓÃ!­š×vãùï×o_u¾|»®Í-Xk)àà”i³î‚Ûç€?ÜJ–rßww€u)=d¦ôp+äÛýµ[·„ÒÃáÉ!°;®²ƒýyýb¹·lüÕû_=¯ÿrU«>kvÕR«n{«wÕcS¨ˆX÷Wp¨£îb8="â䤬£ì¢sx¶aË•gÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”v©|1F³<Šb}Äòýòñ4."†ÿî››Ÿ‡I\¾W¼±hby\ÔQµQU_z´p'Õ‡¤6|gR¶Ëþ×ÿü¯U6ŸÎ›?oŸ}züpz´¬n¾{Œ{àa•qóópÖLç—ÏÊŸ¼7~º8ò÷÷iÜõŸDœïy„€ÒÃͪjÞ>›ýYÕUð×?{P—ËnÒŽ7ý¾íÔ—+¶l&e]Äó®üÕx|\_4ÅŸ´q6-§‹ûöÁ6(=ìмQÎçÃ{Ç“Åb1Œ_´]Ä,b±b‰ûuBmX±m3š2 ÃòÑñd臡«#†Åp¶çáAJ»4i‹å0ÆÓç“Ùô¸¨—³éƒËå²i›ïÞF¿çV+ž‡f¨«rŒòryYu/êrÚU‹h§{!$ ô°KÝq]Õ]ù»º9:»œ±¸<ŸF9mWžo¾_¿’íªcíƒeÛGùbŸô}TGGãüA }D»ßB÷ëmöm(Û(¢ŸöÝ8›ÍšjÒwÕ0,ê3Ѻ=ïÐV?]1™}XCÙ4ýe[Dýýš®Û¢ô°CeüfR>™GUÝÅØ·‹¦ŠeU^tãKܯ£÷ÝŠ· :.‹huYãØñÞ´<_ÆçÃðÁžG (=ìÐOæCD¼šk¿ì#b8¾oE_íæç¡‹ÉËÿÇ"bãb>D„ÌÃ&î×D_¸o”2SzÈLé 3¥€Ì̽‡[äô4"âääæowý¸»~¬ý< p}z¸KNO¿îåímcâåíâGVQz`ç®f^ìaϽ‡»d?ǽ÷vÖØ¥‡;ãÆóÜ×vŽ¯î1ov¾ÿÆe·¸~`Ͻ‡;ãõ”¾JìËñÎGÅW%|»ëöIé?`×’qôî¼7ì(Ÿž®]î×Ù⎸ÍØ?¥‡;o‹ù<9ùý…|W×)Ïp§9z·ÈÕsáï>Ííêz€{Kéáv¹qrû[zýsu6ØPxÃÌ»?·g»[0ÀZ”n«Ÿ0sÕ«Ê^»Üîe€_ÿtš×׹ʪ~¿yýWoÿFï²¼‹"bÝMô¡Žº‹áôtˆˆ““²Ž²‹ÎF¼AîÂíî§Ëý¼Á [î¬<ïDŒá–3÷XÛ»ÏöFéµI;Ü!J;õ*‰§ø-oéÚóæ’AX›óô™Ò@fŽÞÃqze"ÜÉ»*?==}Ç5w…}z¸^fþäääe¡OßáCnß°ìéé黬¸…”î€W™ù­Ýqàí9zwÒŽboòQz¸Û®l¿zlÿäääÕÿ¾~ÌÿÚq‚«ÿûêÆ7¯çõ¯W8 Gïá»zòþÆ¿~ûÕS×2üz•W­gÝñ¤ô™£÷À–Ù‡[Eé-snnGïáN²ß ¼%¥‡;àÚì¶me~ן“ãsxà6Pz¸^Åþêìú«7¾~ÕÜ7®*V\e÷y¾ú¸7Îù_k<ÀNëÿÈ¡Žº‹áôtˆˆ““²Ž²‹ÎFÜäú…éÌÝóÚóæ÷Á–;+Ï™Ò@fJ™¹žvêôßò–*=1+´ãgßZv¿-&ãò[{ $ ô°Kíã!Æ(æc|4Ï¢|ñbXÔÕQ߯š"ssùÒê«o®«£ý‹¨.çý¤,G|6´ÓñÞÚ€íPzØ¡Yñd>¾ˆqŒbˆ˜VGM^-û±ŠöÆû÷qsù²Zõ<,û*¢ªŽ¦ýÙ$"bìǘÍÊóÁ¤¢hc,"Æ3”¾^³ÜfZsÕº¯€ûfëÝ\»ô]y²ÞÖrEç4=À› k~¢Ý7Y»ôŸÞõñ£OÉãŠu_?÷ÍÖ|®ž~ó+úÀë`ßÖ/}±æŒªÑyY®X÷õpßl;›k—~×}§Vz¾¶þë€w²véËb½)vþÀ W­ûú¸o¶Þ͵K¯Ü¼ ¯€=sÍd¦ô™Ò@fJ™)=d¦ô™Ò@fëÿ…›]ŒˆˆÛðnÆbýÊÞÒÁ?#/ÆnËCvfíÒ7ŽßÀδÛ^áÚ¥oK\;³í?¶vé«á'[ðÿúØòYòµKßËíŽøÚ¸å à×ߧ«íŽx¥ßöäûõ÷é·¥°+>#2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé 3¥€Ì”2SzÈLé ³ÿFqY‘v½šþIEND®B`‚dkms-3.2.0/images/mok-key-4.png000066400000000000000000000115201500670340200161360ustar00rootroot00000000000000‰PNG  IHDR™ìÊ!ê pHYsÄÄ•+IDATxœíÝIo#éyÀñ§6’’z›{€‰N'‡\âC>SAŒò‚\bÀ0!ðÇòÅFÛã$¶Ç³ô¢…dm9Èn˪I-ñ‘~?èЪ&«Þîfó_o-Tq@Zå}¸-€Ü´rÓrÈMË 7-€Ü´rÓrÈMË ·zƒÇL«¨úø,¢Šˆº‰®Ý«·=8X«÷:äª(î{}”}UÏûnˆ˜F,ëøf‹ˆvÃ5¬oyÙ¼Š®šÕOæm]FÓµoªúXôEs»ÁÃ]½ss}1Ü÷ bìê˜ô]TñQofõ“e÷Û¢Ž±ÛÛpë[>´EDÑ·Ý,–mô³I5ëû¢ó€0˜–s ea_ûW³²ºþIÄ/fñÍy÷:â º“k¬aí#Êøf=ºî§ÿòƒ¿jžüoY}çõâWuñêùâù-Fw£/íSrsÕàš!îßËÉ—mÿÞóƒ'ãò¬Wÿôw'Íìy{ö´W®a}Ë‹8Y.ã`úíYY ¯?úûïý´ˆêØŸ—‹Û îÂà\·à}Œ°7<ëŠq?ýÁ§³ø`ÚÌOÏú2Þœ_¦¶‰õ-o&/ûe}²XNg˱!&cÙCÃìvƒ¸oöÙ]œµñ¢ˆ/gõ^1ýïÓeÅñdÒÏ7>þ½¾åóå,꺉÷úy? }DD³ì“Í÷`›úû©yãþµQGóz\¾èúyyúþ¤é–E?_œn¾†õ-ŸÄGËøŸ¶ëÊ8†±š Ýâó:¾ÓÇç·9Üa£û*aµ2cçþÕñárù_Í,¢Ÿ–u»lQŸ5ñq_l¼†u–ñiÝíw1´å<&Ñ-Ë:>lãËÍîMØ]öÙËø¬ŽÚù0Nº6ºˆ²îž´ñÙæŸçæNÈMË 7-€Ü´rÓrÈMË 7-€ÜÜ[ GG+nk+—Ö|Õòw¯êâƒo°†«V{'ëY¹Úw¬ó¸ôOsçÿ(ð˜—CÄ…Bn±W­ùº[üêžÇ]yöµ!û»_ýs½}îÛ—•{]ðÈi9¬`ò$¢å°šœGÄÑÑmçÁ›LÊÏ­œv_ŸÆéö7<¬üšÄÙ³âYÄ¢‰å~QGÕFDU}¹ýñëÕ÷=`•á[“²]ö¿ü×ÿ›²ùdÞüeûê“ý'Óér»›-£Z¹ü¸™ÎÏ^•??Yœ¼øÇø¤‰?íú#N¶; `Z»hVUóþ³Ùì/ªþ˺xþ½¿ýÉA].»ÉbÜîvËX½IYñº+ñýïïïקMñgmOËébØîx€Mh9ì¢yÿ:¢œÏ‡gû“Åb1ŒOÞ´]Ä,¢Ýêv‡XçùДq0 ˧û“¡†®ŽÃñVlHËa'MÚb9Œñòõéd6Ý/êålzp¶\n9åÑD³ryÛ uUŽQž-ÏÊ¢îãM]N»jít»6 å°“ºýºª»ò·u³w|6cqv2r±ØêfÛ«Öß,Û>Ê7Ãø¢ï£ÚÛç1ôÛ>NlBËa' eEôÓ¾g³YSMú®†í†<"ê+®}ë¢+"&³Šb(›¦?k‹h¢ßòÙ{`3îIƒ]TƯgåIÄ^U1öí¢.¢­Ê­ß“ÖE½ò«Ž³:ºÅiY–cWijiyR–¿Úöx€M˜—Ã.âÅ|ˆˆvüÝÔwÙGÄ°¿ý-÷+—v19ÿÝq,"†1NçCD¼¿ýñë™—@nZ¹i9ä¦å›–@nZÁÑQ]ù-ð°i9<ú “–Ã"çði9äæsßà»4S?<¼§q[c^Çy§/]w¾üü+„‡‡HËáA1í†GHË 7-‡‡ÆÔ-€Ü´rsOÄÅ|Œçãq”oÞ ‹ºÚëû-o·¯V.®«½7ý›¨Îæý¤,žG|:´Ó1š-؈kß`ÍŠcÔ1ŽCÄ´Úk†¨–ý¸ííVÑ®üZöÃUµ7óƒðc?F=+ßÛöx€M˜—Ã.š/#š¦yڶˈ®?¢œFÕE»Ýí±z^uã¤?^D,†1šúyÛ óá¥÷ØþÂN*‹†¾m«h›²^ “z˜¶C·íÍŽ±ú|ytu³.æÓ²o‡Ó¡«"Š¨ËØúˆ€õ´vÒPDŒCÔÑQ·qQlÃWwÚ8˜Ì×ú1bŒÎI:Ø þ+@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9äVo𘲋áüçßw1Ø €!É›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹i9ä¦å›–@nZ¹ÕkQÅdˆzoòŸÇíwžýö‡ÿñ"†®«>ëÞ¿âö¸h¸ïì´E}Z¶ŽU;LÏ^ÿù“éOß.ãÕæïžEÄÑš‡”m Óˆù“iuº8ãÉÓòùbø¢‹Éʇ÷×?_ußØqEôûåӓወÓYóÁIÛGLªé›~±·áÖÏË£\Dq¼·÷ãã&âiÇ‹êõb¨£,V?~7?_Õë€sÃdQ½†㣓v²ÐÎÿ¯"â[Þ}ñ›³ã“ˆ}1éË7Æ°¸â fb\0t÷=€w°h?º‰®èOOÎ"¢?âxÃçoÐòXNš§ËöeÄˈ.bÅ{u¹_ô«¦·a^Î4½Æ¯.ê±xÒŒËîuDÑMš÷úvÜüœõ&ﳧŰ_Å‹±‹bì—mDÑõŸG478†};€u>qº<+ªòÙ0DE1Ô}œnþü ®c¯^-ú/"êŸVå,bY1ŽMW\¯>ºn™ ®ze1†ˆè†q:Ëq|½è»"Š1^l¸†õ-ïûoEœe1Žû}?¦»¶ˆ'Ÿ\ùx%ç¢Ò¾À; cŲl¦ÃrˆØ‹bˆ±ãyÄË ×°É1ö“ˆ‡ñüÑ–Ó1Ú1®º>Ù1Uþ`¸òuÀ¹!ÆzXö}Dc1nòؤåõ5Ûìªe.ºîëà±¹}7×·¼+¯·J‡T¹ sºà݆uÚ¶Îú–ãõî}ò\÷õðØÜþèåç˯q‡|…×À–mÐòâš×.ÎrÁu_?Í­³¹¾åãxÝ÷b-ç®ÿúàzÖ·¼,®w1›­ÂE×}ý<6·ïæú–k3·áõ°mn€Ü´rÓrÈMË 7-€Ü´rÓrÈmƒŸ­ò5Œ«¯ãg«ŒÅŸÙÜÌ×ð¹o1Þþ§¤Û²¾å£ì°5í­×°¾åméµ`kný#¨Ö·¼~tÛWèã¶ç²×·¼/–·Üp¥ñ¶÷‡o0/«[n¸Jë Ù7˜—ßÁoÀ¶øÜ7ÈMË 7-€Ü´rÓrÈMË 7-€Ü´rÓrÈíÿn…Ý |éD·IEND®B`‚dkms-3.2.0/images/mok-key-5.png000066400000000000000000000127231500670340200161450ustar00rootroot00000000000000‰PNG  IHDRªCô« pHYsÄÄ•+…IDATxœíÝ[oëzØñgN$%ù´ŽÀj’ »-›æ¢Ÿ©€¢A ý¹z“A€ùX¹ÙAŽ;éNÖÚëàƒ$gæ^xE[‘EÛ¢)SÒóûA6Mμ²(þg櫈gdRï{ÀÇ&ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òé´[=jÞD3ÆwMD´] ýaÄÔÄ´ÛÁÁFÏC>@Õ¾‡1F16írJÄƈŬYŒc5øµá(vþùueó‘ýk§EÝ”a|ñ‹øb9¼Œ8Šád—«Øâ1u|ÑÎÊ0üõÿÙïwþ_Ýüìåê_ÚêÅãÕ㎠¶3Ö6CÙ^SœÅþ=ŸýØŸ<>z0­Ïúeó¿ÿûI·xÜŸ=ãÅ®V±Mþ«8Y¯ãhþÛ‹º*/¿úø×U|ÖÆá²^íjX°½bŠàuŒ[à <ª©LßþÙŸÏñÙ¼[žžu¼z}ÊÝNl“ÿnö|\·'«õ|±žú(1›ê¡*}”Å®†°6¹†8ëãI?.Úƒjþw§ë*ªãÙl\îî(û6ù_®Ѷ]|2.ÇRƈˆn=¬f;Ü*0î{Üi^ÇØ¿>Úè^Në'ø¬O?uú—«Ó®b›üÏâ«uüs? u•25³2¬¾oãgc|¿Ã‘ÁvÊ–og…ˆˆ:ügÿÚør½þÛn1Îë¶_÷«hϺøºv·Šë[Ç·íp8DéëeÌbX×m|ÙÇÛ^EධùÈm°ŽïÚø¬_–i6ô1DÔíð ïvx±>ç¸@:òéÈ?¤#ÿŽü@:òéÈ?¤ã®pµgÏ®¸ñéÓ›ZË¥%oºý틺xç-–°i±;YΕ‹}Ë2ßr‡K?šÿP {ÿpµó¨<}zƒÙ´äë®ñÍ•]ù&¾÷w¶ÿü_ßü¾Î{þs¹rC x;ù‡÷b¸OäÞ—-€ˆxöìC÷¶ßg×ÿµ+wî/ŒyÿE—˜û‡w»8­~žœK“â›nž«¾¸ð+s¸Ãñ\Zþ•Ë¹ò>o_…¹|øøìýÃ;lŠÜ¥¹çM·ßô\õŽáM§)ìd<›ºþß×®Æ\‹½x‡‹;ô×zÔ-±Ã‘|„oêöü¿Áý&ÿðn÷¯I[ï©ošYØÚë­«‹Ë¹ÿÛp É?d´EbÏ;}ñ±;Iõ¥Ë¼¹‘ñÎG×eîÞ—÷—ïÄûOð›Ý‡›#ÿð^îJû¯ûƼkÝÿ-åÞú ÿ@È?lrž–÷ÌÌÅû_tžÌóå\yiÞKÚtû&W¾áí÷¼r­Û¨‡lL—¨8låÆ;+ØÀMÑ~¸µœùì’KøÁ ÿÀ.é=Ü þ@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽü@:òéÈ?¤#ÿŽüsïÔ/"¦èÖQÍbŒXR?žÇiDÙðÅ~mú¹ìçkgªG«.Ö‡UMMóã¾ÿ—`ÇÚ}v­üÖ¬î×ã?ýß¿ø¯u÷Ëe÷Ÿú¿<|0?X7Wß=¦<@.ªãêŸË¾wóåÙ‹úèëGÓ/W'Oþ×ÿüe¿3Œ_Gœì{h°KòÏ}³hšåøÝbñ›ñǶzü‡ÿíGm½fýtuæíþïW}Ë6¿fu[ÅË¡þÇ?ýÓÃÃö´«~·ãy=_y¢p¿È?÷Ír|Q/—åÑálµZ•éÁ«~ˆXD¬6<ÂØ>•[¶¶,]G¥¬ÎÊXÊÐF”U9Þ÷¸`ÇäŸ{gÖWë2Å󗧳Åü°j׋ùÑÙzÝõÝ•wïcüÈä¢.®þ¹ìKß•¶©§¨ÏÖguÕŽñª­çC³Š~¾ï¡Á.É?÷ÎpØ6íPÿºíŽÏ–S¬ÎNæQÏûs·~ ö©ßxTfOú£u?FýªLOÆ1šƒƒiyeŒè÷=2Ø%/|Ü;¥î£Šq>Ób±èšÙ84¥¬Ú §˜ yxü{›~.û2ÄPEÌŸUU©»n<ë«èb¼]'(À‡“î›:þuV?Y–ƒ¦bûU×ĺ©O‡òpÃ#üߧᖽ µqVE·:mëºLÓPÅ£y}²ŽïJùtßCƒ]º]¿xðáJà[>Nà6³÷Ovç}úô§?¿¹Ap«¨>ðáäÒ‘HÇÜ?ltqàâ!÷K³çÿtåí¯o¼tŸ+g.ÝÿÊ9þ·LL\ZÀ[Øû‡^Ÿ p)Õ畽ôO›nßdÓýÏÿü–U| {ÿð“íΨßtç]EúÊÃ7ºF ù‡Ÿ¼™Ï+wß_–s^`Óí—¦ÐÀ-!ÿpµwNÒŸßí¼ë›n¸mÌýÃÇpñü€½“¸žKGøßyû¹›>ðÎœ“²»t^ý¹óÃþçÇð/Mœçöâ‘ÿM·¿¹äM÷Ÿñ\y€÷WElñRÚh‡(Ïž•ˆxú´n£b°1Á­âmrlÅë·Á?=¡ ù€täÒ‘HGþ Wýƒ\ª˜ö=„[mêÖeèbŠ¨›ªš"bˆ.Ú6†õ¾‡»$ÿËT5ûÂíÖ1Eß4³õòÕÁ¢ŽjÕÅÐSD·ï‘Á.É?$3ûÁ­Vw?–þd›Åü¨_—¶j§Rºö¨ú} vIþ!—6ª}áVú!âQUκ£(ÃPΪXOëˆÅ¾‡»$ÿËeßC¸Ýêª)Ý8-<ýþ`ñ8¢>ì>?þÙ)Ü3òÉÔæþߦ.Ÿ7Ññ«ƒE]5˨º“þûh›ö=2Ø)ù‡\êbïÿm¦x±h^5m5ž>ˆ8l»ÓaýM5}nçŸ{Fþ¹ç|,Þ%•©ÿ·ZUuÓŽ'g¿{¸øÅpúŸÇõóúÑ0~6Æûì’üsoù¬¿ ôÿíúˆ‡ßG|ñCÄ|U"´Ÿ{ÇUÿ ù€täÒ‘HGþ ù€täÒ‘`kQ£<ŽÕq°ïñïKþáŽyöìV\Ê°êNê(15ôó³?úùYLM¥êNö=.ླྀê°©ÐÖÏKù¢_†ÐASÿºï„ƃ»ÀÞ?°ª”n>¯ª©ª¦j>¯Jé\Qî {ÿÀ6šfªÇƒÕêWMW"bµª»ø4ša÷=2à=È?°qg]úOª±‰ˆ*ƶ[Ÿõ“cŠp'øE¶Òvgýª®Úuùf]¾©«ö¬_EÛí{XÀ{±÷le#Úqê»æˈ§>¢ ‡þᎰ÷wDsÒT}]}8óRÇ¢™·1[ßüŠ««¿Ú±žÍë¨ûÙi,ú.º¶ŽhŽo~<ÀØû‡;búzœ¾ïâä䴪겈oW«6b~ó+Þ°…Ñ·U¼šÇªïýM¬—¥‰ø*âÕÍ øPòwD)ÏÎ~Qâ¿,þõOþòÎÖÿ4?lêåêFWÛÆìÊÛ׋Åê´;˜}Uæ{vò–ñW?;;»Ñ±;#ÿpGtÿ°ºˆÏþÏÓïºê`9ýýãj~<=oúR»M¹òæz|þ°zøbúûEuÔOßF|¾¾©f§Óúó›° òwDÿ¸ÄÕrŠ/—ÓqÔ¯^•UÛÜøÉv?]Ôﲶ9x5¾Šæl9ÎêêqÄ·¥ŸOá̸œúwâz2EÓQ"æÍAW¢Y7~…Ý&ú+¿Öc)Ñ4óx=;0S´‹ú“›°öþánXNÏ#º®{Ø÷ëˆa<)QÏ£¢¿Ùõ–¸zï?Ú*¦Ùx¼ŠX•)ºöq?”eyîUpGÔU”2ö}}W·«2k˼/ÃM¯vŠ«çþch»X ±œ×c_NËÐDTÑÖqã#v@þáŽ(UÄT¢ˆ±DDÛÇéGùˆMS„¥ÓˆÙò§Íƒ)bŠÁ|"Ü ~W ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒi·zT=Dyý‡×¢Ø’€»B³ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒi·xL³íÁìoŽû?8zôë?ÿù“(ÃÐþÃbøtÃ#ldpQÙ÷nµU{Z÷_NM_æÇg/ïÁü¯NW¿]Ç‹¾zVÏ®ý º2X>˜7§«ã)<¬¯ÊCÌ®¼ûø¡ƒä^iö=€[®Šñ°~xR~ˆ8]tŸôcĬ™¿W»ZÅ6{ÿQ¯¢:>8øüø¸‹xXÇñªy¹*mÔÕÕ÷/Ó‡ ‘{fÜô<àµ2[5/K‰)¾:ég‡GÃéòWc‰ˆýæø:⛳㓈'c5WëW_FYmx€ý=.(þGpË­úo£íb#ÆÓ“³ˆ£?8ÞÕ ¶Ê¬gÝÃuÿ<âyÄ1ꓶ>¬Æ«ó÷aïŸßè¶|Öd1D;UŸÎºi=¼Œh"†Y÷ÉØO;œLßî…ø´*‡M<™ª©ª¦qÝGTÃø}D·»qoÙx—ïcš¯Ïª¦~TJTQU¥ãt‡+ØêÌÿæÅjü!¢éaS/"ÖUÓÔEµá ÿÉ™Þ\°éy@DDÔÕ¼”ˆÊ4Ÿªõ4½\CÕOvµŠmò?Ž¿qRÕÕ4Žã2ºjú*TÓúÊû‹?Õ6ÞªLuT뺛—u‰8ˆªÄTOñ8âù®V±ÝÁÿ“ˆ˜ÊôúÑ×ó)ú)6Ñí`/¿Q6>Ox­ÄÔ–õ1Fô1UÓÛÛ忽fÎçÍE×}þdóº¹Mþ‡úéõàX/ ¦þÞ®\ÿŠ|×´Mþ«ézïãŸ\÷ ®ûüÈæ##Ýjî—ï<$Ï€}Û*ÿÕ5OÝšÌõrÁuŸ?ÙÜ|6·Éÿ4]÷å[þùë?رmò_W×;—Ï'þpÑuŸ?Ù|„nn“9çCxþì÷`@:òéÈ?¤#ÿŽü@:òéÈ?¤³ÕGþì|À¿¹¥ù3U[}Rð>nçUÿbv= àãÙ&ÿÃÿpcú›_Å6ùïkm€s󟌶Mþ›ò—;ðÚ7>ɾMþÇj½óq?™nümù[íýOÍÎǼ6Þü©ÿ[íýŒw$7ÅUÿ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ù€täÒ‘HGþ ÿ®„ûÇj»„¤IEND®B`‚dkms-3.2.0/images/mok-key-6.png000066400000000000000000000135151500670340200161460ustar00rootroot00000000000000‰PNG  IHDRõ;øÒà pHYsÄÄ•+ÿIDATxœíÝKocizØñç\HJ¥ª®¾ÌtÒÉÀH_QœN§Ý|ëýâãº>_D]Oâ‹nÞõ}1Y¶‹éöï#`—º}€gÍëû×D“÷Ãò󶛗ç_N'í²èæ‹óí—0®ëÓøfÓ´mG}?TÓ¾]|WÇ/»ønäÈááõ£¯Û„Ê°žý«ãëåò/&ݬ¬›e³ˆúb¿hâû­—0Æ2¾­ÛWmôM9i´Ë²Ž¯›øaüuðO‹÷…<ËøM_5ó~˜¶M´eݾnâ7ÛŽœó? ]€/ù:ù]½¦¯Ïá(W™¼ÿ¢î°ÞÕÕ­ŽDÂ7y´ x"Ì×áîž~A•^óux6L=O2_çE»åøôññõÕµœÕw:ŸÞrá·Œgí™·lŸMglZÅ'ϸe<±õvû-xIÌ×y¹n?>}y²ÕµBÜüÃÝ–³v$·»\ÂØ2Ý­d«¼9ø[×Úû¯nŸ›Q_û+kÇ3v;_ýxíÏ›ù:/ÈöóïU«w¾Ï û毌ݯ~‡•Ž:ü©íçjãgA×yAÖn_ñ¸|‹°º÷xG«Ø2íkÇ3vlwx,›~eÓö{¸®óÒÙ=»É-Âäþ—çȼŽ¯Cf|‘=°wº?¹Üe;ŒÝþ»¾?¹Þ\þ6KÞtÿÕÛ·ÿ6ËßþìEŸÄÇKSDŒz èë¨ÛèONúˆ8>.ë(Ûh½?¶¡¯ð)÷í¬»e8<&]vëÚ~x“uØ)×¹;§åðhÌ× ]€æu”]œ™oe±Û÷I]œ.£n£ŸTÓhºÓ˜×ñ¶]¶ž?†ˆv߃1tLNnýnsÐ]Te¼š.#bÖÿ·¾?¯¢›ï{`0ŠëÜ""Ú8jʳe4mó¡m>,£iʳ6Žö=.Ç|àREåUQGD”?FQ٠ϳ£ë¼\k/ ðKº®ÖrmÉ›nß~ nuƒ<æ¥m÷|€·}úègQUwùã4ú!ÂÙð<3öÃór]eàøx‡Û´äí×ø8‰½¬ãÕ¦xÌO–ÛôON¶ÆCmŸ¢XFq>ôGóˆùÐEq^ˇY:<óuøÉññ£Æì){™ŸCÓ QGm|èÊËÆuÔØÏs£ëðѳèÙÕÄ:½ûì– ÛÖÒuˆˆ89ùX‚«0\;p»éö¸±×zwQ¹­µë]{Ÿ; iìã]½Ûö+Ý´díQóOngQÇ×ac¥®lÞtûê‘éœÞìû¯÷êož:wŸÇûÉñÜ’á[š½i½¢a¾q×#ë{éÇŽVºÍ {ûUo¹1ï™á-ß ÀKc¾ϧ7“yyÒøÓ9ãïrKîb{^ÍÑoyÈOg;À¾˜¯Ã³q9«^= žÏ;’qíXûÍMqóFxiÌ×á#³=à¹Óuøɳˆú-ç©=©½ñ»°Í¼ßùƒeûӧ˕—¯mô^$yv÷ÜÅrV¿5÷C`6 xËÏÛ‘s^&]‡ŸÈÀ'íô ð 쇇DëY¸çŽÈM×!"~ëË=¯pó“É×ÞõQ0·¯wí‡Ò¯σ·Þ~;¬Þmû¸nÚÓ¾vðŸÜþ¢ÎËa?Ý÷°`œz߀‡3ü¢¾›ÄÙÙyQ”ýA|»XÔ³ˆå†_˜<êðxâš²ˆ³X4ÍA3DËy_E|ñaß#ƒtDúþððíÅÅÿìã_ü¿ÿü§¿±ü?³WÕt¾¾ëm <@ž²þàÕâ|r8ý¦ŸýÅÅÙ?™ÇŸþòâbß‘tD&µl'_ý‡ãßLŠÃùð—o‹Ùéð®«Öß¿³+žÊx÷¦xóãð—ÅQ3|ñ³eû÷Åô|XþlßCƒtDš·} Q̇øz>œFùáC¿¨«Ã®ÛtIÿ¨Ããi««Ã݇¨.æÝ´,ÞF|Û7³ÁÁžçÍ‘ÇAñùu CD1«'}TËn¨¢Yûß¾ÇËÓ²ìú>ªêp1ˆº!êƒò‹} Æ1_'ùð.b2™¼išeDÛõQ΢jû¦Ú÷Ðxê"†iwºˆXôCLê·MÛÏûw^'y^<_I¤,¢ï»¦©¢™”õ¢ŸÖý¬éÛaãþvû«XÑ“8hc>+»¦?ïÛ*¢ˆºŒv߃1tDú"b裎ˆ®ˆº‰s—ª³µ¾‰óˆéü§÷CÄ­7<3ž²‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyÔ#ï_¶Ñ_þáòç6zoà‰dÈC× ]€ÿÛ®ˆu½ýEÄß_œžE|ÑÓn±üñuô‹ ¿`†ÆŠ¾Ý÷ž¸£EómÔ“h»ˆîüì"â(º/#N·üý‘]åtòfÙ¼‹xÑFÌ¢ø¢._Ýú=îM˜¯óÑdôó àei£Š/§“aÙ¾¨"Úéä‹®¶?®=öuö¼è_UñùP E1tË&¢h»ï"&#—ÃKä}À§|ÃlyQTåg}EE_wq¾ýï<¾úqÑ}QÇð¦*"–EÃ0‰bÃyïƒóŸY±éy@DD”Ŭï#¢í‡ÙP,‡áý¢k‹(†ø|Ë%Œëz×ýÓˆ³¢,†áU×ÍcR mSÄëbX®½¿ª³ªô>àVýPF±,'³~ÙGFÑÇPñ6âÝ–K»þ,"†~¸üC4eÄlˆfˆMç9ÛïÊGýÆç —úê~ÙEtM EÄ°}Ôcl×ë‘vö3«Æ>^šûws\×ÛòxÜâíveEëð:Àíú1·Î¸®øëÑŸ8ÇŠ±Ï€—æþ{5G_qÜàù°c#»^Œ<ïip<•cŸ?/ͽ³9®ëÃ0öuY×ùhüó€qÆu½,Æçk_X5öùðÒÜ¿›ãº®Ó܇çÀ®¹ðòÐuÈC× ]€`£á¾×Ÿœ¯Õ=×lÒÝû„ø‘óõ¸²ØŸ7yè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyè:ä¡ë‡®@ºyü®…¦{ËÞ[IEND®B`‚dkms-3.2.0/redhat_kernel_install.d.in000066400000000000000000000004171500670340200175600ustar00rootroot00000000000000#!/bin/bash COMMAND=$1 KERNEL_VERSION=$2 res=0 case "$COMMAND" in add) dkms kernel_postinst --kernelver "$KERNEL_VERSION" res=$? ;; remove) dkms kernel_prerm --kernelver "$KERNEL_VERSION" res=$? ;; esac exit $res dkms-3.2.0/run_test.sh000077500000000000000000005261361500670340200146660ustar00rootroot00000000000000#!/bin/bash # Test that dkms works properly set -eu # Change the to base directory cd "$(dirname -- "$0")" # To use a specific kernel version, use the environment variable KERNEL_VER UNAME_R="$(uname -r)" KERNEL_VER="${KERNEL_VER:-${UNAME_R}}" KERNEL_ARCH="$(uname -m)" echo "Using kernel ${KERNEL_VER}/${KERNEL_ARCH}" # debconf can trigger at random points, in the testing process. Where a bunch of # the frontends cannot work in our CI. Just opt for the noninteractive one. export DEBIAN_FRONTEND=noninteractive # Avoid output variations due to parallelism export parallel_jobs=1 tmpdir= tmpdir_cleanup() { rm -rf "${tmpdir:?}" } trap tmpdir_cleanup EXIT tmpdir=$(mktemp -d) [[ -d ${tmpdir} ]] || exit 1 # Temporary files, directories, and modules created during tests TEST_MODULES=( "dkms_test" "dkms_dependencies_test" "dkms_dependencies_rebuild_test" "dkms_circular_dependencies_test" "dkms_replace_test" "dkms_noautoinstall_test" "dkms_failing_test" "dkms_failing_dependencies_test" "dkms_multiver_test" "dkms_nover_test" "dkms_emptyver_test" "dkms_nover_update_test" "dkms_conf_test" "dkms_duplicate_test" "dkms_duplicate_built_test" "dkms_duplicate_dest_test" "dkms_patches_test" "dkms_scripts_test" "dkms_noisy_test" "dkms_crlf_test" "dkms_deprecated_test" "dkms_build_exclusive_test" "dkms_build_exclusive_dependencies_test" ) TEST_TMPDIRS=( "/usr/src/dkms_test-1.0" "/usr/src/dkms_test-2.0" "/usr/src/dkms_dependencies_test-1.0" "/usr/src/dkms_dependencies_rebuild_test-1.0" "/usr/src/dkms_circular_dependencies_test-1.0" "/usr/src/dkms_replace_test-2.0" "/usr/src/dkms_noautoinstall_test-1.0" "/usr/src/dkms_failing_test-1.0" "/usr/src/dkms_failing_dependencies_test-1.0" "/usr/src/dkms_multiver_test-1.0" "/usr/src/dkms_multiver_test-2.0" "/usr/src/dkms_nover_test-1.0" "/usr/src/dkms_emptyver_test-1.0" "/usr/src/dkms_nover_update_test-1.0" "/usr/src/dkms_nover_update_test-2.0" "/usr/src/dkms_nover_update_test-3.0" "/usr/src/dkms_conf_test-1.0" "/usr/src/dkms_duplicate_test-1.0" "/usr/src/dkms_duplicate_built_test-1.0" "/usr/src/dkms_duplicate_dest_test-1.0" "/usr/src/dkms_patches_test-1.0" "/usr/src/dkms_scripts_test-1.0" "/usr/src/dkms_noisy_test-1.0" "/usr/src/dkms_crlf_test-1.0" "/usr/src/dkms_deprecated_test-1.0" "/usr/src/dkms_build_exclusive_test-1.0" "/usr/src/dkms_build_exclusive_dependencies_test-1.0" "${tmpdir}/dkms_test_dir_${KERNEL_VER}/" ) TEST_TMPFILES=( "${tmpdir}/dkms_test_private_key" "${tmpdir}/dkms_test_certificate" "${tmpdir}/dkms_test_kconfig" "/etc/dkms/framework.conf.d/dkms_test_framework.conf" "/etc/dkms/no-autoinstall" "test_cmd_output.log" "test_cmd_stdout.log" "test_cmd_stderr.log" "test_cmd_expected_output.log" ) # Reportedly in some cases the entries in the modinfo output are ordered # differently. Fetch whatever we need and sort them. modinfo_quad() { modinfo "$1" | grep -E "^description:|^filename:|^license:|^version:" | sort } SIGNING_MESSAGE="" declare -i NO_SIGNING_TOOL if [[ $# = 1 ]] && [[ $1 = "--no-signing-tool" ]]; then echo 'Ignore signing tool errors' NO_SIGNING_TOOL=1 else NO_SIGNING_TOOL=0 fi # Some helpers dkms_status_grep_dkms_module() { local module_name="$1" (dkms status | grep "^${module_name}/") || true } clean_dkms_env() { local found_module for module in "${TEST_MODULES[@]}"; do found_module=$(dkms_status_grep_dkms_module "${module}") if [[ $found_module ]] ; then local version for version in 1.0 2.0 3.0; do [[ ! -d "/var/lib/dkms/${module}/${version}" ]] || dkms remove "${module}/${version}" >/dev/null || true done fi rm -rf "/var/lib/dkms/${module}/" rm -f "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/${module}.ko${mod_compression_ext}" rm -f "/lib/modules/${KERNEL_VER}/kernel/extra/${module}.ko${mod_compression_ext}" done for dir in "${TEST_TMPDIRS[@]}"; do rm -rf "$dir" done for file in "${TEST_TMPFILES[@]}"; do rm -f "$file" done } check_no_dkms_test() { local found_module for module in "${TEST_MODULES[@]}"; do found_module=$(dkms_status_grep_dkms_module "${module}") if [[ $found_module ]] ; then echo >&2 "Error: module ${module} is still in DKMS tree" exit 1 fi if [[ -d "/var/lib/dkms/${module}" ]]; then echo >&2 "Error: directory /var/lib/dkms/${module} still exists" exit 1 fi if [[ -f "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/${module}.ko${mod_compression_ext}" ]]; then echo >&2 "Error: file /lib/modules/${KERNEL_VER}/${expected_dest_loc}/${module}.ko${mod_compression_ext} still exists" exit 1 fi done for dir in "${TEST_TMPDIRS[@]}"; do if [[ -d "$dir" ]]; then echo >&2 "Error: directory ${dir} still exists" exit 1 fi done for file in "${TEST_TMPFILES[@]}"; do if [[ -f "$file" ]]; then echo >&2 "Error: file ${file} still exists" exit 1 fi done } cert_serial() { local ver ver=$(openssl version) # Some systems in CI test are still using ancient versions of openssl program. if [[ "$ver" = "OpenSSL 1.0."* ]] || [[ "$ver" = "OpenSSL 0."* ]]; then openssl x509 -text -inform DER -in "$1" -noout | grep -A 1 'X509v3 Subject Key Identifier' | tail -n 1 | tr '[:lower:]' '[:upper:]' | tr -d ' :' else openssl x509 -serial -inform DER -in "$1" -noout | tr '[:lower:]' '[:upper:]' | sed 's/^SERIAL=//' fi } set_signing_message() { # $1: module name # $2: module version # $3: module file name if not the same as $1 if (( NO_SIGNING_TOOL == 0 )); then SIGNING_MESSAGE=" Signing module /var/lib/dkms/$1/$2/build/${3:-$1}.ko" fi } run_status_with_expected_output() { local module=$1 cat > test_cmd_expected_output.log dkms_status_grep_dkms_module "${module}" > test_cmd_output.log 2>&1 if ! diff -U3 test_cmd_expected_output.log test_cmd_output.log ; then echo >&2 "Error: unexpected output from: dkms_status_grep_dkms_module for ${module}" return 1 fi rm test_cmd_expected_output.log test_cmd_output.log } generalize_expected_output() { local output_log=$1 # Normalize temporary directories sed -i "s|/\(\.tmp_${KERNEL_ARCH}\)_....../|/\1_XXXXXX/|g" "${output_log}" # On Red Hat and SUSE based distributions, weak-modules is executed. Drop it from the output, to be more generic sed -i '/^Adding linked weak modules.*$/d' "${output_log}" sed -i '/^Removing linked weak modules.*$/d' "${output_log}" # Signing related output. Drop it from the output, to be more generic if (( NO_SIGNING_TOOL == 0 )); then sed -i '/^EFI variables are not supported on this system/d' "${output_log}" sed -i '/^\/sys\/firmware\/efi\/efivars not found, aborting./d' "${output_log}" sed -i '/^Certificate or key are missing, generating them using update-secureboot-policy...$/d' "${output_log}" sed -i '/^Certificate or key are missing, generating self signed certificate for MOK...$/d' "${output_log}" else sed -i "/^Binary .* not found, modules won't be signed$/d" "${output_log}" # Uncomment the following line to run this script with --no-signing-tool on platforms where the sign-file tool exists # sed -i '/^Signing module \/var\/lib\/dkms\/dkms_test\/1.0\/build\/dkms_test.ko$/d' "${output_log}" fi # OpenSSL non-critical errors while signing. Remove them to be more generic sed -i '/^At main.c:/d' "${output_log}" sed -i '/^- SSL error:/d' "${output_log}" # Apport related error that can occur in the CI. Drop from the output to be more generic sed -i "/^python3: can't open file '\/usr\/share\/apport\/package-hooks\/dkms_packages.py'\: \[Errno 2\] No such file or directory$/d" "${output_log}" sed -i "/^ERROR (dkms apport): /d" "${output_log}" # Swap any CC/LD/... flags (if set) with a placeholder message sed -i "s|\(make -j1 KERNELRELEASE=${KERNEL_VER} all\).*|\1 |" "${output_log}" } run_with_expected_output() { run_with_expected_error 0 "$@" } run_with_expected_error() { local expected_error_code=$1 local dkms_command=$3 local output_log=test_cmd_output.log local expected_output_log=test_cmd_expected_output.log local error_code=0 shift cat > "${expected_output_log}" stdbuf -o L -e L "$@" > "${output_log}" 2>&1 || error_code=$? if [[ "${error_code}" != "${expected_error_code}" ]] ; then echo "Error: command '$*' returned status ${error_code} instead of expected ${expected_error_code}" cat "${output_log}" rm "${expected_output_log}" "${output_log}" return 1 fi generalize_expected_output "${output_log}" "${dkms_command}" if ! diff -U3 "${expected_output_log}" "${output_log}" ; then echo >&2 "Error: unexpected output from: $*" rm "${expected_output_log}" "${output_log}" return 1 fi rm "${expected_output_log}" "${output_log}" } generalize_make_log() { local output_log=$1 sed -r -i ' # timestamp on line 2 2s/.*// /# elapsed time:/s/[0-9]+:[0-9]+:[0-9]+// # minimize and unify compilation output between distributions # we are not really interested in the compilation details /warning: the compiler differs from the one used to build the kernel/d / The kernel was built by:/d / You are using:/d /make(\[[0-9]+\])?: (Entering|Leaving) directory/d s/ \[M\] / / /^ /s/\/var\/lib\/dkms\/.*\/// /^ AR built-in\.a$/d /^ Building modules, stage 2\.$/d /^ MODPOST Module\.symvers$/d /^ MODPOST [0-9]+ modules$/d /^ CC \.module-common\.o$/d /^ BTF dkms_(.*_)?test.ko$/d /Skipping BTF generation for (\/var\/lib\/dkms\/.*\/)?dkms_(.*_)?test.ko due to unavailability of vmlinux$/d /^ CLEAN \.tmp_versions$/d ' "${output_log}" } check_make_log_content() { local make_log=$1 local output_log=test_cmd_output.log local expected_output_log=test_cmd_expected_output.log cat > "${expected_output_log}" cat "$make_log" > "${output_log}" generalize_make_log "${output_log}" if ! diff -U3 "${expected_output_log}" "${output_log}" ; then echo >&2 "Error: unexpected make.log difference" rm "${expected_output_log}" "${output_log}" return 1 fi rm "${expected_output_log}" "${output_log}" } check_module_source_tree_created() { if ! [[ -d "$1" ]] ; then echo >&2 "Error: directory '$1' was not created" exit 1 fi if ! [[ -f "$1/dkms.conf" ]] ; then echo >&2 "Error: '$1/dkms.conf' was not found" exit 1 fi } remove_module_source_tree() { for p in "$@" ; do case "$p" in /usr/src/*) ;; *) echo "Unsuported module source tree location '$p'" exit 1 ;; esac done echo "Removing source tree $*" rm -r "$@" } install_framework_conf() { [[ $1 && $2 ]] || return sed "s|@tmpdir@|${tmpdir:?}|g" "$1" > "$2" } # sig_hashalgo itself may show bogus value if kmod version < 26 kmod_broken_hashalgo() { local -ri kmod_ver=$(kmod --version | sed -n 's/kmod version \([0-9]\+\).*/\1/p') (( kmod_ver < 26 )) } # Function to check if a file does not exist file_not_exists() { local file="$1" if [ ! -e "$file" ]; then return 0 else return 1 fi } mod_compression_ext= kernel_config="/lib/modules/${KERNEL_VER}/build/.config" if [[ -f $kernel_config ]]; then if grep -q "^CONFIG_MODULE_COMPRESS_NONE=y" "${kernel_config}" ; then mod_compression_ext= elif grep -q "^CONFIG_MODULE_COMPRESS_GZIP=y" "${kernel_config}" ; then mod_compression_ext=.gz elif grep -q "^CONFIG_MODULE_COMPRESS_XZ=y" "${kernel_config}" ; then mod_compression_ext=.xz elif grep -q "^CONFIG_MODULE_COMPRESS_ZSTD=y" "${kernel_config}" ; then mod_compression_ext=.zst fi fi # Compute the expected destination module location os_id="$(sed -n 's/^ID\s*=\s*\(.*\)$/\1/p' /etc/os-release | tr -d '"')" distro_sign_file_candidates= distro_modsigkey=/var/lib/dkms/mok.key distro_modsigcert=/var/lib/dkms/mok.pub case "${os_id}" in centos | fedora | rhel | ovm | almalinux) expected_dest_loc=extra mod_compression_ext=.xz ;; sles | suse | opensuse*) expected_dest_loc=updates mod_compression_ext=.zst ;; arch) expected_dest_loc=updates/dkms ;; debian* | linuxmint) expected_dest_loc=updates/dkms distro_sign_file_candidates="/usr/lib/linux-kbuild-${KERNEL_VER%.*}/scripts/sign-file" ;; ubuntu) expected_dest_loc=updates/dkms distro_sign_file_candidates="/usr/bin/kmodsign /usr/src/linux-headers-${KERNEL_VER}/scripts/sign-file" ;; alpine) expected_dest_loc=kernel/extra ;; gentoo) expected_dest_loc=kernel/extra mod_compression_ext= distro_sign_file_candidates="/usr/src/linux-${KERNEL_VER}/scripts/sign-file" distro_modsigkey=/root/kernel_key.pem distro_modsigcert=/root/kernel_cert.pem echo "MODULES_SIGN_KEY=${distro_modsigkey}" >> /etc/portage/make.conf echo "MODULES_SIGN_CERT=${distro_modsigcert}" >> /etc/portage/make.conf ;; *) echo >&2 "Error: unknown Linux distribution ID ${os_id}" exit 1 ;; esac echo "Checking module compression ..." echo "config: $(grep "^CONFIG_MODULE_COMPRESS" "${kernel_config}" || true)" echo "files: $(find "/lib/modules/${KERNEL_VER}" -name \*.ko\* 2>/dev/null | head -n1)" echo "Expected extension: ${mod_compression_ext:-(none)}" for sign_file in $distro_sign_file_candidates \ "/lib/modules/${KERNEL_VER}/build/scripts/sign-file" do [[ ! -x $sign_file ]] || break done SIGNING_PROLOGUE_command="Sign command: ${sign_file}" SIGNING_PROLOGUE_key="Signing key: ${distro_modsigkey}" SIGNING_PROLOGUE_cert="Public certificate (MOK): ${distro_modsigcert}" if [[ $sign_file = "/usr/bin/kmodsign" ]]; then SIGNING_PROLOGUE_key="Signing key: /var/lib/shim-signed/mok/MOK.priv" SIGNING_PROLOGUE_cert="Public certificate (MOK): /var/lib/shim-signed/mok/MOK.der" fi if (( NO_SIGNING_TOOL == 0 )); then SIGNING_PROLOGUE="${SIGNING_PROLOGUE_command} ${SIGNING_PROLOGUE_key} ${SIGNING_PROLOGUE_cert} " else SIGNING_PROLOGUE="The kernel is built without module signing facility, modules won't be signed " fi DKMS_VERSION="$(dkms --version)" echo 'Preparing a clean test environment' clean_dkms_env echo 'Test that there are no dkms modules installed' run_with_expected_output dkms status -k "${KERNEL_VER}" << EOF EOF echo 'Test framework file hijacking' mkdir -p /etc/dkms/framework.conf.d/ install_framework_conf test/framework/hijacking.conf /etc/dkms/framework.conf.d/dkms_test_framework.conf run_with_expected_output dkms status -m dkms_test << EOF EOF rm /etc/dkms/framework.conf.d/dkms_test_framework.conf only="${1:-}" [[ $only ]] && echo "Running only '$only' tests" if [[ ! $only || $only = basic ]]; then ############################################################################ echo '*** Testing dkms on a regular module' ############################################################################ echo 'Adding the test module by version (expected error)' run_with_expected_error 2 dkms add -m dkms_test -v 1.0 << EOF Error! Could not find module source directory. Directory: /usr/src/dkms_test-1.0 does not exist. EOF echo 'Adding the test module by directory' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Adding the test module by directory again (expected error)' run_with_expected_error 3 dkms add test/dkms_test-1.0 << EOF Error! DKMS tree already contains: dkms_test/1.0 You cannot add the same module/version combo more than once. EOF echo 'Removing the test module' run_with_expected_output dkms remove --all -m dkms_test -v 1.0 << EOF Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF remove_module_source_tree /usr/src/dkms_test-1.0 echo 'Adding the test module by config file' run_with_expected_output dkms add test/dkms_test-1.0/dkms.conf << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Adding the test module by config file again (expected error)' run_with_expected_error 3 dkms add test/dkms_test-1.0/dkms.conf << EOF Error! DKMS tree already contains: dkms_test/1.0 You cannot add the same module/version combo more than once. EOF echo 'Removing the test module' run_with_expected_output dkms remove --all -m dkms_test -v 1.0 << EOF Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF echo 'Adding the test module by version' run_with_expected_output dkms add -m dkms_test -v 1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Adding the test module by version again (expected error)' run_with_expected_error 3 dkms add -m dkms_test -v 1.0 << EOF Error! DKMS tree already contains: dkms_test/1.0 You cannot add the same module/version combo more than once. EOF echo 'Building the test module' set_signing_message "dkms_test" "1.0" run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Checking make.log content' check_make_log_content "/var/lib/dkms/dkms_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/log/make.log" << EOF DKMS (${DKMS_VERSION}) make.log for dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s) # command: make -j1 KERNELRELEASE=${KERNEL_VER} -C /lib/modules/${KERNEL_VER}/build M=/var/lib/dkms/dkms_test/1.0/build CC dkms_test.o CC dkms_test.mod.o LD dkms_test.ko # exit code: 0 # elapsed time: ---------------------------------------------------------------- EOF echo 'Building the test module again' run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 already built for kernel ${KERNEL_VER} (${KERNEL_ARCH}), skip. You may override by specifying --force. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Building the test module for a kernel without headers installed (expected error)' run_with_expected_error 21 dkms build -k "${KERNEL_VER}-noheaders" -m dkms_test -v 1.0 << EOF Error! Your kernel headers for kernel ${KERNEL_VER}-noheaders cannot be found at /lib/modules/${KERNEL_VER}-noheaders/build or /lib/modules/${KERNEL_VER}-noheaders/source. Please install the linux-headers-${KERNEL_VER}-noheaders package or use the --kernelsourcedir option to tell DKMS where it's located. EOF echo 'Building the test module for more than one kernel version (same version twice for this test)' run_with_expected_output dkms build -k "${KERNEL_VER}" -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 already built for kernel ${KERNEL_VER} (${KERNEL_ARCH}), skip. You may override by specifying --force. Module dkms_test/1.0 already built for kernel ${KERNEL_VER} (${KERNEL_ARCH}), skip. You may override by specifying --force. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Building the test module again by force' run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 --force << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Installing the test module' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF if ! [[ -f "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" ]] ; then echo >&2 "Error: module not found in /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" exit 1 fi echo 'Installing the test module again' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 already installed on kernel ${KERNEL_VER} (${KERNEL_ARCH}), skip. You may override by specifying --force. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Installing the test module again by force' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 --force << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Checking modinfo' run_with_expected_output sh -c "$(declare -f modinfo_quad); modinfo_quad /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" << EOF description: A Simple dkms test module filename: /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} license: GPL version: 1.0 EOF echo 'Enable post-transaction command and install the module' mkdir -p /etc/dkms/framework.conf.d/ install_framework_conf test/framework/post_transaction.conf /etc/dkms/framework.conf.d/dkms_test_framework.conf run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 --force << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Executing post-transaction command... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Checking post_transacion.log content' check_make_log_content "/var/lib/dkms/post_transaction.log" << EOF # command: echo This is a test message as post transaction. Kernel version is ${KERNEL_VER} This is a test message as post transaction. Kernel version is ${KERNEL_VER} # exit code: 0 # elapsed time: ---------------------------------------------------------------- EOF rm /etc/dkms/framework.conf.d/dkms_test_framework.conf echo 'Uninstalling the test module' run_with_expected_output dkms uninstall -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF if [[ -e "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" ]] ; then echo >&2 "Error: module not removed in /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" exit 1 fi echo 'Uninstalling the test module again' run_with_expected_output dkms uninstall -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Unbuilding the test module' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Unbuilding the test module again' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Removing the test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF if ! [[ -d /usr/src/dkms_test-1.0 ]] ; then echo >&2 'Error: directory /usr/src/dkms_test-1.0 was removed' exit 1 fi echo 'Installing the test module by version (combining add, build, install)' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF if ! [[ -f "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" ]] ; then echo >&2 "Error: module not found in /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" exit 1 fi echo 'Checking modinfo' run_with_expected_output sh -c "$(declare -f modinfo_quad); modinfo_quad /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" << EOF description: A Simple dkms test module filename: /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} license: GPL version: 1.0 EOF echo 'Removing the test module with --all' run_with_expected_output dkms remove --all -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF if [[ -e "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" ]] ; then echo >&2 "Error: module not removed in /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" exit 1 fi remove_module_source_tree /usr/src/dkms_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # basic tests if [[ ! $only || $only = signing ]]; then if (( NO_SIGNING_TOOL == 0 )); then ############################################################################ echo '*** Testing module signing' ############################################################################ echo 'Adding the test module' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Building the test module with bad sign_file path in framework file' install_framework_conf test/framework/bad_sign_file_path.conf /etc/dkms/framework.conf.d/dkms_test_framework.conf run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 --force << EOF Sign command: /no/such/file Binary /no/such/file not found, modules won't be signed Building module(s)... done. EOF echo 'Building the test module with bad mok_signing_key path in framework file' install_framework_conf test/framework/bad_key_file_path.conf /etc/dkms/framework.conf.d/dkms_test_framework.conf run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 --force << EOF ${SIGNING_PROLOGUE_command} Signing key: /no/such/path.key Public certificate (MOK): /var/lib/dkms/mok.pub Key file /no/such/path.key not found and can't be generated, modules won't be signed Building module(s)... done. EOF echo 'Building the test module with bad mok_certificate path in framework file' install_framework_conf test/framework/bad_cert_file_path.conf /etc/dkms/framework.conf.d/dkms_test_framework.conf run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 --force << EOF ${SIGNING_PROLOGUE_command} Signing key: ${tmpdir}/dkms_test_private_key Public certificate (MOK): /no/such/path.crt Certificate file /no/such/path.crt not found and can't be generated, modules won't be signed Building module(s)... done. EOF echo 'Building the test module with a failing sign_file command' install_framework_conf test/framework/fail_sign_file_path.conf /etc/dkms/framework.conf.d/dkms_test_framework.conf run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 --force << EOF Sign command: /bin/false Signing key: ${tmpdir}/dkms_test_private_key Public certificate (MOK): ${tmpdir}/dkms_test_certificate Building module(s)... done.${SIGNING_MESSAGE} Warning: Failed to sign module '/var/lib/dkms/dkms_test/1.0/build/dkms_test.ko'! EOF rm "${tmpdir}/dkms_test_private_key" echo 'Building the test module with path contains variables in framework file' mkdir "${tmpdir}/dkms_test_dir_${KERNEL_VER}/" install_framework_conf test/framework/variables_in_path.conf /etc/dkms/framework.conf.d/dkms_test_framework.conf run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 --force << EOF Sign command: /lib/modules/${KERNEL_VER}/build/scripts/sign-file Signing key: ${tmpdir}/dkms_test_dir_${KERNEL_VER}/key Public certificate (MOK): ${tmpdir}/dkms_test_dir_${KERNEL_VER}/cert Building module(s)... done.${SIGNING_MESSAGE} EOF rm -r "${tmpdir}/dkms_test_dir_${KERNEL_VER}/" BUILT_MODULE_PATH="/var/lib/dkms/dkms_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/module/dkms_test.ko${mod_compression_ext}" CURRENT_HASH="$(modinfo -F sig_hashalgo "${BUILT_MODULE_PATH}")" install_framework_conf test/framework/temp_key_cert.conf /etc/dkms/framework.conf.d/dkms_test_framework.conf SIGNING_PROLOGUE_tmp_key_cert="${SIGNING_PROLOGUE_command} Signing key: ${tmpdir}/dkms_test_private_key Public certificate (MOK): ${tmpdir}/dkms_test_certificate " echo 'Building the test module using a different hash algorithm' if kmod_broken_hashalgo; then echo ' Current kmod has broken hash algorithm code. Skipping...' elif [[ "${CURRENT_HASH}" == "unknown" ]]; then echo ' Current kmod reports unknown hash algorithm. Skipping...' else if [[ "${CURRENT_HASH}" == "sha512" ]]; then ALTER_HASH="sha256" else ALTER_HASH="sha512" fi echo "CONFIG_MODULE_SIG_HASH=\"${ALTER_HASH}\"" > "${tmpdir}/dkms_test_kconfig" run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 --config "${tmpdir}/dkms_test_kconfig" --force << EOF ${SIGNING_PROLOGUE_tmp_key_cert} Building module(s)... done.${SIGNING_MESSAGE} EOF run_with_expected_output sh -c "modinfo -F sig_hashalgo '${BUILT_MODULE_PATH}'" << EOF ${ALTER_HASH} EOF rm "${tmpdir}/dkms_test_kconfig" fi echo 'Building the test module again by force' run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 --force << EOF ${SIGNING_PROLOGUE_tmp_key_cert} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo ' Extracting serial number (aka sig_key in modinfo) from the certificate' CERT_SERIAL="$(cert_serial "${tmpdir}/dkms_test_certificate")" echo 'Installing the test module' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Checking modinfo' run_with_expected_output sh -c "$(declare -f modinfo_quad); modinfo_quad /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" << EOF description: A Simple dkms test module filename: /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} license: GPL version: 1.0 EOF echo ' Checking module signature' SIG_KEY="$(modinfo -F sig_key "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" | tr -d ':')" SIG_HASH="$(modinfo -F sig_hashalgo "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}")" if kmod_broken_hashalgo; then echo ' Current kmod has broken hash algorithm code. Skipping...' elif [[ "${SIG_HASH}" == "unknown" ]]; then echo ' Current kmod reports unknown hash algorithm. Skipping...' elif [[ ! "${SIG_KEY}" ]]; then # kmod may not be linked with openssl and thus can't extract the key from module echo >&2 "Error: module was not signed, or key is unknown" exit 1 else run_with_expected_output sh -c "echo '${SIG_KEY}'" << EOF ${CERT_SERIAL} EOF fi echo 'Removing the test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF remove_module_source_tree /usr/src/dkms_test-1.0 echo 'Installing the test module (combining add, build, install)' run_with_expected_output dkms install -k "${KERNEL_VER}" test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 ${SIGNING_PROLOGUE_tmp_key_cert} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Checking modinfo' run_with_expected_output sh -c "$(declare -f modinfo_quad); modinfo_quad /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" << EOF description: A Simple dkms test module filename: /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} license: GPL version: 1.0 EOF echo ' Checking module signature' SIG_KEY="$(modinfo -F sig_key "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" | tr -d ':')" SIG_HASH="$(modinfo -F sig_hashalgo "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}")" if kmod_broken_hashalgo; then echo ' Current kmod has broken hash algorithm code. Skipping...' elif [[ "${SIG_HASH}" == "unknown" ]]; then echo ' Current kmod reports unknown hash algorithm. Skipping...' elif [[ ! "${SIG_KEY}" ]]; then # kmod may not be linked with openssl and thus can't extract the key from module echo >&2 "Error: module was not signed, or key is unknown" exit 1 else run_with_expected_output sh -c "echo '${SIG_KEY}'" << EOF ${CERT_SERIAL} EOF fi echo 'Removing the test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF echo 'Removing temporary files' rm "${tmpdir}/dkms_test_private_key" "${tmpdir}/dkms_test_certificate" rm /etc/dkms/framework.conf.d/dkms_test_framework.conf remove_module_source_tree /usr/src/dkms_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi fi # signing tests if [[ ! $only || $only = autoinstall ]]; then ############################################################################ echo '*** Testing dkms autoinstall/kernel_{postinst/prerm}, dkms_autoinstaller' ############################################################################ echo 'Testing without modules and without headers' echo ' Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}-noheaders" << EOF EOF if [[ -x /usr/lib/dkms/dkms_autoinstaller ]]; then echo ' Running dkms_autoinstaller' run_with_expected_output /usr/lib/dkms/dkms_autoinstaller start "${KERNEL_VER}-noheaders" << EOF Automatic installation of modules for kernel ${KERNEL_VER}-noheaders was skipped since the kernel headers for this kernel do not seem to be installed. EOF fi echo ' Running dkms kernel_postinst' run_with_expected_output dkms kernel_postinst -k "${KERNEL_VER}-noheaders" << EOF EOF echo ' Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}-noheaders" << EOF EOF echo 'Testing without modules but with /etc/dkms/no-autoinstall' touch /etc/dkms/no-autoinstall echo ' Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF Automatic installation of modules has been disabled. EOF if [[ -x /usr/lib/dkms/dkms_autoinstaller ]]; then echo ' Running dkms_autoinstaller' run_with_expected_output /usr/lib/dkms/dkms_autoinstaller start "${KERNEL_VER}" << EOF Automatic installation of modules has been disabled. EOF fi echo ' Running dkms kernel_postinst' run_with_expected_output dkms kernel_postinst -k "${KERNEL_VER}" << EOF Automatic installation of modules has been disabled. EOF echo ' Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF EOF rm -f /etc/dkms/no-autoinstall echo 'Testing without modules' echo ' Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF EOF if [[ -x /usr/lib/dkms/dkms_autoinstaller ]]; then echo ' Running dkms_autoinstaller' run_with_expected_output /usr/lib/dkms/dkms_autoinstaller start "${KERNEL_VER}" << EOF EOF fi echo ' Running dkms kernel_postinst' run_with_expected_output dkms kernel_postinst -k "${KERNEL_VER}" << EOF EOF echo ' Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF EOF echo 'Building the test module by config file (combining add, build)' run_with_expected_output dkms build -k "${KERNEL_VER}" test/dkms_test-1.0/dkms.conf << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Running dkms autoinstall (module built but not installed)' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Unbuilding the test module' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Testing without headers' echo ' Running dkms autoinstall (expected error)' run_with_expected_error 21 dkms autoinstall -k "${KERNEL_VER}-noheaders" << EOF Error! Your kernel headers for kernel ${KERNEL_VER}-noheaders cannot be found at /lib/modules/${KERNEL_VER}-noheaders/build or /lib/modules/${KERNEL_VER}-noheaders/source. Please install the linux-headers-${KERNEL_VER}-noheaders package or use the --kernelsourcedir option to tell DKMS where it's located. EOF if [[ -x /usr/lib/dkms/dkms_autoinstaller ]]; then echo ' Running dkms_autoinstaller' run_with_expected_output /usr/lib/dkms/dkms_autoinstaller start "${KERNEL_VER}-noheaders" << EOF Automatic installation of modules for kernel ${KERNEL_VER}-noheaders was skipped since the kernel headers for this kernel do not seem to be installed. EOF fi echo ' Running dkms kernel_postinst (expected error)' run_with_expected_error 21 dkms kernel_postinst -k "${KERNEL_VER}-noheaders" << EOF Error! Your kernel headers for kernel ${KERNEL_VER}-noheaders cannot be found at /lib/modules/${KERNEL_VER}-noheaders/build or /lib/modules/${KERNEL_VER}-noheaders/source. Please install the linux-headers-${KERNEL_VER}-noheaders package or use the --kernelsourcedir option to tell DKMS where it's located. EOF echo ' Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}-noheaders" << EOF EOF echo 'Testing with /etc/dkms/no-autoinstall' touch /etc/dkms/no-autoinstall echo ' Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF Automatic installation of modules has been disabled. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF if [[ -x /usr/lib/dkms/dkms_autoinstaller ]]; then echo ' Running dkms_autoinstaller' run_with_expected_output /usr/lib/dkms/dkms_autoinstaller start "${KERNEL_VER}" << EOF Automatic installation of modules has been disabled. EOF fi echo ' Running dkms kernel_postinst' run_with_expected_output dkms kernel_postinst -k "${KERNEL_VER}" << EOF Automatic installation of modules has been disabled. EOF echo ' Installing the test module' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF echo ' Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF dkms: removing module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF rm -f /etc/dkms/no-autoinstall echo 'Running dkms autoinstall --all (expected error)' run_with_expected_error 5 dkms autoinstall --all << EOF Error! The action autoinstall does not support the --all parameter. EOF echo 'Running dkms autoinstall for more than one kernel version (same version twice for this test) (expected error)' run_with_expected_error 4 dkms autoinstall -k "${KERNEL_VER}" -k "${KERNEL_VER}" << EOF Error! The action autoinstall does not support multiple kernel version parameters on the command line. EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms autoinstall again' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF if [[ -x /usr/lib/dkms/dkms_autoinstaller ]]; then echo 'Unbuilding the test module' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Running dkms_autoinstaller' run_with_expected_output /usr/lib/dkms/dkms_autoinstaller start "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms_autoinstaller again' run_with_expected_output /usr/lib/dkms/dkms_autoinstaller start "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF fi echo 'Running dkms kernel_prerm w/o kernel argument (expected error)' run_with_expected_error 4 dkms kernel_prerm << EOF Error! The action kernel_prerm requires exactly one kernel version parameter on the command line. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF dkms: removing module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Running dkms kernel_prerm again' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Building the test module' run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Running dkms kernel_prerm (module built but not installed)' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF dkms: removing module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Running dkms kernel_postinst w/o kernel argument (expected error)' run_with_expected_error 4 dkms kernel_postinst << EOF Error! The action kernel_postinst requires exactly one kernel version parameter on the command line. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Running dkms kernel_postinst' run_with_expected_output dkms kernel_postinst -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms kernel_postinst again' run_with_expected_output dkms kernel_postinst -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Removing the test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF remove_module_source_tree /usr/src/dkms_test-1.0 echo 'Adding failing test module' run_with_expected_output dkms add test/dkms_failing_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_failing_test/1.0/source -> /usr/src/dkms_failing_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_failing_test-1.0 echo ' Running autoinstall with failing test module (expected error)' run_with_expected_error 11 dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_failing_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)...(bad exit status: 2) Failed command: make -j1 KERNELRELEASE=${KERNEL_VER} all Error! Bad return status for module build on kernel: ${KERNEL_VER} (${KERNEL_ARCH}) Consult /var/lib/dkms/dkms_failing_test/1.0/build/make.log for more information. Autoinstall on ${KERNEL_VER} failed for module(s) dkms_failing_test(10). Error! One or more modules failed to install during autoinstall. Refer to previous errors for more information. EOF if [[ -x /usr/lib/dkms/dkms_autoinstaller ]]; then echo ' Running dkms_autoinstaller with failing test module (expected error)' run_with_expected_error 1 /usr/lib/dkms/dkms_autoinstaller start "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_failing_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)...(bad exit status: 2) Failed command: make -j1 KERNELRELEASE=${KERNEL_VER} all Error! Bad return status for module build on kernel: ${KERNEL_VER} (${KERNEL_ARCH}) Consult /var/lib/dkms/dkms_failing_test/1.0/build/make.log for more information. Autoinstall on ${KERNEL_VER} failed for module(s) dkms_failing_test(10). Error! One or more modules failed to install during autoinstall. Refer to previous errors for more information. EOF fi echo ' Running dkms kernel_postinst with failing test module (expected error)' run_with_expected_error 11 dkms kernel_postinst -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_failing_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)...(bad exit status: 2) Failed command: make -j1 KERNELRELEASE=${KERNEL_VER} all Error! Bad return status for module build on kernel: ${KERNEL_VER} (${KERNEL_ARCH}) Consult /var/lib/dkms/dkms_failing_test/1.0/build/make.log for more information. Autoinstall on ${KERNEL_VER} failed for module(s) dkms_failing_test(10). Error! One or more modules failed to install during autoinstall. Refer to previous errors for more information. EOF echo ' Removing failing test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_failing_test -v 1.0 << EOF Module dkms_failing_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_failing_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_failing_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_failing_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # autoinstall tests if [[ ! $only || $only = noautoinstall ]]; then ############################################################################ echo '*** Testing dkms on a module with AUTOINSTALL=""' ############################################################################ echo 'Adding the noautoinstall test module' run_with_expected_output dkms add test/dkms_noautoinstall_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_noautoinstall_test/1.0/source -> /usr/src/dkms_noautoinstall_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_noautoinstall_test-1.0 run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF if [[ -x /usr/lib/dkms/dkms_autoinstaller ]]; then echo 'Running dkms_autoinstaller' run_with_expected_output /usr/lib/dkms/dkms_autoinstaller start "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF fi echo 'Running dkms kernel_postinst' run_with_expected_output dkms kernel_postinst -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF echo 'Building the noautoinstall test module' set_signing_message "dkms_noautoinstall_test" "1.0" run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_noautoinstall_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Installing the noautoinstall test module' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_noautoinstall_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_noautoinstall_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF dkms: removing module dkms_noautoinstall_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_noautoinstall_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_noautoinstall_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF echo 'Installing the noautoinstall test module' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_noautoinstall_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_noautoinstall_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Uninstalling the noautoinstall test module' run_with_expected_output dkms uninstall -k "${KERNEL_VER}" -m dkms_noautoinstall_test -v 1.0 << EOF Module dkms_noautoinstall_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_noautoinstall_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Unbuilding the noautoinstall test module' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_noautoinstall_test -v 1.0 << EOF Module dkms_noautoinstall_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF echo 'Removing the noautoinstall test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_noautoinstall_test -v 1.0 << EOF Module dkms_noautoinstall_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_noautoinstall_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_noautoinstall_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF EOF remove_module_source_tree /usr/src/dkms_noautoinstall_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # noautoinstall tests if [[ ! $only || $only = dependencies ]]; then ############################################################################ echo '*** Testing dkms modules with dependencies' ############################################################################ set_signing_message "dkms_dependencies_test" "1.0" SIGNING_MESSAGE_dependencies="$SIGNING_MESSAGE" set_signing_message "dkms_test" "1.0" echo 'Adding the prerequisite test module' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF EOF echo 'Adding test module with dependencies' run_with_expected_output dkms add test/dkms_dependencies_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_dependencies_test/1.0/source -> /usr/src/dkms_dependencies_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_dependencies_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE_dependencies} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test dkms_dependencies_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF dkms: removing module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_test.ko${mod_compression_ext} dkms: removing module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF echo 'Running dkms kernel_prerm again' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall of module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE_dependencies} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test dkms_dependencies_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms autoinstall again' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Removing the test module with dependencies' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_dependencies_test -v 1.0 << EOF Module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_dependencies_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF EOF echo 'Removing the prerequisite test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF EOF remove_module_source_tree /usr/src/dkms_test-1.0 /usr/src/dkms_dependencies_test-1.0 echo 'Adding test module with unsatisfied dependencies' run_with_expected_output dkms add test/dkms_dependencies_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_dependencies_test/1.0/source -> /usr/src/dkms_dependencies_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_dependencies_test-1.0 run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF echo 'Building the test module with unsatisfied dependencies (expected error)' run_with_expected_error 13 dkms build -k "${KERNEL_VER}" -m dkms_dependencies_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Error! Aborting build of module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) due to missing BUILD_DEPENDS: dkms_test. You may override by specifying --force. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF echo 'Building the test module with unsatisfied dependencies by force' run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_dependencies_test -v 1.0 --force << EOF ${SIGNING_PROLOGUE} Warning: Trying to build module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) despite of missing BUILD_DEPENDS: dkms_test. Building module(s)... done.${SIGNING_MESSAGE_dependencies} EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Installing the test module with unsatisfied dependencies' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_dependencies_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo "Running dkms autoinstall" run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Unbuilding the test module with unsatisfied dependencies' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_dependencies_test -v 1.0 << EOF Module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF echo "Running dkms autoinstall (expected error)" run_with_expected_error 11 dkms autoinstall -k "${KERNEL_VER}" << EOF dkms_dependencies_test/1.0 autoinstall failed due to missing dependencies: dkms_test. Error! One or more modules failed to install during autoinstall. Refer to previous errors for more information. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF echo 'Removing the test module with unsatisfied dependencies' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_dependencies_test -v 1.0 << EOF Module dkms_dependencies_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_dependencies_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_dependencies_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF EOF remove_module_source_tree /usr/src/dkms_dependencies_test-1.0 echo 'Adding test module with circular dependencies' set_signing_message "dkms_circular_dependencies_test" "1.0" run_with_expected_output dkms add test/dkms_circular_dependencies_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_circular_dependencies_test/1.0/source -> /usr/src/dkms_circular_dependencies_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_circular_dependencies_test-1.0 run_status_with_expected_output 'dkms_circular_dependencies_test' << EOF dkms_circular_dependencies_test/1.0: added EOF echo "Running dkms autoinstall (expected error)" run_with_expected_error 11 dkms autoinstall -k "${KERNEL_VER}" << EOF dkms_circular_dependencies_test/1.0 autoinstall failed due to missing dependencies: dkms_circular_dependencies_test. Error! One or more modules failed to install during autoinstall. Refer to previous errors for more information. EOF run_status_with_expected_output 'dkms_circular_dependencies_test' << EOF dkms_circular_dependencies_test/1.0: added EOF echo 'Building the test module with circular dependencies (expected error)' run_with_expected_error 13 dkms build -k "${KERNEL_VER}" -m dkms_circular_dependencies_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Error! Aborting build of module dkms_circular_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) due to missing BUILD_DEPENDS: dkms_circular_dependencies_test. You may override by specifying --force. EOF run_status_with_expected_output 'dkms_circular_dependencies_test' << EOF dkms_circular_dependencies_test/1.0: added EOF echo 'Building the test module with circular dependencies by force' run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_circular_dependencies_test -v 1.0 --force << EOF ${SIGNING_PROLOGUE} Warning: Trying to build module dkms_circular_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) despite of missing BUILD_DEPENDS: dkms_circular_dependencies_test. Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_circular_dependencies_test' << EOF dkms_circular_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Installing the test module with circular dependencies' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_circular_dependencies_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_circular_dependencies_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_circular_dependencies_test' << EOF dkms_circular_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Removing the test module with circular dependencies' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_circular_dependencies_test -v 1.0 << EOF Module dkms_circular_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_circular_dependencies_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_circular_dependencies_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_circular_dependencies_test' << EOF EOF remove_module_source_tree /usr/src/dkms_circular_dependencies_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # dependencies tests if [[ ! $only || $only = rebuild_dependencies ]]; then ############################################################################ echo '*** Testing dkms modules with dependencies and rebuild requirements' ############################################################################ set_signing_message "dkms_dependencies_rebuild_test" "1.0" SIGNING_MESSAGE_rebuild_dependencies="$SIGNING_MESSAGE" set_signing_message "dkms_test" "2.0" SIGNING_MESSAGE_updated_dependency="$SIGNING_MESSAGE" set_signing_message "dkms_test" "1.0" echo 'Adding the prerequisite test module' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF EOF echo 'Adding test module with dependencies' run_with_expected_output dkms add test/dkms_dependencies_rebuild_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_dependencies_rebuild_test/1.0/source -> /usr/src/dkms_dependencies_rebuild_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_dependencies_rebuild_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0: added EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE_rebuild_dependencies} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test dkms_dependencies_rebuild_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo ' Checking the dependency version' run_with_expected_output cat /var/lib/dkms/dkms_dependencies_rebuild_test/kernel-"${KERNEL_VER}"-"${KERNEL_ARCH}"/.dep_dkms_test << EOF 1.0 EOF echo 'Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF dkms: removing module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} dkms: removing module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0: added EOF echo 'Running dkms kernel_prerm again' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0: added EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall of module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE_rebuild_dependencies} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test dkms_dependencies_rebuild_test. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms autoinstall again' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Removing the prerequisite test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF remove_module_source_tree /usr/src/dkms_test-1.0 echo 'Adding the updated prerequisite test module' run_with_expected_output dkms add test/dkms_test-2.0 << EOF Creating symlink /var/lib/dkms/dkms_test/2.0/source -> /usr/src/dkms_test-2.0 EOF check_module_source_tree_created /usr/src/dkms_test-2.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/2.0: added EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Building and installing the updated prerequisite test module and trigger rebuild of the dependent module' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 2.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE_updated_dependency} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Rebuilding module dkms_dependencies_rebuild_test/1.0 due to updated dependencies Module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} Running depmod... done. Building module(s)... done.${SIGNING_MESSAGE_rebuild_dependencies} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo ' Checking the updated dependency version after the rebuild' run_with_expected_output cat /var/lib/dkms/dkms_dependencies_rebuild_test/kernel-"${KERNEL_VER}"-"${KERNEL_ARCH}"/.dep_dkms_test << EOF 2.0 EOF echo 'Removing the updated prerequisite test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 2.0 << EOF Module dkms_test/2.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/2.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF remove_module_source_tree /usr/src/dkms_test-2.0 echo 'Adding the downgraded prerequisite test module' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Building and installing the downgraded prerequisite test module and trigger rebuild of the dependent module' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Rebuilding module dkms_dependencies_rebuild_test/1.0 due to updated dependencies Module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} Running depmod... done. Building module(s)... done.${SIGNING_MESSAGE_rebuild_dependencies} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo ' Checking the updated dependency version after the rebuild' run_with_expected_output cat /var/lib/dkms/dkms_dependencies_rebuild_test/kernel-"${KERNEL_VER}"-"${KERNEL_ARCH}"/.dep_dkms_test << EOF 1.0 EOF echo 'Removing the test module with dependencies' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_dependencies_rebuild_test -v 1.0 << EOF Module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_dependencies_rebuild_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF EOF echo 'Removing the downgraded prerequisite test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF EOF remove_module_source_tree /usr/src/dkms_test-1.0 /usr/src/dkms_dependencies_rebuild_test-1.0 echo 'Adding test module with unsatisfied dependencies' run_with_expected_output dkms add test/dkms_dependencies_rebuild_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_dependencies_rebuild_test/1.0/source -> /usr/src/dkms_dependencies_rebuild_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_dependencies_rebuild_test-1.0 run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0: added EOF echo 'Building the test module with unsatisfied dependencies (expected error)' run_with_expected_error 13 dkms build -k "${KERNEL_VER}" -m dkms_dependencies_rebuild_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Error! Aborting build of module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) due to missing BUILD_DEPENDS: dkms_test. You may override by specifying --force. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0: added EOF echo 'Building the test module with unsatisfied dependencies by force (expected success, ignoring build dependencies)' run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_dependencies_rebuild_test -v 1.0 --force << EOF ${SIGNING_PROLOGUE} Warning: Trying to build module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) despite of missing BUILD_DEPENDS: dkms_test. Building module(s)... done.${SIGNING_MESSAGE_rebuild_dependencies} EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo ' Checking there is no dependency version generated when ignoring build dependencies' file_not_exists /var/lib/dkms/dkms_dependencies_rebuild_test/kernel-"${KERNEL_VER}"-"${KERNEL_ARCH}"/.dep_dkms_test echo 'Installing the test module with unsatisfied dependencies' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_dependencies_rebuild_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo "Running dkms autoinstall" run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Unbuilding the test module with unsatisfied dependencies' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_dependencies_rebuild_test -v 1.0 << EOF Module dkms_dependencies_rebuild_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_rebuild_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0: added EOF echo "Running dkms autoinstall (expected error)" run_with_expected_error 11 dkms autoinstall -k "${KERNEL_VER}" << EOF dkms_dependencies_rebuild_test/1.0 autoinstall failed due to missing dependencies: dkms_test. Error! One or more modules failed to install during autoinstall. Refer to previous errors for more information. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF dkms_dependencies_rebuild_test/1.0: added EOF echo 'Removing the test module with unsatisfied dependencies' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_dependencies_rebuild_test -v 1.0 << EOF Module dkms_dependencies_rebuild_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_dependencies_rebuild_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_dependencies_rebuild_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF run_status_with_expected_output 'dkms_dependencies_rebuild_test' << EOF EOF remove_module_source_tree /usr/src/dkms_dependencies_rebuild_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # rebuild_dependencies tests if [[ ! $only || $only = replace ]]; then ############################################################################ echo '*** Testing replacement of a pre-existing module' ############################################################################ # This feature is intended to replace modules that are shipped with the # kernel image by a newer version, not for supporting different dkms # modules with conflicting module names. # Only for this test the to-be-replaced module is also a dkms module. echo 'Adding, building and installing the to-be-replaced test module' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF set_signing_message "dkms_test" "1.0" run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Adding, building and installing the replacement test module' run_with_expected_output dkms add test/dkms_replace_test-2.0 << EOF Creating symlink /var/lib/dkms/dkms_replace_test/2.0/source -> /usr/src/dkms_replace_test-2.0 EOF check_module_source_tree_created /usr/src/dkms_replace_test-2.0 run_status_with_expected_output 'dkms_replace_test' << EOF dkms_replace_test/2.0: added EOF set_signing_message "dkms_replace_test" "2.0" "dkms_test" run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_replace_test -v 2.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Found pre-existing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}, archiving for uninstallation Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_replace_test' << EOF dkms_replace_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed (Original modules exist) EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed (Differences between built and installed modules) EOF echo 'Unbuilding the replacement test module' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_replace_test -v 2.0 << EOF Module dkms_replace_test/2.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Restoring archived original module /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_replace_test' << EOF dkms_replace_test/2.0: added EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_replace_test/2.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Found pre-existing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}, archiving for uninstallation Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test dkms_replace_test. EOF run_status_with_expected_output 'dkms_replace_test' << EOF dkms_replace_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed (Original modules exist) EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed (Differences between built and installed modules) EOF echo 'Running dkms autoinstall again' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_replace_test' << EOF dkms_replace_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed (Original modules exist) EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed (Differences between built and installed modules) EOF echo 'Removing the replacement test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_replace_test -v 2.0 << EOF Module dkms_replace_test/2.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Restoring archived original module /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_replace_test/2.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_replace_test' << EOF EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Removing the to-be-replaced test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_replace_test' << EOF EOF run_status_with_expected_output 'dkms_test' << EOF EOF remove_module_source_tree /usr/src/dkms_test-1.0 /usr/src/dkms_replace_test-2.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # replace tests if [[ ! $only || $only = multiple ]]; then ############################################################################ echo '*** Testing more dkms features' ############################################################################ echo 'Adding test module with patches' run_with_expected_output dkms add test/dkms_patches_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_patches_test/1.0/source -> /usr/src/dkms_patches_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_patches_test-1.0 run_status_with_expected_output 'dkms_patches_test' << EOF dkms_patches_test/1.0: added EOF echo 'Building and installing the test module with patches' set_signing_message "dkms_patches_test" "1.0" SIGNING_MESSAGE_patches="$SIGNING_MESSAGE" run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_patches_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Applying patch patch1.patch... done. Applying patch subdir/patch2.patch... done. Building module(s)... done.${SIGNING_MESSAGE_patches} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_patches_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_patches_test' << EOF dkms_patches_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Unbuilding the test module with patches' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_patches_test -v 1.0 << EOF Module dkms_patches_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_patches_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_patches_test' << EOF dkms_patches_test/1.0: added EOF echo 'Adding test module with pre/post scripts' run_with_expected_output dkms add test/dkms_scripts_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_scripts_test/1.0/source -> /usr/src/dkms_scripts_test-1.0 Running the post_add script: EOF check_module_source_tree_created /usr/src/dkms_scripts_test-1.0 run_status_with_expected_output 'dkms_scripts_test' << EOF dkms_scripts_test/1.0: added EOF echo 'Building and installing the test module with pre/post scripts' set_signing_message "dkms_scripts_test" "1.0" SIGNING_MESSAGE_scripts="$SIGNING_MESSAGE" run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_scripts_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Running the pre_build script... done. Building module(s)... done.${SIGNING_MESSAGE_scripts} Running the post_build script... done. Running the pre_install script: Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_scripts_test.ko${mod_compression_ext} Running the post_install script: Running depmod... done. EOF run_status_with_expected_output 'dkms_scripts_test' << EOF dkms_scripts_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Unbuilding the test module with pre/post scripts' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_scripts_test -v 1.0 << EOF Module dkms_scripts_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_scripts_test.ko${mod_compression_ext} Running the post_remove script: Running depmod... done. EOF run_status_with_expected_output 'dkms_scripts_test' << EOF dkms_scripts_test/1.0: added EOF echo 'Adding noisy test module' run_with_expected_output dkms add test/dkms_noisy_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_noisy_test/1.0/source -> /usr/src/dkms_noisy_test-1.0 Running the post_add script: /var/lib/dkms/dkms_noisy_test/1.0/source/script.sh post_add post_add: line 1 post_add: line 2/stderr post_add: line 3 post_add: line 4/stderr post_add: line 5 EOF check_module_source_tree_created /usr/src/dkms_noisy_test-1.0 run_status_with_expected_output 'dkms_noisy_test' << EOF dkms_noisy_test/1.0: added EOF echo 'Building and installing the noisy test module' set_signing_message "dkms_noisy_test" "1.0" SIGNING_MESSAGE_noisy="$SIGNING_MESSAGE" run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_noisy_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Applying patch patch2.patch... done. Applying patch patch1.patch... done. Running the pre_build script... done. Building module(s)... done.${SIGNING_MESSAGE_noisy} Running the post_build script... done. Running the pre_install script: /var/lib/dkms/dkms_noisy_test/1.0/source/script.sh pre_install pre_install: line 1 pre_install: line 2/stderr pre_install: line 3 pre_install: line 4/stderr pre_install: line 5 Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_noisy_test.ko${mod_compression_ext} Running the post_install script: /var/lib/dkms/dkms_noisy_test/1.0/source/script.sh post_install post_install: line 1 post_install: line 2/stderr post_install: line 3 post_install: line 4/stderr post_install: line 5 Running depmod... done. EOF run_status_with_expected_output 'dkms_noisy_test' << EOF dkms_noisy_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Checking make.log content' check_make_log_content "/var/lib/dkms/dkms_noisy_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/log/make.log" << EOF DKMS (${DKMS_VERSION}) make.log for dkms_noisy_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Applying patch patch2.patch # command: patch -p1 < ./patches/patch2.patch patching file Makefile patching file dkms_noisy_test.c # exit code: 0 # elapsed time: ---------------------------------------------------------------- Applying patch patch1.patch # command: patch -p1 < ./patches/patch1.patch patching file Makefile Hunk #1 succeeded at 3 (offset 2 lines). patching file dkms_noisy_test.c Hunk #1 succeeded at 18 (offset 2 lines). # exit code: 0 # elapsed time: ---------------------------------------------------------------- Running the pre_build script # command: cd /var/lib/dkms/dkms_noisy_test/1.0/build/ && /var/lib/dkms/dkms_noisy_test/1.0/build/script.sh pre_build /var/lib/dkms/dkms_noisy_test/1.0/build/script.sh pre_build pre_build: line 1 pre_build: line 2/stderr pre_build: line 3 pre_build: line 4/stderr pre_build: line 5 # exit code: 0 # elapsed time: ---------------------------------------------------------------- Building module(s) # command: make -j1 KERNELRELEASE=${KERNEL_VER} -C /lib/modules/${KERNEL_VER}/build M=/var/lib/dkms/dkms_noisy_test/1.0/build CC dkms_noisy_test.o CC dkms_noisy_test.mod.o LD dkms_noisy_test.ko # exit code: 0 # elapsed time: ---------------------------------------------------------------- Running the post_build script # command: cd /var/lib/dkms/dkms_noisy_test/1.0/build/ && /var/lib/dkms/dkms_noisy_test/1.0/build/script.sh post_build /var/lib/dkms/dkms_noisy_test/1.0/build/script.sh post_build post_build: line 1 post_build: line 2/stderr post_build: line 3 post_build: line 4/stderr post_build: line 5 # exit code: 0 # elapsed time: ---------------------------------------------------------------- EOF echo 'Unbuilding the noisy test module' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_noisy_test -v 1.0 << EOF Module dkms_noisy_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_noisy_test.ko${mod_compression_ext} Running the post_remove script: /var/lib/dkms/dkms_noisy_test/1.0/source/script.sh post_remove post_remove: line 1 post_remove: line 2/stderr post_remove: line 3 post_remove: line 4/stderr post_remove: line 5 Running depmod... done. EOF run_status_with_expected_output 'dkms_noisy_test' << EOF dkms_noisy_test/1.0: added EOF # neither remove the modules here nor run check_no_dkms_test, # keep them added for the next part ############################################################################ echo '*** Testing multiple dkms modules' ############################################################################ echo 'Adding test module with dependencies' run_with_expected_output dkms add test/dkms_dependencies_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_dependencies_test/1.0/source -> /usr/src/dkms_dependencies_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_dependencies_test-1.0 run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF echo 'Adding build-exclusive test module' run_with_expected_output dkms add test/dkms_build_exclusive_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_build_exclusive_test/1.0/source -> /usr/src/dkms_build_exclusive_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_build_exclusive_test-1.0 run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF echo 'Adding noautoinstall test module' run_with_expected_output dkms add test/dkms_noautoinstall_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_noautoinstall_test/1.0/source -> /usr/src/dkms_noautoinstall_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_noautoinstall_test-1.0 run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF echo 'Adding test module' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo "Running dkms autoinstall with multiple modules" set_signing_message "dkms_test" "1.0" run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_build_exclusive_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Warning: The /var/lib/dkms/dkms_build_exclusive_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/dkms.conf for module dkms_build_exclusive_test/1.0 includes a BUILD_EXCLUSIVE directive which does not match this kernel/arch/config. This indicates that it should not be built. Autoinstall of module dkms_noisy_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Applying patch patch2.patch... done. Applying patch patch1.patch... done. Running the pre_build script... done. Building module(s)... done.${SIGNING_MESSAGE_noisy} Running the post_build script... done. Running the pre_install script: /var/lib/dkms/dkms_noisy_test/1.0/source/script.sh pre_install pre_install: line 1 pre_install: line 2/stderr pre_install: line 3 pre_install: line 4/stderr pre_install: line 5 Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_noisy_test.ko${mod_compression_ext} Running the post_install script: /var/lib/dkms/dkms_noisy_test/1.0/source/script.sh post_install post_install: line 1 post_install: line 2/stderr post_install: line 3 post_install: line 4/stderr post_install: line 5 Running depmod... done. Autoinstall of module dkms_patches_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Applying patch patch1.patch... done. Applying patch subdir/patch2.patch... done. Building module(s)... done.${SIGNING_MESSAGE_patches} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_patches_test.ko${mod_compression_ext} Running depmod... done. Autoinstall of module dkms_scripts_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Running the pre_build script... done. Building module(s)... done.${SIGNING_MESSAGE_scripts} Running the post_build script... done. Running the pre_install script: Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_scripts_test.ko${mod_compression_ext} Running the post_install script: Running depmod... done. Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall of module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE_dependencies} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_noisy_test dkms_patches_test dkms_scripts_test dkms_test dkms_dependencies_test. Autoinstall on ${KERNEL_VER} was skipped for module(s) dkms_build_exclusive_test. EOF run_status_with_expected_output 'dkms_patches_test' << EOF dkms_patches_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_scripts_test' << EOF dkms_scripts_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_noisy_test' << EOF dkms_noisy_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo "Running dkms autoinstall again with multiple modules" run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_build_exclusive_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Warning: The /var/lib/dkms/dkms_build_exclusive_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/dkms.conf for module dkms_build_exclusive_test/1.0 includes a BUILD_EXCLUSIVE directive which does not match this kernel/arch/config. This indicates that it should not be built. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_dependencies_test dkms_noisy_test dkms_patches_test dkms_scripts_test dkms_test. Autoinstall on ${KERNEL_VER} was skipped for module(s) dkms_build_exclusive_test. EOF run_status_with_expected_output 'dkms_patches_test' << EOF dkms_patches_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_scripts_test' << EOF dkms_scripts_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_noisy_test' << EOF dkms_noisy_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Running dkms kernel_prerm' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF dkms: removing module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dependencies_test.ko${mod_compression_ext} dkms: removing module dkms_noisy_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_noisy_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_noisy_test.ko${mod_compression_ext} Running the post_remove script: /var/lib/dkms/dkms_noisy_test/1.0/source/script.sh post_remove post_remove: line 1 post_remove: line 2/stderr post_remove: line 3 post_remove: line 4/stderr post_remove: line 5 dkms: removing module dkms_patches_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_patches_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_patches_test.ko${mod_compression_ext} dkms: removing module dkms_scripts_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_scripts_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_scripts_test.ko${mod_compression_ext} Running the post_remove script: dkms: removing module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_patches_test' << EOF dkms_patches_test/1.0: added EOF run_status_with_expected_output 'dkms_scripts_test' << EOF dkms_scripts_test/1.0: added EOF run_status_with_expected_output 'dkms_noisy_test' << EOF dkms_noisy_test/1.0: added EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Running dkms kernel_prerm again' run_with_expected_output dkms kernel_prerm -k "${KERNEL_VER}" << EOF EOF run_status_with_expected_output 'dkms_patches_test' << EOF dkms_patches_test/1.0: added EOF run_status_with_expected_output 'dkms_scripts_test' << EOF dkms_scripts_test/1.0: added EOF run_status_with_expected_output 'dkms_noisy_test' << EOF dkms_noisy_test/1.0: added EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF dkms_dependencies_test/1.0: added EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF dkms_noautoinstall_test/1.0: added EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Removing the test module with patches' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_patches_test -v 1.0 << EOF Module dkms_patches_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_patches_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_patches_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_patches_test' << EOF EOF echo 'Removing the test module with pre/post scripts' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_scripts_test -v 1.0 << EOF Module dkms_scripts_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_scripts_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_scripts_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_scripts_test' << EOF EOF echo 'Removing the noisy test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_noisy_test -v 1.0 << EOF Module dkms_noisy_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_noisy_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_noisy_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_noisy_test' << EOF EOF echo 'Removing the test module with dependencies' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_dependencies_test -v 1.0 << EOF Module dkms_dependencies_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_dependencies_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_dependencies_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_dependencies_test' << EOF EOF echo 'Removing the build-exclusive test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_build_exclusive_test -v 1.0 << EOF Module dkms_build_exclusive_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_build_exclusive_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_build_exclusive_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF EOF echo 'Removing the noautoinstall test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_noautoinstall_test -v 1.0 << EOF Module dkms_noautoinstall_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_noautoinstall_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_noautoinstall_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_noautoinstall_test' << EOF EOF echo 'Removing the test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF remove_module_source_tree \ /usr/src/dkms_patches_test-1.0 \ /usr/src/dkms_scripts_test-1.0 \ /usr/src/dkms_noisy_test-1.0 \ /usr/src/dkms_dependencies_test-1.0 \ /usr/src/dkms_build_exclusive_test-1.0 \ /usr/src/dkms_noautoinstall_test-1.0 \ /usr/src/dkms_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # multiple tests if [[ ! $only || $only = malformed ]]; then ############################################################################ echo '*** Testing malformed/borderline dkms.conf' ############################################################################ abspwd=$(readlink -f "$(pwd)") echo 'Testing dkms add of source tree without dkms.conf (expected error)' run_with_expected_error 1 dkms add "${abspwd}/test/dkms_conf_test_no_conf" << EOF Error! Arguments and are not specified. Usage: add / or add -m / or add -m -v EOF echo 'Testing dkms add with empty dkms.conf (expected error)' run_with_expected_error 8 dkms add test/dkms_conf_test_empty << EOF dkms.conf: Error! No 'PACKAGE_NAME' directive specified. dkms.conf: Error! No 'PACKAGE_VERSION' directive specified. Error! Bad conf file. File: ${abspwd}/test/dkms_conf_test_empty/dkms.conf does not represent a valid dkms.conf file. EOF echo 'Testing dkms.conf with invalid values (expected error)' run_with_expected_error 8 dkms add test/dkms_conf_test_invalid << EOF dkms.conf: Error! No 'BUILT_MODULE_NAME' directive specified for record #0. dkms.conf: Error! 'DEST_MODULE_NAME' directive ends in '.o' or '.ko' in record #0. dkms.conf: Error! Directive 'DEST_MODULE_LOCATION' does not begin with '/kernel', '/updates', or '/extra' in record #0. dkms.conf: Error! 'BUILT_MODULE_NAME' directive ends in '.o' or '.ko' in record #1. dkms.conf: Error! No 'DEST_MODULE_LOCATION' directive specified for record #1. dkms.conf: Error! Directive 'DEST_MODULE_LOCATION' does not begin with '/kernel', '/updates', or '/extra' in record #1. dkms.conf: Error! Unsupported AUTOINSTALL value 'maybe' Error! Bad conf file. File: ${abspwd}/test/dkms_conf_test_invalid/dkms.conf does not represent a valid dkms.conf file. EOF # -------------------------------------------------------------------------- echo 'Testing dkms.conf defining zero modules' run_with_expected_output dkms add test/dkms_conf_test_zero_modules << EOF dkms.conf: Warning! Zero modules specified. Creating symlink /var/lib/dkms/dkms_conf_test/1.0/source -> /usr/src/dkms_conf_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_conf_test-1.0 run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0: added EOF run_with_expected_output dkms remove --all -m dkms_conf_test -v 1.0 << EOF Deleting module dkms_conf_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_conf_test' << EOF EOF echo 'Testing add/build/install of a test module building zero kernel modules' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_conf_test -v 1.0 << EOF dkms.conf: Warning! Zero modules specified. Creating symlink /var/lib/dkms/dkms_conf_test/1.0/source -> /usr/src/dkms_conf_test-1.0 dkms.conf: Warning! Zero modules specified. ${SIGNING_PROLOGUE} Building module(s)... done. dkms.conf: Warning! Zero modules specified. Running depmod... done. EOF run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_with_expected_output dkms remove --all -m dkms_conf_test -v 1.0 << EOF Module dkms_conf_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Running depmod... done. Deleting module dkms_conf_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_conf_test-1.0 # -------------------------------------------------------------------------- echo 'Testing dkms.conf with defaulted BUILT_MODULE_NAME' run_with_expected_output dkms add test/dkms_conf_test_defaulted_BUILT_MODULE_NAME << EOF Creating symlink /var/lib/dkms/dkms_conf_test/1.0/source -> /usr/src/dkms_conf_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_conf_test-1.0 run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0: added EOF echo 'Building test module without source (expected error)' run_with_expected_error 8 dkms build -k "${KERNEL_VER}" -m dkms_conf_test -v 1.0 << EOF Error! The directory /var/lib/dkms/dkms_conf_test/1.0/source does not appear to have module source located within it. Build halted. EOF run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0: added EOF run_with_expected_output dkms remove --all -m dkms_conf_test -v 1.0 << EOF Deleting module dkms_conf_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_conf_test-1.0 # -------------------------------------------------------------------------- echo 'Testing dkms.conf with missing patch' run_with_expected_output dkms add test/dkms_conf_test_patch_missing << EOF Creating symlink /var/lib/dkms/dkms_conf_test/1.0/source -> /usr/src/dkms_conf_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_conf_test-1.0 run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0: added EOF echo ' Building test module with missing patch (expected error)' run_with_expected_error 5 dkms build -k "${KERNEL_VER}" -m dkms_conf_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Error! Patch missing.patch as specified in dkms.conf cannot be found in /var/lib/dkms/dkms_conf_test/1.0/build/patches/. EOF run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0: added EOF run_with_expected_output dkms remove --all -m dkms_conf_test -v 1.0 << EOF Deleting module dkms_conf_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_conf_test-1.0 # -------------------------------------------------------------------------- echo 'Testing dkms.conf with bad patch path (../some.patch)' run_with_expected_output dkms add test/dkms_conf_test_patch_badpath1 << EOF Creating symlink /var/lib/dkms/dkms_conf_test/1.0/source -> /usr/src/dkms_conf_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_conf_test-1.0 run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0: added EOF echo ' Building test module with bad patch path (expected error)' run_with_expected_error 5 dkms build -k "${KERNEL_VER}" -m dkms_conf_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Error! Patch ../badpath.patch as specified in dkms.conf contains '..' path component. EOF run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0: added EOF run_with_expected_output dkms remove --all -m dkms_conf_test -v 1.0 << EOF Deleting module dkms_conf_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_conf_test-1.0 # -------------------------------------------------------------------------- echo 'Testing dkms.conf with bad patch path (path/../some.patch)' run_with_expected_output dkms add test/dkms_conf_test_patch_badpath2 << EOF Creating symlink /var/lib/dkms/dkms_conf_test/1.0/source -> /usr/src/dkms_conf_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_conf_test-1.0 run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0: added EOF echo ' Building test module with bad patch path (expected error)' run_with_expected_error 5 dkms build -k "${KERNEL_VER}" -m dkms_conf_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Error! Patch subdir/../badpath.patch as specified in dkms.conf contains '..' path component. EOF run_status_with_expected_output 'dkms_conf_test' << EOF dkms_conf_test/1.0: added EOF run_with_expected_output dkms remove --all -m dkms_conf_test -v 1.0 << EOF Deleting module dkms_conf_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_conf_test-1.0 # -------------------------------------------------------------------------- echo 'Testing dkms.conf specifying a module twice (expected error)' run_with_expected_error 8 dkms add test/dkms_duplicate_test << EOF dkms.conf: Error! Duplicate module 'dkms_duplicate_test' in 'BUILT_MODULE_NAME[1]'. dkms.conf: Error! Duplicate module 'dkms_duplicate_test' in 'DEST_MODULE_NAME[1]'. Error! Bad conf file. File: /usr/src/dkms_duplicate_test-1.0/dkms.conf does not represent a valid dkms.conf file. EOF check_module_source_tree_created /usr/src/dkms_duplicate_test-1.0 run_status_with_expected_output 'dkms_duplicate_test' << EOF EOF remove_module_source_tree /usr/src/dkms_duplicate_test-1.0 # -------------------------------------------------------------------------- echo 'Testing dkms.conf specifying a module twice in BUILT_MODULE_NAME[] (expected error)' run_with_expected_error 8 dkms add test/dkms_duplicate_built_test-1.0 << EOF dkms.conf: Error! Duplicate module 'dkms_duplicate_built_test' in 'BUILT_MODULE_NAME[1]'. Error! Bad conf file. File: /usr/src/dkms_duplicate_built_test-1.0/dkms.conf does not represent a valid dkms.conf file. EOF check_module_source_tree_created /usr/src/dkms_duplicate_built_test-1.0 run_status_with_expected_output 'dkms_duplicate_built_test' << EOF EOF remove_module_source_tree /usr/src/dkms_duplicate_built_test-1.0 # -------------------------------------------------------------------------- echo 'Testing dkms.conf specifying a module twice in DEST_MODULE_NAME[] (expected error)' run_with_expected_error 8 dkms add test/dkms_duplicate_dest_test-1.0 << EOF dkms.conf: Error! Duplicate module 'dkms_duplicate_dest_test' in 'DEST_MODULE_NAME[1]'. Error! Bad conf file. File: /usr/src/dkms_duplicate_dest_test-1.0/dkms.conf does not represent a valid dkms.conf file. EOF check_module_source_tree_created /usr/src/dkms_duplicate_dest_test-1.0 run_status_with_expected_output 'dkms_duplicate_dest_test' << EOF EOF remove_module_source_tree /usr/src/dkms_duplicate_dest_test-1.0 # -------------------------------------------------------------------------- echo 'Testing dkms.conf with CR/LF line endings' run_with_expected_output dkms add test/dkms_crlf_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_crlf_test/1.0/source -> /usr/src/dkms_crlf_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_crlf_test-1.0 run_status_with_expected_output 'dkms_crlf_test' << EOF dkms_crlf_test/1.0: added EOF echo ' Building and installing the test module' set_signing_message "dkms_crlf_test" "1.0" "dkms_dos_test" run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_crlf_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dos_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_crlf_test' << EOF dkms_crlf_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo ' Removing the test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_crlf_test -v 1.0 << EOF Module dkms_crlf_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_dos_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_crlf_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_crlf_test' << EOF EOF remove_module_source_tree /usr/src/dkms_crlf_test-1.0 # -------------------------------------------------------------------------- echo 'Testing dkms.conf with deprecated directives' run_with_expected_output dkms add test/dkms_deprecated_test-1.0 << EOF Deprecated feature: REMAKE_INITRD (/usr/src/dkms_deprecated_test-1.0/dkms.conf) Creating symlink /var/lib/dkms/dkms_deprecated_test/1.0/source -> /usr/src/dkms_deprecated_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_deprecated_test-1.0 run_status_with_expected_output 'dkms_deprecated_test' << EOF dkms_deprecated_test/1.0: added EOF echo ' Building and installing the test module' set_signing_message "dkms_deprecated_test" "1.0" run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_deprecated_test -v 1.0 << EOF Deprecated feature: REMAKE_INITRD (/var/lib/dkms/dkms_deprecated_test/1.0/source/dkms.conf) ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_deprecated_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_deprecated_test' << EOF dkms_deprecated_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo ' Removing the test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_deprecated_test -v 1.0 << EOF Module dkms_deprecated_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_deprecated_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_deprecated_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_deprecated_test' << EOF EOF remove_module_source_tree /usr/src/dkms_deprecated_test-1.0 # -------------------------------------------------------------------------- echo 'Checking that the environment is clean again' check_no_dkms_test fi # malformed tests if [[ ! $only || $only = multiversion ]]; then ############################################################################ echo '*** Testing dkms on a module with multiple versions' ############################################################################ echo 'Adding the multiver test modules by directory' run_with_expected_output dkms add test/dkms_multiver_test/1.0 << EOF Creating symlink /var/lib/dkms/dkms_multiver_test/1.0/source -> /usr/src/dkms_multiver_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_multiver_test-1.0 run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0: added EOF run_with_expected_output dkms add test/dkms_multiver_test/2.0 << EOF Creating symlink /var/lib/dkms/dkms_multiver_test/2.0/source -> /usr/src/dkms_multiver_test-2.0 EOF check_module_source_tree_created /usr/src/dkms_multiver_test-2.0 run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0: added dkms_multiver_test/2.0: added EOF echo 'Building the multiver test modules' set_signing_message "dkms_multiver_test" "1.0" run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_multiver_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_multiver_test/2.0: added EOF set_signing_message "dkms_multiver_test" "2.0" run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_multiver_test -v 2.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_multiver_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Installing the multiver test modules' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_multiver_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_multiver_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed dkms_multiver_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_multiver_test -v 2.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_multiver_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_multiver_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_with_expected_error 6 dkms install -k "${KERNEL_VER}" -m dkms_multiver_test -v 1.0 << EOF Error! Module version 1.0 for dkms_multiver_test.ko${mod_compression_ext} is not newer than what is already found in kernel ${KERNEL_VER} (2.0). You may override by specifying --force. Error! Installation aborted. EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_multiver_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Uninstalling the multiver test modules' run_with_expected_output dkms uninstall -k "${KERNEL_VER}" -m dkms_multiver_test -v 1.0 << EOF Module dkms_multiver_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_multiver_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_with_expected_output dkms uninstall -k "${KERNEL_VER}" -m dkms_multiver_test -v 2.0 << EOF Module dkms_multiver_test/2.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_multiver_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_multiver_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF if [[ -e "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_multiver_test.ko${mod_compression_ext}" ]] ; then echo >&2 "Error: module not removed in /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_multiver_test.ko${mod_compression_ext}" exit 1 fi echo 'Unbuilding the multiver test modules' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_multiver_test -v 1.0 << EOF Module dkms_multiver_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0: added dkms_multiver_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_multiver_test -v 2.0 << EOF Module dkms_multiver_test/2.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/1.0: added dkms_multiver_test/2.0: added EOF echo 'Removing the multiver test modules' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_multiver_test -v 1.0 << EOF Module dkms_multiver_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_multiver_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_multiver_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_multiver_test' << EOF dkms_multiver_test/2.0: added EOF run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_multiver_test -v 2.0 << EOF Module dkms_multiver_test/2.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_multiver_test/2.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_multiver_test/2.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_multiver_test' << EOF EOF remove_module_source_tree /usr/src/dkms_multiver_test-1.0 /usr/src/dkms_multiver_test-2.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # multiversion tests if [[ ! $only || $only = noversion ]]; then ############################################################################ echo '*** Testing dkms operations on modules with no or empty version' ############################################################################ echo 'Adding the nover/emptyver test modules by directory' run_with_expected_output dkms add test/dkms_nover_test << EOF Creating symlink /var/lib/dkms/dkms_nover_test/1.0/source -> /usr/src/dkms_nover_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_nover_test-1.0 run_status_with_expected_output 'dkms_nover_test' << EOF dkms_nover_test/1.0: added EOF run_with_expected_output dkms add test/dkms_emptyver_test << EOF Creating symlink /var/lib/dkms/dkms_emptyver_test/1.0/source -> /usr/src/dkms_emptyver_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_emptyver_test-1.0 run_status_with_expected_output 'dkms_emptyver_test' << EOF dkms_emptyver_test/1.0: added EOF echo 'Building the nover/emptyver test modules' set_signing_message "dkms_nover_test" "1.0" run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_nover_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_nover_test' << EOF dkms_nover_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF set_signing_message "dkms_emptyver_test" "1.0" run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_emptyver_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_emptyver_test' << EOF dkms_emptyver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Installing the nover/emptyver test modules' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_nover_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_nover_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_nover_test' << EOF dkms_nover_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_emptyver_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_emptyver_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_emptyver_test' << EOF dkms_emptyver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Uninstalling the nover/emptyver test modules' run_with_expected_output dkms uninstall -k "${KERNEL_VER}" -m dkms_nover_test -v 1.0 << EOF Module dkms_nover_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_nover_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_nover_test' << EOF dkms_nover_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF if [[ -e "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_nover_test.ko${mod_compression_ext}" ]] ; then echo >&2 "Error: module not removed in /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_nover_test.ko${mod_compression_ext}" exit 1 fi run_with_expected_output dkms uninstall -k "${KERNEL_VER}" -m dkms_emptyver_test -v 1.0 << EOF Module dkms_emptyver_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_emptyver_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_emptyver_test' << EOF dkms_emptyver_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF if [[ -e "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_emptyver_test.ko${mod_compression_ext}" ]] ; then echo >&2 "Error: module not removed in /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_emptyver_test.ko${mod_compression_ext}" exit 1 fi echo 'Unbuilding the nover/emptyver test modules' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_nover_test -v 1.0 << EOF Module dkms_nover_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_nover_test' << EOF dkms_nover_test/1.0: added EOF run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_emptyver_test -v 1.0 << EOF Module dkms_emptyver_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... EOF run_status_with_expected_output 'dkms_emptyver_test' << EOF dkms_emptyver_test/1.0: added EOF echo 'Removing the nover/emptyver test modules' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_nover_test -v 1.0 << EOF Module dkms_nover_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_nover_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_nover_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_nover_test' << EOF EOF run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_emptyver_test -v 1.0 << EOF Module dkms_emptyver_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_emptyver_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_emptyver_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_emptyver_test' << EOF EOF remove_module_source_tree /usr/src/dkms_nover_test-1.0 /usr/src/dkms_emptyver_test-1.0 echo 'Adding the nover update test modules 1.0 by directory' run_with_expected_output dkms add test/dkms_nover_update_test/1.0 << EOF Creating symlink /var/lib/dkms/dkms_nover_update_test/1.0/source -> /usr/src/dkms_nover_update_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_nover_update_test-1.0 run_status_with_expected_output 'dkms_nover_update_test' << EOF dkms_nover_update_test/1.0: added EOF echo 'Installing the nover update test 1.0 modules' set_signing_message "dkms_nover_update_test" "1.0" run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_nover_update_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_nover_update_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_nover_update_test' << EOF dkms_nover_update_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Adding the nover update test modules 2.0 by directory' run_with_expected_output dkms add test/dkms_nover_update_test/2.0 << EOF Creating symlink /var/lib/dkms/dkms_nover_update_test/2.0/source -> /usr/src/dkms_nover_update_test-2.0 EOF check_module_source_tree_created /usr/src/dkms_nover_update_test-2.0 run_status_with_expected_output 'dkms_nover_update_test' << EOF dkms_nover_update_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed dkms_nover_update_test/2.0: added EOF echo 'Installing the nover update test 2.0 modules' set_signing_message "dkms_nover_update_test" "2.0" run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_nover_update_test -v 2.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_nover_update_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_nover_update_test' << EOF dkms_nover_update_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_nover_update_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Adding the nover update test modules 3.0 by directory' run_with_expected_output dkms add test/dkms_nover_update_test/3.0 << EOF Creating symlink /var/lib/dkms/dkms_nover_update_test/3.0/source -> /usr/src/dkms_nover_update_test-3.0 EOF check_module_source_tree_created /usr/src/dkms_nover_update_test-3.0 run_status_with_expected_output 'dkms_nover_update_test' << EOF dkms_nover_update_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_nover_update_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed dkms_nover_update_test/3.0: added EOF echo 'Building the nover update test 3.0 modules' set_signing_message "dkms_nover_update_test" "3.0" run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_nover_update_test -v 3.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_nover_update_test' << EOF dkms_nover_update_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_nover_update_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed dkms_nover_update_test/3.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF MODULE_PATH_2="/var/lib/dkms/dkms_nover_update_test/2.0/${KERNEL_VER}/${KERNEL_ARCH}/module/dkms_nover_update_test.ko${mod_compression_ext}" MODULE_PATH_3="/var/lib/dkms/dkms_nover_update_test/3.0/${KERNEL_VER}/${KERNEL_ARCH}/module/dkms_nover_update_test.ko${mod_compression_ext}" if ! modinfo "${MODULE_PATH_3}" | grep -q '^srcversion:' && ! diff "${MODULE_PATH_2}" "${MODULE_PATH_3}" &>/dev/null; then # On debian, no srcversion in modinfo's output, the installation will always succeed echo ' Notice: Skip installation test on this platform' else echo ' Installing the nover update test 3.0 modules (expected error)' set_signing_message "dkms_nover_update_test" "3.0" run_with_expected_error 6 dkms install -k "${KERNEL_VER}" -m dkms_nover_update_test -v 3.0 << EOF Module /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_nover_update_test.ko${mod_compression_ext} already installed (unversioned module), override by specifying --force Error! Installation aborted. EOF run_status_with_expected_output 'dkms_nover_update_test' << EOF dkms_nover_update_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_nover_update_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed dkms_nover_update_test/3.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF fi echo 'Removing the nover update test modules' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_nover_update_test -v 3.0 << EOF Module dkms_nover_update_test/3.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_nover_update_test/3.0 completely from the DKMS tree. EOF run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_nover_update_test -v 2.0 << EOF Module dkms_nover_update_test/2.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_nover_update_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_nover_update_test/2.0 completely from the DKMS tree. EOF run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_nover_update_test -v 1.0 << EOF Module dkms_nover_update_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_nover_update_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_nover_update_test' << EOF EOF remove_module_source_tree /usr/src/dkms_nover_update_test-{1,2,3}.0 echo 'Checking that the environment is clean' check_no_dkms_test fi # multiversion tests if [[ ! $only || $only = autoinstall ]]; then ############################################################################ echo '*** Testing dkms autoinstall error handling' ############################################################################ echo 'Adding failing test module by directory' run_with_expected_output dkms add test/dkms_failing_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_failing_test/1.0/source -> /usr/src/dkms_failing_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_failing_test-1.0 echo 'Adding test module with dependencies on failing test module by directory' run_with_expected_output dkms add test/dkms_failing_dependencies_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_failing_dependencies_test/1.0/source -> /usr/src/dkms_failing_dependencies_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_failing_dependencies_test-1.0 echo 'Running autoinstall with failing test module and test module with dependencies on the failing module (expected error)' run_with_expected_error 11 dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_failing_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)...(bad exit status: 2) Failed command: make -j1 KERNELRELEASE=${KERNEL_VER} all Error! Bad return status for module build on kernel: ${KERNEL_VER} (${KERNEL_ARCH}) Consult /var/lib/dkms/dkms_failing_test/1.0/build/make.log for more information. Autoinstall on ${KERNEL_VER} failed for module(s) dkms_failing_test(10). dkms_failing_dependencies_test/1.0 autoinstall failed due to missing dependencies: dkms_failing_test. Error! One or more modules failed to install during autoinstall. Refer to previous errors for more information. EOF echo 'Removing failing test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_failing_test -v 1.0 << EOF Module dkms_failing_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_failing_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_failing_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_failing_test-1.0 echo 'Removing test module with dependencies' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_failing_dependencies_test -v 1.0 << EOF Module dkms_failing_dependencies_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_failing_dependencies_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_failing_dependencies_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_failing_dependencies_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # autoinstall tests if [[ ! $only || $only = exclusive ]]; then ############################################################################ echo '*** Running tests with BUILD_EXCLUSIVE_* modules' ############################################################################ set_signing_message "dkms_test" "1.0" echo 'Adding the build-exclusive test module by directory' run_with_expected_output dkms add test/dkms_build_exclusive_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_build_exclusive_test/1.0/source -> /usr/src/dkms_build_exclusive_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_build_exclusive_test-1.0 run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF # Should this really fail? echo '(Not) building the build-exclusive test module' run_with_expected_error 77 dkms build -k "${KERNEL_VER}" -m dkms_build_exclusive_test -v 1.0 << EOF Warning: The /var/lib/dkms/dkms_build_exclusive_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/dkms.conf for module dkms_build_exclusive_test/1.0 includes a BUILD_EXCLUSIVE directive which does not match this kernel/arch/config. This indicates that it should not be built. EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF echo "Running dkms autoinstall (1 x skip)" run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_build_exclusive_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Warning: The /var/lib/dkms/dkms_build_exclusive_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/dkms.conf for module dkms_build_exclusive_test/1.0 includes a BUILD_EXCLUSIVE directive which does not match this kernel/arch/config. This indicates that it should not be built. Autoinstall on ${KERNEL_VER} was skipped for module(s) dkms_build_exclusive_test. EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF echo 'Adding the test module by directory' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo "Running dkms autoinstall (1 x skip, 1 x pass)" run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_build_exclusive_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Warning: The /var/lib/dkms/dkms_build_exclusive_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/dkms.conf for module dkms_build_exclusive_test/1.0 includes a BUILD_EXCLUSIVE directive which does not match this kernel/arch/config. This indicates that it should not be built. Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test. Autoinstall on ${KERNEL_VER} was skipped for module(s) dkms_build_exclusive_test. EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Unbuilding the test module' run_with_expected_output dkms unbuild -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Adding failing test module by directory' run_with_expected_output dkms add test/dkms_failing_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_failing_test/1.0/source -> /usr/src/dkms_failing_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_failing_test-1.0 echo "Running dkms autoinstall (1 x skip, 1 x fail, 1 x pass) (expected error)" run_with_expected_error 11 dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_build_exclusive_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Warning: The /var/lib/dkms/dkms_build_exclusive_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/dkms.conf for module dkms_build_exclusive_test/1.0 includes a BUILD_EXCLUSIVE directive which does not match this kernel/arch/config. This indicates that it should not be built. Autoinstall of module dkms_failing_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)...(bad exit status: 2) Failed command: make -j1 KERNELRELEASE=${KERNEL_VER} all Error! Bad return status for module build on kernel: ${KERNEL_VER} (${KERNEL_ARCH}) Consult /var/lib/dkms/dkms_failing_test/1.0/build/make.log for more information. Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Building module(s)... done.${SIGNING_MESSAGE} Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test. Autoinstall on ${KERNEL_VER} was skipped for module(s) dkms_build_exclusive_test. Autoinstall on ${KERNEL_VER} failed for module(s) dkms_failing_test(10). Error! One or more modules failed to install during autoinstall. Refer to previous errors for more information. EOF echo 'Removing failing test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_failing_test -v 1.0 << EOF Module dkms_failing_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_failing_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_failing_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_failing_test-1.0 echo 'Removing the test module' run_with_expected_output dkms remove --all -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF remove_module_source_tree /usr/src/dkms_test-1.0 echo 'Adding the build-exclusive dependencies test module by directory' run_with_expected_output dkms add test/dkms_build_exclusive_dependencies_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_build_exclusive_dependencies_test/1.0/source -> /usr/src/dkms_build_exclusive_dependencies_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_build_exclusive_dependencies_test-1.0 run_status_with_expected_output 'dkms_build_exclusive_dependencies_test' << EOF dkms_build_exclusive_dependencies_test/1.0: added EOF echo "Running dkms autoinstall (2 x skip, with dependency)" run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF ${SIGNING_PROLOGUE} Autoinstall of module dkms_build_exclusive_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Warning: The /var/lib/dkms/dkms_build_exclusive_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/dkms.conf for module dkms_build_exclusive_test/1.0 includes a BUILD_EXCLUSIVE directive which does not match this kernel/arch/config. This indicates that it should not be built. Autoinstall of module dkms_build_exclusive_dependencies_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Warning: The /var/lib/dkms/dkms_build_exclusive_dependencies_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/dkms.conf for module dkms_build_exclusive_dependencies_test/1.0 includes a BUILD_EXCLUSIVE directive which does not match this kernel/arch/config. This indicates that it should not be built. Autoinstall on ${KERNEL_VER} was skipped for module(s) dkms_build_exclusive_test dkms_build_exclusive_dependencies_test. EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF dkms_build_exclusive_test/1.0: added EOF run_status_with_expected_output 'dkms_build_exclusive_dependencies_test' << EOF dkms_build_exclusive_dependencies_test/1.0: added EOF echo 'Removing the build-exclusive dependencies test module' run_with_expected_output dkms remove --all -m dkms_build_exclusive_dependencies_test -v 1.0 << EOF Deleting module dkms_build_exclusive_dependencies_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_build_exclusive_dependencies_test' << EOF EOF remove_module_source_tree /usr/src/dkms_build_exclusive_dependencies_test-1.0 echo 'Removing the build-exclusive test module' run_with_expected_output dkms remove --all -m dkms_build_exclusive_test -v 1.0 << EOF Deleting module dkms_build_exclusive_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_build_exclusive_test' << EOF EOF remove_module_source_tree /usr/src/dkms_build_exclusive_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # exclusive tests if [[ ! $only || $only = os-release ]]; then ############################################################################ echo '*** Testing os-release detection' ############################################################################ echo "Backing up /etc/os-release and /usr/lib/os-release" osrelease_cleanup() { rm -f _os-release mv _etc-os-release /etc/os-release &>/dev/null || : mv _usrlib-os-release /usr/lib/os-release &>/dev/null || : } for f in /etc/os-release /usr/lib/os-release; do if [[ -e "$f" ]]; then cp --preserve=all -f "$f" _os-release break fi done [[ -f _os-release ]] || { echo >&2 "Error: file os-release not found"; exit 1; } trap osrelease_cleanup EXIT mv_osrelease() { if [[ -f "$1" ]]; then mv "$1" "$2" || { echo >&2 "Error: could not move os-release $1"; exit 1; } fi } mv_osrelease "/etc/os-release" "_etc-os-release" mv_osrelease "/usr/lib/os-release" "_usrlib-os-release" echo "Adding the dkms_test-1.0 module with no os-release files (expected error)" run_with_expected_error 4 dkms add test/dkms_test-1.0 << EOF Error! System is missing os-release file. EOF echo "Creating /etc/os-release" cp -f _os-release /etc/os-release echo "Adding the dkms_test-1.0 module with file /etc/os-release" run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Removing dkms_test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_test-1.0 echo "Deleting /etc/os-release" rm -f /etc/os-release echo "Creating /usr/lib/os-release" cp -f _os-release /etc/os-release echo "Adding the dkms_test-1.0 module with file /usr/lib/os-release" run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Removing dkms_test module' run_with_expected_output dkms remove -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Module dkms_test/1.0 is not built for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_test/1.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_test-1.0 echo "Deleting /usr/lib/os-release" rm -f /usr/lib/os-release echo "Restoring /etc/os-release and /usr/bin/os-release" osrelease_cleanup trap tmpdir_cleanup EXIT echo 'Checking that the environment is clean again' check_no_dkms_test fi # os-release tests if [[ ! $only || $only = incomplete ]]; then ############################################################################ echo '*** Testing '"'incomplete'"' status' ############################################################################ echo 'Adding the test module by directory' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Building the test module' set_signing_message "dkms_test" "1.0" run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Installing the test module' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Making the built/installed module "incomplete"' rm "/var/lib/dkms/dkms_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/module/dkms_test.ko${mod_compression_ext}" # if the module didn't exist in the build tree it probably wasn't installed either rm "/lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext}" run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed (Built modules are missing in the kernel modules folder) EOF echo 'Uninstalling the "incomplete" test module' run_with_expected_output dkms uninstall -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Module dkms_test.ko${mod_compression_ext} was not found within /lib/modules/${KERNEL_VER}/ Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built (Built modules are missing in the kernel modules folder) EOF echo 'Installing the "incomplete" test module (expected error)' run_with_expected_error 6 dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Error! Missing module dkms_test in /var/lib/dkms/dkms_test/1.0/${KERNEL_VER}/${KERNEL_ARCH}/module EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built (Built modules are missing in the kernel modules folder) EOF echo 'Removing the "incomplete" test module with --all' run_with_expected_output dkms remove --all -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF echo 'Adding the test module by version' run_with_expected_output dkms add -m dkms_test -v 1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0: added EOF echo 'Building the test module' run_with_expected_output dkms build -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built EOF echo 'Installing the test module' run_with_expected_output dkms install -k "${KERNEL_VER}" -m dkms_test -v 1.0 << EOF Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. EOF run_status_with_expected_output 'dkms_test' << EOF dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Removing the test module with --all' run_with_expected_output dkms remove --all -m dkms_test -v 1.0 << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF run_status_with_expected_output 'dkms_test' << EOF EOF remove_module_source_tree /usr/src/dkms_test-1.0 echo 'Checking that the environment is clean again' check_no_dkms_test fi # incomplete tests if [[ ! $only || $only = broken ]]; then ############################################################################ echo '*** Testing '"'broken'"' status' ############################################################################ echo 'Adding the test module by directory' run_with_expected_output dkms add test/dkms_test-1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_test-1.0 echo ' Removing symlink /var/lib/dkms/dkms_test/1.0/source' rm /var/lib/dkms/dkms_test/1.0/source echo 'Checking broken status' run_with_expected_output dkms status dkms_test/1.0 << EOF dkms_test/1.0: broken Error! dkms_test/1.0: Missing the module source directory or the symbolic link pointing to it. Manual intervention is required! EOF echo 'Re-adding the test module' run_with_expected_output dkms add dkms_test/1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF echo ' Removing symlink /var/lib/dkms/dkms_test/1.0/source' rm /var/lib/dkms/dkms_test/1.0/source echo 'Building broken test module (expected error)' run_with_expected_error 4 dkms build dkms_test/1.0 << EOF Error! dkms_test/1.0 is broken! Missing the source directory or the symbolic link pointing to it. Manual intervention is required! EOF echo 'Installing broken test module (expected error)' run_with_expected_error 4 dkms install dkms_test/1.0 << EOF Error! dkms_test/1.0 is broken! Missing the source directory or the symbolic link pointing to it. Manual intervention is required! EOF echo 'Unbuild broken test module (expected error)' run_with_expected_error 4 dkms unbuild dkms_test/1.0 << EOF Error! dkms_test/1.0 is broken! Missing the source directory or the symbolic link pointing to it. Manual intervention is required! EOF echo 'Uninstall broken test module (expected error)' run_with_expected_error 4 dkms uninstall dkms_test/1.0 << EOF Error! dkms_test/1.0 is broken! Missing the source directory or the symbolic link pointing to it. Manual intervention is required! EOF echo 'Adding the multiver test module 1.0 by directory' run_with_expected_output dkms add test/dkms_multiver_test/1.0 << EOF Creating symlink /var/lib/dkms/dkms_multiver_test/1.0/source -> /usr/src/dkms_multiver_test-1.0 EOF check_module_source_tree_created /usr/src/dkms_multiver_test-1.0 echo 'Checking broken status' run_with_expected_output dkms status << EOF dkms_multiver_test/1.0: added dkms_test/1.0: broken Error! dkms_test/1.0: Missing the module source directory or the symbolic link pointing to it. Manual intervention is required! EOF echo 'Remove broken test module (expected error)' run_with_expected_error 4 dkms remove dkms_test/1.0 << EOF Error! dkms_test/1.0 is broken! Missing the source directory or the symbolic link pointing to it. Manual intervention is required! EOF echo 'Re-adding the test module' run_with_expected_output dkms add dkms_test/1.0 << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 EOF remove_module_source_tree /usr/src/dkms_test-1.0/ echo 'Checking broken status' run_with_expected_output dkms status << EOF dkms_multiver_test/1.0: added dkms_test/1.0: broken Error! dkms_test/1.0: Missing the module source directory or the symbolic link pointing to it. Manual intervention is required! EOF echo 'Removing dkms_multiver_test' dkms remove dkms_multiver_test/1.0 -k "${KERNEL_VER}" > /dev/null echo 'Removing dkms_test' rm -rf /var/lib/dkms/dkms_test/ echo 'Adding and building the test module by directory' set_signing_message "dkms_test" "1.0" run_with_expected_output dkms build test/dkms_test-1.0 -k "${KERNEL_VER}" << EOF Creating symlink /var/lib/dkms/dkms_test/1.0/source -> /usr/src/dkms_test-1.0 ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF echo 'Adding and building the multiver test module 1.0 by directory' set_signing_message "dkms_multiver_test" "1.0" run_with_expected_output dkms build test/dkms_multiver_test/1.0 -k "${KERNEL_VER}" << EOF Creating symlink /var/lib/dkms/dkms_multiver_test/1.0/source -> /usr/src/dkms_multiver_test-1.0 ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF echo ' Removing symlink /var/lib/dkms/dkms_multiver_test/1.0/source' rm /var/lib/dkms/dkms_multiver_test/1.0/source echo 'Adding and building the multiver test module 2.0 by directory' set_signing_message "dkms_multiver_test" "2.0" run_with_expected_output dkms build test/dkms_multiver_test/2.0 -k "${KERNEL_VER}" << EOF Creating symlink /var/lib/dkms/dkms_multiver_test/2.0/source -> /usr/src/dkms_multiver_test-2.0 ${SIGNING_PROLOGUE} Building module(s)... done.${SIGNING_MESSAGE} EOF echo 'Running dkms autoinstall' run_with_expected_output dkms autoinstall -k "${KERNEL_VER}" << EOF Error! dkms_multiver_test/1.0 is broken! Missing the source directory or the symbolic link pointing to it. Manual intervention is required! Autoinstall of module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}) Installing /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Autoinstall on ${KERNEL_VER} succeeded for module(s) dkms_test. EOF run_with_expected_output dkms status << EOF dkms_multiver_test/1.0: broken Error! dkms_multiver_test/1.0: Missing the module source directory or the symbolic link pointing to it. Manual intervention is required! dkms_multiver_test/2.0, ${KERNEL_VER}, ${KERNEL_ARCH}: built dkms_test/1.0, ${KERNEL_VER}, ${KERNEL_ARCH}: installed EOF echo 'Removing all modules' echo ' Removing the test module' run_with_expected_output dkms remove dkms_test/1.0 -k "${KERNEL_VER}" << EOF Module dkms_test/1.0 for kernel ${KERNEL_VER} (${KERNEL_ARCH}): Before uninstall, this module version was ACTIVE on this kernel. Deleting /lib/modules/${KERNEL_VER}/${expected_dest_loc}/dkms_test.ko${mod_compression_ext} Running depmod... done. Deleting module dkms_test/1.0 completely from the DKMS tree. EOF echo ' Removing the multi_ver_test 2.0 module' run_with_expected_output dkms remove -m dkms_multiver_test -v 2.0 -k "${KERNEL_VER}" << EOF Module dkms_multiver_test/2.0 is not installed for kernel ${KERNEL_VER} (${KERNEL_ARCH}). Skipping... Deleting module dkms_multiver_test/2.0 completely from the DKMS tree. EOF remove_module_source_tree /usr/src/dkms_test-1.0 /usr/src/dkms_multiver_test-?.0 echo ' Removing directories: /var/lib/dkms/dkms_test/ /var/lib/dkms/dkms_multiver_test' rm -rf /var/lib/dkms/dkms_test/ /var/lib/dkms/dkms_multiver_test echo 'Checking that the environment is clean again' check_no_dkms_test fi # broken tests ############################################################################ echo '*** All tests successful :)' # vim: et:ts=4:sw=4 dkms-3.2.0/test/000077500000000000000000000000001500670340200134265ustar00rootroot00000000000000dkms-3.2.0/test/README000066400000000000000000000000621500670340200143040ustar00rootroot00000000000000A sample module and framework files to test dkms. dkms-3.2.0/test/dkms_build_exclusive_dependencies_test-1.0/000077500000000000000000000000001500670340200236735ustar00rootroot00000000000000dkms-3.2.0/test/dkms_build_exclusive_dependencies_test-1.0/Makefile000066400000000000000000000000701500670340200253300ustar00rootroot00000000000000all: @echo ERROR: This module fails to build. @exit 1 dkms-3.2.0/test/dkms_build_exclusive_dependencies_test-1.0/dkms.conf000066400000000000000000000003141500670340200254760ustar00rootroot00000000000000PACKAGE_NAME="dkms_build_exclusive_dependencies_test" PACKAGE_VERSION="1.0" BUILD_DEPENDS="dkms_build_exclusive_test" DEST_MODULE_LOCATION[0]="/updates/dkms" BUILD_EXCLUSIVE_ARCH="none" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_build_exclusive_test-1.0/000077500000000000000000000000001500670340200211655ustar00rootroot00000000000000dkms-3.2.0/test/dkms_build_exclusive_test-1.0/Makefile000066400000000000000000000000701500670340200226220ustar00rootroot00000000000000all: @echo ERROR: This module fails to build. @exit 1 dkms-3.2.0/test/dkms_build_exclusive_test-1.0/dkms.conf000066400000000000000000000002251500670340200227710ustar00rootroot00000000000000PACKAGE_NAME="dkms_build_exclusive_test" PACKAGE_VERSION="1.0" DEST_MODULE_LOCATION[0]="/updates/dkms" BUILD_EXCLUSIVE_ARCH="none" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_circular_dependencies_test-1.0/000077500000000000000000000000001500670340200223115ustar00rootroot00000000000000dkms-3.2.0/test/dkms_circular_dependencies_test-1.0/Makefile000066400000000000000000000002651500670340200237540ustar00rootroot00000000000000obj-m += dkms_circular_dependencies_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_circular_dependencies_test-1.0/dkms.conf000066400000000000000000000003461500670340200241210ustar00rootroot00000000000000PACKAGE_NAME="dkms_circular_dependencies_test" PACKAGE_VERSION="1.0" BUILD_DEPENDS="dkms_circular_dependencies_test" BUILT_MODULE_NAME[0]="dkms_circular_dependencies_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_circular_dependencies_test-1.0/dkms_circular_dependencies_test.c000066400000000000000000000007761500670340200310560ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_conf_test_defaulted_BUILT_MODULE_NAME/000077500000000000000000000000001500670340200232515ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_defaulted_BUILT_MODULE_NAME/dkms.conf000066400000000000000000000001411500670340200250520ustar00rootroot00000000000000PACKAGE_NAME="dkms_conf_test" PACKAGE_VERSION="1.0" DEST_MODULE_LOCATION[0]="/updates-dkms-test" dkms-3.2.0/test/dkms_conf_test_empty/000077500000000000000000000000001500670340200176465ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_empty/dkms.conf000066400000000000000000000000001500670340200214410ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_invalid/000077500000000000000000000000001500670340200201365ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_invalid/dkms.conf000066400000000000000000000002771500670340200217510ustar00rootroot00000000000000PACKAGE_NAME="dkms_conf_test" PACKAGE_VERSION="1.0" DEST_MODULE_NAME[0]="bar.ko" DEST_MODULE_LOCATION="/wrong/path" BUILT_MODULE_NAME[1]="bar.o" DEST_MODULE_NAME[1]="foo" AUTOINSTALL="maybe" dkms-3.2.0/test/dkms_conf_test_no_conf/000077500000000000000000000000001500670340200201315ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_no_conf/.placeholder000066400000000000000000000000001500670340200224020ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_badpath1/000077500000000000000000000000001500670340200213535ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_badpath1/badpath.patch000066400000000000000000000000001500670340200237650ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_badpath1/dkms.conf000066400000000000000000000002501500670340200231550ustar00rootroot00000000000000PACKAGE_NAME="dkms_conf_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" PATCH="../badpath.patch" dkms-3.2.0/test/dkms_conf_test_patch_badpath1/patches/000077500000000000000000000000001500670340200230025ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_badpath1/patches/dummy.patch000066400000000000000000000000001500670340200251440ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_badpath2/000077500000000000000000000000001500670340200213545ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_badpath2/dkms.conf000066400000000000000000000002571500670340200231650ustar00rootroot00000000000000PACKAGE_NAME="dkms_conf_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" PATCH="subdir/../badpath.patch" dkms-3.2.0/test/dkms_conf_test_patch_badpath2/patches/000077500000000000000000000000001500670340200230035ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_badpath2/patches/badpath.patch000066400000000000000000000000001500670340200254150ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_badpath2/patches/subdir/000077500000000000000000000000001500670340200242735ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_badpath2/patches/subdir/dummy.patch000066400000000000000000000000001500670340200264350ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_missing/000077500000000000000000000000001500670340200213405ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_patch_missing/dkms.conf000066400000000000000000000002451500670340200231460ustar00rootroot00000000000000PACKAGE_NAME="dkms_conf_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" PATCH="missing.patch" dkms-3.2.0/test/dkms_conf_test_patch_missing/dummy.c000066400000000000000000000000001500670340200226250ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_zero_modules/000077500000000000000000000000001500670340200212175ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_zero_modules/Makefile000066400000000000000000000000001500670340200226450ustar00rootroot00000000000000dkms-3.2.0/test/dkms_conf_test_zero_modules/dkms.conf000066400000000000000000000001061500670340200230210ustar00rootroot00000000000000PACKAGE_NAME="dkms_conf_test" PACKAGE_VERSION="1.0" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_crlf_test-1.0/000077500000000000000000000000001500670340200167255ustar00rootroot00000000000000dkms-3.2.0/test/dkms_crlf_test-1.0/Makefile000066400000000000000000000002521500670340200203640ustar00rootroot00000000000000obj-m += dkms_dos_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_crlf_test-1.0/dkms.conf000066400000000000000000000002301500670340200205250ustar00rootroot00000000000000PACKAGE_NAME="dkms_crlf_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_dos_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_crlf_test-1.0/dkms_dos_test.c000066400000000000000000000010511500670340200217300ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_crlf_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_crlf_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_crlf_test_init); module_exit(dkms_crlf_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_dependencies_rebuild_test-1.0/000077500000000000000000000000001500670340200221335ustar00rootroot00000000000000dkms-3.2.0/test/dkms_dependencies_rebuild_test-1.0/Makefile000066400000000000000000000002641500670340200235750ustar00rootroot00000000000000obj-m += dkms_dependencies_rebuild_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_dependencies_rebuild_test-1.0/dkms.conf000066400000000000000000000003531500670340200237410ustar00rootroot00000000000000PACKAGE_NAME="dkms_dependencies_rebuild_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_dependencies_rebuild_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" BUILD_DEPENDS="dkms_test" BUILD_DEPENDS_REBUILD="yes" dkms-3.2.0/test/dkms_dependencies_rebuild_test-1.0/dkms_dependencies_rebuild_test.c000066400000000000000000000012401500670340200305050ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module with rebuild dependencies"); static int __init dkms_dependencies_rebuild_test_init(void) { printk(KERN_INFO "DKMS Test Module with rebuild dependencies -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_dependencies_rebuild_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module with rebuild dependencies.\n"); } module_init(dkms_dependencies_rebuild_test_init); module_exit(dkms_dependencies_rebuild_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_dependencies_test-1.0/000077500000000000000000000000001500670340200204255ustar00rootroot00000000000000dkms-3.2.0/test/dkms_dependencies_test-1.0/Makefile000066400000000000000000000002541500670340200220660ustar00rootroot00000000000000obj-m += dkms_dependencies_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_dependencies_test-1.0/dkms.conf000066400000000000000000000002761500670340200222370ustar00rootroot00000000000000PACKAGE_NAME="dkms_dependencies_test" PACKAGE_VERSION="1.0" BUILD_DEPENDS="dkms_test" BUILT_MODULE_NAME[0]="dkms_dependencies_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_dependencies_test-1.0/dkms_dependencies_test.c000066400000000000000000000010621500670340200252730ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_dependencies_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_dependencies_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_dependencies_test_init); module_exit(dkms_dependencies_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_deprecated_test-1.0/000077500000000000000000000000001500670340200200775ustar00rootroot00000000000000dkms-3.2.0/test/dkms_deprecated_test-1.0/Makefile000066400000000000000000000002521500670340200215360ustar00rootroot00000000000000obj-m += dkms_deprecated_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_deprecated_test-1.0/dkms.conf000066400000000000000000000003011500670340200216760ustar00rootroot00000000000000PACKAGE_NAME="dkms_deprecated_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_deprecated_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" REMAKE_INITRD="yes" CLEAN="true" dkms-3.2.0/test/dkms_deprecated_test-1.0/dkms_deprecated_test.c000066400000000000000000000007761500670340200244320ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_duplicate_built_test-1.0/000077500000000000000000000000001500670340200211505ustar00rootroot00000000000000dkms-3.2.0/test/dkms_duplicate_built_test-1.0/Makefile000066400000000000000000000002571500670340200226140ustar00rootroot00000000000000obj-m += dkms_duplicate_built_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_duplicate_built_test-1.0/dkms.conf000066400000000000000000000005471500670340200227630ustar00rootroot00000000000000PACKAGE_NAME="dkms_duplicate_built_test" PACKAGE_VERSION="1.0" AUTOINSTALL="yes" BUILT_MODULE_NAME[0]="dkms_duplicate_built_test" DEST_MODULE_NAME[0]="dkms_duplicate1_built_test" DEST_MODULE_LOCATION[0]="/kernel/extra" BUILT_MODULE_NAME[1]="dkms_duplicate_built_test" DEST_MODULE_NAME[1]="dkms_duplicate2_built_test" DEST_MODULE_LOCATION[1]="/kernel/extra" dkms-3.2.0/test/dkms_duplicate_built_test-1.0/dkms_duplicate_built_test.c000066400000000000000000000007761500670340200265540ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_duplicate_dest_test-1.0/000077500000000000000000000000001500670340200207705ustar00rootroot00000000000000dkms-3.2.0/test/dkms_duplicate_dest_test-1.0/Makefile000066400000000000000000000003241500670340200224270ustar00rootroot00000000000000obj-m += dkms_duplicate1_dest_test.o obj-m += dkms_duplicate2_dest_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_duplicate_dest_test-1.0/dkms.conf000066400000000000000000000005421500670340200225760ustar00rootroot00000000000000PACKAGE_NAME="dkms_duplicate_dest_test" PACKAGE_VERSION="1.0" AUTOINSTALL="yes" BUILT_MODULE_NAME[0]="dkms_duplicate1_dest_test" DEST_MODULE_NAME[0]="dkms_duplicate_dest_test" DEST_MODULE_LOCATION[0]="/kernel/extra" BUILT_MODULE_NAME[1]="dkms_duplicate2_dest_test" DEST_MODULE_NAME[1]="dkms_duplicate_dest_test" DEST_MODULE_LOCATION[1]="/kernel/extra" dkms-3.2.0/test/dkms_duplicate_dest_test-1.0/dkms_duplicate1_dest_test.c000066400000000000000000000010021500670340200262540ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test1_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test1_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test1_init); module_exit(dkms_test1_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_duplicate_dest_test-1.0/dkms_duplicate2_dest_test.c000066400000000000000000000010021500670340200262550ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test2_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test2_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test2_init); module_exit(dkms_test2_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_duplicate_test/000077500000000000000000000000001500670340200174555ustar00rootroot00000000000000dkms-3.2.0/test/dkms_duplicate_test/Makefile000066400000000000000000000002511500670340200211130ustar00rootroot00000000000000obj-m += dkms_duplicate_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_duplicate_test/dkms.conf000066400000000000000000000003611500670340200212620ustar00rootroot00000000000000PACKAGE_NAME="dkms_duplicate_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_duplicate_test" DEST_MODULE_LOCATION[0]="/kernel/extra" BUILT_MODULE_NAME[1]="dkms_duplicate_test" DEST_MODULE_LOCATION[1]="/kernel/extra" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_duplicate_test/dkms_duplicate_test.c000066400000000000000000000007011500670340200236460ustar00rootroot00000000000000#include #include #include MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module with no version"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module - Loaded\n"); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); dkms-3.2.0/test/dkms_emptyver_test/000077500000000000000000000000001500670340200173565ustar00rootroot00000000000000dkms-3.2.0/test/dkms_emptyver_test/Makefile000066400000000000000000000002501500670340200210130ustar00rootroot00000000000000obj-m += dkms_emptyver_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_emptyver_test/dkms.conf000066400000000000000000000003141500670340200211610ustar00rootroot00000000000000PACKAGE_NAME="dkms_emptyver_test" PACKAGE_VERSION="1.0" # intentionally uses POSIX syntax (no array notation) BUILT_MODULE_NAME="dkms_emptyver_test" DEST_MODULE_LOCATION="/kernel/extra" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_emptyver_test/dkms_emptyver_test.c000066400000000000000000000007301500670340200234520ustar00rootroot00000000000000#include #include #include MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module with empty version"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module - Loaded\n"); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(""); dkms-3.2.0/test/dkms_failing_dependencies_test-1.0/000077500000000000000000000000001500670340200221165ustar00rootroot00000000000000dkms-3.2.0/test/dkms_failing_dependencies_test-1.0/Makefile000066400000000000000000000000741500670340200235570ustar00rootroot00000000000000all: @echo ERROR: This module should never build. @exit 1 dkms-3.2.0/test/dkms_failing_dependencies_test-1.0/dkms.conf000066400000000000000000000003461500670340200237260ustar00rootroot00000000000000PACKAGE_NAME="dkms_failing_dependencies_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_failing_dependencies_test" DEST_MODULE_LOCATION[0]="/kernel/extra" BUILD_DEPENDS="dkms_failing_test" MAKE="make all" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_failing_test-1.0/000077500000000000000000000000001500670340200174105ustar00rootroot00000000000000dkms-3.2.0/test/dkms_failing_test-1.0/Makefile000066400000000000000000000000701500670340200210450ustar00rootroot00000000000000all: @echo ERROR: This module fails to build. @exit 1 dkms-3.2.0/test/dkms_failing_test-1.0/dkms.conf000066400000000000000000000002521500670340200212140ustar00rootroot00000000000000PACKAGE_NAME="dkms_failing_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_failing_test" DEST_MODULE_LOCATION[0]="/kernel/extra" MAKE="make all" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_multiver_test/000077500000000000000000000000001500670340200173525ustar00rootroot00000000000000dkms-3.2.0/test/dkms_multiver_test/1.0/000077500000000000000000000000001500670340200176505ustar00rootroot00000000000000dkms-3.2.0/test/dkms_multiver_test/1.0/Makefile000066400000000000000000000002501500670340200213050ustar00rootroot00000000000000obj-m += dkms_multiver_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_multiver_test/1.0/dkms.conf000066400000000000000000000002051500670340200214520ustar00rootroot00000000000000PACKAGE_NAME="dkms_multiver_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME="dkms_multiver_test" DEST_MODULE_LOCATION="/kernel/extra" dkms-3.2.0/test/dkms_multiver_test/1.0/dkms_multiver_test.c000066400000000000000000000010311500670340200237330ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms multiver test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS MultiVer Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms multiver test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_multiver_test/2.0/000077500000000000000000000000001500670340200176515ustar00rootroot00000000000000dkms-3.2.0/test/dkms_multiver_test/2.0/Makefile000066400000000000000000000002501500670340200213060ustar00rootroot00000000000000obj-m += dkms_multiver_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_multiver_test/2.0/dkms.conf000066400000000000000000000002051500670340200214530ustar00rootroot00000000000000PACKAGE_NAME="dkms_multiver_test" PACKAGE_VERSION="2.0" BUILT_MODULE_NAME="dkms_multiver_test" DEST_MODULE_LOCATION="/kernel/extra" dkms-3.2.0/test/dkms_multiver_test/2.0/dkms_multiver_test.c000066400000000000000000000010311500670340200237340ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "2.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms multiver test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS MultiVer Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms multiver test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_noautoinstall_test-1.0/000077500000000000000000000000001500670340200206735ustar00rootroot00000000000000dkms-3.2.0/test/dkms_noautoinstall_test-1.0/Makefile000066400000000000000000000002551500670340200223350ustar00rootroot00000000000000obj-m += dkms_noautoinstall_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_noautoinstall_test-1.0/dkms.conf000066400000000000000000000002431500670340200224770ustar00rootroot00000000000000PACKAGE_NAME="dkms_noautoinstall_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_noautoinstall_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="" dkms-3.2.0/test/dkms_noautoinstall_test-1.0/dkms_noautoinstall_test.c000066400000000000000000000007761500670340200260220ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_noisy_test-1.0/000077500000000000000000000000001500670340200171405ustar00rootroot00000000000000dkms-3.2.0/test/dkms_noisy_test-1.0/Makefile000066400000000000000000000002021500670340200205720ustar00rootroot00000000000000all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_noisy_test-1.0/dkms.conf000066400000000000000000000006061500670340200207470ustar00rootroot00000000000000PACKAGE_NAME="dkms_noisy_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_noisy_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" PATCH=(patch2.patch patch1.patch) POST_ADD="script.sh post_add" PRE_BUILD="script.sh pre_build" POST_BUILD="script.sh post_build" PRE_INSTALL="script.sh pre_install" POST_INSTALL="script.sh post_install" POST_REMOVE="script.sh post_remove" dkms-3.2.0/test/dkms_noisy_test-1.0/dkms_noisy_test.c000066400000000000000000000006461500670340200225300ustar00rootroot00000000000000#include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_noisy_test-1.0/patches/000077500000000000000000000000001500670340200205675ustar00rootroot00000000000000dkms-3.2.0/test/dkms_noisy_test-1.0/patches/patch1.patch000066400000000000000000000012021500670340200227630ustar00rootroot00000000000000diff -ur 1/Makefile 2/Makefile --- 1/Makefile 2024-10-27 02:08:27.104704591 +0100 +++ 2/Makefile 2024-10-27 02:06:45.157263482 +0100 @@ -1,4 +1,5 @@ all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules +clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean diff -ur 1/dkms_noisy_test.c 2/dkms_noisy_test.c --- 1/dkms_noisy_test.c 2024-10-27 02:08:16.528761716 +0100 +++ 2/dkms_noisy_test.c 2024-10-27 02:07:01.709171430 +0100 @@ -16,4 +16,6 @@ printk(KERN_INFO "Cleaning up after dkms test module.\n"); } +module_init(dkms_test_init); +module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_noisy_test-1.0/patches/patch2.patch000066400000000000000000000010751500670340200227740ustar00rootroot00000000000000diff -ur 2/Makefile 3/Makefile --- 2/Makefile 2024-10-27 02:06:45.157263482 +0100 +++ 3/Makefile 2024-10-27 02:05:12.925786989 +0100 @@ -1,3 +1,5 @@ +obj-m += dkms_noisy_test.o + all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules diff -ur 2/dkms_noisy_test.c 3/dkms_noisy_test.c --- 2/dkms_noisy_test.c 2024-10-27 02:07:01.709171430 +0100 +++ 3/dkms_noisy_test.c 2024-10-27 02:05:12.925786989 +0100 @@ -1,5 +1,7 @@ #include +#include #include + #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); dkms-3.2.0/test/dkms_noisy_test-1.0/script.sh000077500000000000000000000002121500670340200207760ustar00rootroot00000000000000#!/bin/sh echo "$0" "$@" echo "$1: line 1" echo "$1: line 2/stderr" >&2 echo "$1: line 3" echo "$1: line 4/stderr" >&2 echo "$1: line 5" dkms-3.2.0/test/dkms_nover_test/000077500000000000000000000000001500670340200166345ustar00rootroot00000000000000dkms-3.2.0/test/dkms_nover_test/Makefile000066400000000000000000000002451500670340200202750ustar00rootroot00000000000000obj-m += dkms_nover_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_nover_test/dkms.conf000066400000000000000000000003061500670340200204400ustar00rootroot00000000000000PACKAGE_NAME="dkms_nover_test" PACKAGE_VERSION="1.0" # intentionally uses POSIX syntax (no array notation) BUILT_MODULE_NAME="dkms_nover_test" DEST_MODULE_LOCATION="/kernel/extra" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_nover_test/dkms_nover_test.c000066400000000000000000000007011500670340200222040ustar00rootroot00000000000000#include #include #include MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module with no version"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module - Loaded\n"); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); dkms-3.2.0/test/dkms_nover_update_test/000077500000000000000000000000001500670340200201765ustar00rootroot00000000000000dkms-3.2.0/test/dkms_nover_update_test/1.0/000077500000000000000000000000001500670340200204745ustar00rootroot00000000000000dkms-3.2.0/test/dkms_nover_update_test/1.0/Makefile000066400000000000000000000002541500670340200221350ustar00rootroot00000000000000obj-m += dkms_nover_update_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_nover_update_test/1.0/dkms.conf000066400000000000000000000004321500670340200223000ustar00rootroot00000000000000 PACKAGE_NAME="dkms_nover_update_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME="dkms_nover_update_test" # MAKE="make -C /lib/modules/${kernelver}/build SUBDIRS=${dkms_tree}/${PACKAGE_NAME}/${PACKAGE_VERSION}/build modules" AUTOINSTALL="yes" DEST_MODULE_LOCATION="/kernel/extra" dkms-3.2.0/test/dkms_nover_update_test/1.0/dkms_nover_update_test.c000066400000000000000000000007011500670340200254060ustar00rootroot00000000000000#include #include #include MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module with no version"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module - Loaded\n"); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); dkms-3.2.0/test/dkms_nover_update_test/2.0/000077500000000000000000000000001500670340200204755ustar00rootroot00000000000000dkms-3.2.0/test/dkms_nover_update_test/2.0/Makefile000066400000000000000000000002541500670340200221360ustar00rootroot00000000000000obj-m += dkms_nover_update_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_nover_update_test/2.0/dkms.conf000066400000000000000000000004321500670340200223010ustar00rootroot00000000000000 PACKAGE_NAME="dkms_nover_update_test" PACKAGE_VERSION="2.0" BUILT_MODULE_NAME="dkms_nover_update_test" # MAKE="make -C /lib/modules/${kernelver}/build SUBDIRS=${dkms_tree}/${PACKAGE_NAME}/${PACKAGE_VERSION}/build modules" AUTOINSTALL="yes" DEST_MODULE_LOCATION="/kernel/extra" dkms-3.2.0/test/dkms_nover_update_test/2.0/dkms_nover_update_test.c000066400000000000000000000007021500670340200254100ustar00rootroot00000000000000#include #include #include MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module with no version!"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module - Loaded\n"); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); dkms-3.2.0/test/dkms_nover_update_test/3.0/000077500000000000000000000000001500670340200204765ustar00rootroot00000000000000dkms-3.2.0/test/dkms_nover_update_test/3.0/Makefile000066400000000000000000000002541500670340200221370ustar00rootroot00000000000000obj-m += dkms_nover_update_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_nover_update_test/3.0/dkms.conf000066400000000000000000000004321500670340200223020ustar00rootroot00000000000000 PACKAGE_NAME="dkms_nover_update_test" PACKAGE_VERSION="3.0" BUILT_MODULE_NAME="dkms_nover_update_test" # MAKE="make -C /lib/modules/${kernelver}/build SUBDIRS=${dkms_tree}/${PACKAGE_NAME}/${PACKAGE_VERSION}/build modules" AUTOINSTALL="yes" DEST_MODULE_LOCATION="/kernel/extra" dkms-3.2.0/test/dkms_nover_update_test/3.0/dkms_nover_update_test.c000066400000000000000000000007021500670340200254110ustar00rootroot00000000000000#include #include #include MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module with no version!"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module - Loaded\n"); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); dkms-3.2.0/test/dkms_patches_test-1.0/000077500000000000000000000000001500670340200174265ustar00rootroot00000000000000dkms-3.2.0/test/dkms_patches_test-1.0/Makefile000066400000000000000000000002021500670340200210600ustar00rootroot00000000000000all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_patches_test-1.0/dkms.conf000066400000000000000000000003031500670340200212270ustar00rootroot00000000000000PACKAGE_NAME="dkms_patches_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_patches_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" PATCH=(patch1.patch subdir/patch2.patch) dkms-3.2.0/test/dkms_patches_test-1.0/dkms_patches_test.c000066400000000000000000000006461500670340200233040ustar00rootroot00000000000000#include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_patches_test-1.0/patches/000077500000000000000000000000001500670340200210555ustar00rootroot00000000000000dkms-3.2.0/test/dkms_patches_test-1.0/patches/patch1.patch000066400000000000000000000012121500670340200232520ustar00rootroot00000000000000diff -ur 1/Makefile 2/Makefile --- 1/Makefile 2024-10-27 02:08:27.104704591 +0100 +++ 2/Makefile 2024-10-27 02:06:45.157263482 +0100 @@ -1,4 +1,5 @@ all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules +clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean diff -ur 1/dkms_patches_test.c 2/dkms_patches_test.c --- 1/dkms_patches_test.c 2024-10-27 02:08:16.528761716 +0100 +++ 2/dkms_patches_test.c 2024-10-27 02:07:01.709171430 +0100 @@ -16,4 +16,6 @@ printk(KERN_INFO "Cleaning up after dkms test module.\n"); } +module_init(dkms_test_init); +module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_patches_test-1.0/patches/subdir/000077500000000000000000000000001500670340200223455ustar00rootroot00000000000000dkms-3.2.0/test/dkms_patches_test-1.0/patches/subdir/patch2.patch000066400000000000000000000011071500670340200245460ustar00rootroot00000000000000diff -ur 2/Makefile 3/Makefile --- 2/Makefile 2024-10-27 02:06:45.157263482 +0100 +++ 3/Makefile 2024-10-27 02:05:12.925786989 +0100 @@ -1,3 +1,5 @@ +obj-m += dkms_patches_test.o + all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules diff -ur 2/dkms_patches_test.c 3/dkms_patches_test.c --- 2/dkms_patches_test.c 2024-10-27 02:07:01.709171430 +0100 +++ 3/dkms_patches_test.c 2024-10-27 02:05:12.925786989 +0100 @@ -1,5 +1,7 @@ #include +#include #include + #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); dkms-3.2.0/test/dkms_replace_test-2.0/000077500000000000000000000000001500670340200174135ustar00rootroot00000000000000dkms-3.2.0/test/dkms_replace_test-2.0/Makefile000066400000000000000000000002371500670340200210550ustar00rootroot00000000000000obj-m += dkms_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_replace_test-2.0/dkms.conf000066400000000000000000000002221500670340200212140ustar00rootroot00000000000000PACKAGE_NAME="dkms_replace_test" PACKAGE_VERSION="2.0" BUILT_MODULE_NAME[0]="dkms_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_replace_test-2.0/dkms_test.c000066400000000000000000000007761500670340200215660ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "2.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_scripts_test-1.0/000077500000000000000000000000001500670340200174665ustar00rootroot00000000000000dkms-3.2.0/test/dkms_scripts_test-1.0/Makefile000066400000000000000000000002471500670340200211310ustar00rootroot00000000000000obj-m += dkms_scripts_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_scripts_test-1.0/dkms.conf000066400000000000000000000005501500670340200212730ustar00rootroot00000000000000PACKAGE_NAME="dkms_scripts_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_scripts_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" POST_ADD="script.sh post_add" PRE_BUILD="script.sh pre_build" POST_BUILD="script.sh post_build" PRE_INSTALL="script.sh pre_install" POST_INSTALL="script.sh post_install" POST_REMOVE="script.sh post_remove" dkms-3.2.0/test/dkms_scripts_test-1.0/dkms_scripts_test.c000066400000000000000000000007761500670340200234100ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_scripts_test-1.0/script.sh000077500000000000000000000000221500670340200213230ustar00rootroot00000000000000#!/bin/sh exit 0 dkms-3.2.0/test/dkms_test-1.0/000077500000000000000000000000001500670340200157175ustar00rootroot00000000000000dkms-3.2.0/test/dkms_test-1.0/Makefile000066400000000000000000000002371500670340200173610ustar00rootroot00000000000000obj-m += dkms_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_test-1.0/dkms.conf000066400000000000000000000002121500670340200175170ustar00rootroot00000000000000PACKAGE_NAME="dkms_test" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="dkms_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_test-1.0/dkms_test.c000066400000000000000000000007761500670340200200720ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "1.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/dkms_test-2.0/000077500000000000000000000000001500670340200157205ustar00rootroot00000000000000dkms-3.2.0/test/dkms_test-2.0/Makefile000066400000000000000000000002371500670340200173620ustar00rootroot00000000000000obj-m += dkms_test.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean dkms-3.2.0/test/dkms_test-2.0/dkms.conf000066400000000000000000000002121500670340200175200ustar00rootroot00000000000000PACKAGE_NAME="dkms_test" PACKAGE_VERSION="2.0" BUILT_MODULE_NAME[0]="dkms_test" DEST_MODULE_LOCATION[0]="/kernel/extra" AUTOINSTALL="yes" dkms-3.2.0/test/dkms_test-2.0/dkms_test.c000066400000000000000000000007761500670340200200730ustar00rootroot00000000000000#include #include #include #define DKMS_TEST_VER "2.0" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("A Simple dkms test module"); static int __init dkms_test_init(void) { printk(KERN_INFO "DKMS Test Module -%s Loaded\n",DKMS_TEST_VER); return 0; } static void __exit dkms_test_cleanup(void) { printk(KERN_INFO "Cleaning up after dkms test module.\n"); } module_init(dkms_test_init); module_exit(dkms_test_cleanup); MODULE_VERSION(DKMS_TEST_VER); dkms-3.2.0/test/framework/000077500000000000000000000000001500670340200154235ustar00rootroot00000000000000dkms-3.2.0/test/framework/bad_cert_file_path.conf000066400000000000000000000003261500670340200220510ustar00rootroot00000000000000# The key file will be generated by openssl. Use a temporary path to avoid corrupting the default private key file on the system mok_signing_key="@tmpdir@/dkms_test_private_key" mok_certificate="/no/such/path.crt" dkms-3.2.0/test/framework/bad_key_file_path.conf000066400000000000000000000000441500670340200217010ustar00rootroot00000000000000mok_signing_key="/no/such/path.key" dkms-3.2.0/test/framework/bad_sign_file_path.conf000066400000000000000000000000321500670340200220460ustar00rootroot00000000000000sign_file="/no/such/file" dkms-3.2.0/test/framework/fail_sign_file_path.conf000066400000000000000000000001711500670340200222370ustar00rootroot00000000000000sign_file="/bin/false" mok_signing_key="@tmpdir@/dkms_test_private_key" mok_certificate="@tmpdir@/dkms_test_certificate" dkms-3.2.0/test/framework/hijacking.conf000066400000000000000000000000611500670340200202160ustar00rootroot00000000000000do_status() { echo "do_status() is hijacked!" } dkms-3.2.0/test/framework/post_transaction.conf000066400000000000000000000001411500670340200216600ustar00rootroot00000000000000post_transaction="echo This is a test message as post transaction. Kernel version is $kernelver" dkms-3.2.0/test/framework/temp_key_cert.conf000066400000000000000000000001421500670340200211210ustar00rootroot00000000000000mok_signing_key="@tmpdir@/dkms_test_private_key" mok_certificate="@tmpdir@/dkms_test_certificate" dkms-3.2.0/test/framework/variables_in_path.conf000066400000000000000000000002631500670340200217450ustar00rootroot00000000000000sign_file="/lib/modules/${kernelver}/build/scripts/sign-file" mok_signing_key="@tmpdir@/dkms_test_dir_${kernelver}/key" mok_certificate="@tmpdir@/dkms_test_dir_${kernelver}/cert"