Linux – Cannot remove or reinsert kernel module after error while inserting it without rebooting

kernel-moduleslinux

I am learning how to create kernel modules and it was all working fine: I compiled, inserted the .ko with sudo insmod cheat.ko, and the printk messages inside the init function (set by module_init) appeared correctly in /etc/log/syslog. Then I made changes to the module, removed it with sudo rmmod cheat.ko, reinserted, and printk messages were good again.

Then, when I tried a new feature the screen became like a tty, error messages all over, I did ctrl-alt-f2 ctrl-alt-f7 (I'm on ubuntu), and I got back to the X server.

I undid the most recent modifications to the source file, recompiled, but the problem now is that I am unable to reinsert the module to test things out again, unless I reboot, which is too annoying for testing.

How can I reinsert the modified module without rebooting?

What I tried and info I got:

cat /etc/log/syslog: The only relevant information to me was:
```
BUG: unable to handle kernel NULL pointer dereference at 00000003
```
so it seems that was the cause of the problem, and then I got an oops:
```
Oops: 0002 [#1] SMP
```
Horrid debug information follows that, but nothing that seems to help me on how to reinsert the module.
sudo insmod cheat.ko: command just hangs, outputs nothing, and the only way I can get on using that terminal emulator is killing it with c-c

sudo rmmod cheat:

Error: Module cheat is not currently loaded

sudo modprobe -r cheat.ko
```
FATAL: Module cheat.ko not found.
```
lsmod | grep cheat:
```
cheat                  19009  -2
```
which has a very suspicious -2 usage count…
cat /proc/modules | grep cheat
```
cheat 19009 1 - Loading 0x00000000 (OF+)
```
interesting, so the module is still loading…

Edit

As others have said, use a VM. And I strongly recommend you to use Vagrant to manage it.

Edit 2

Nah, Vagrant is for newbs, use QEMU + Buildroot instead: https://github.com/cirosantilli/linux-kernel-module-cheat

Best Answer

The Linux kernel is only willing to unload modules if their module_exit function returns successfully. If some function from the module crashes, the kernel may be able to recover, but the module is locked in memory. It may be possible to rummage through the kernel data structures and forcibly mark the module as unloadable (try patching the module_exit function to do nothing), but that's risky. Your best bet is to reboot.

The normal way to test a kernel module is in a virtual machine. Don't test the module on your development machine. A VM has the advantage over a physical machine that you can save the VM state in a ready-for-testing configuration and restore it as many times as you like, which saves the startup time between tests.

Related Solutions

Kernel Modules – Compile Linux Kernel Module Without Module.symvers

First, in order to answer your question "can I compile Linux kernel module without Module.symvers", we need to understand what is the purpose of Module.symvers:

Module.symvers serves two main purposes:

1) It lists all exported symbols from vmlinux and all modules.

2) It lists the CRC if CONFIG_MODVERSIONS is enabled. Without CONFIG_MODVERSIONS enabled, the CRC would read 0x00000000.

Module.symvers will be generated during a kernel build, it contains all exported symbols from the kernel and compiled modules. For each symbol, the corresponding CRC value is also stored. The syntax of the Module.symvers file is:

    <CRC>       <Symbol>           <module>

For example:

    0x2d036834  scsi_remove_host   drivers/scsi/scsi_mod

Having said that, if we have Module.symvers then we can build any module because it contain all the necessary symbols.

If Module.symvers is not available, we still able to build an external module either by building this file or by borrowing it from another module.

Usually, when building an external module, the build system needs access to the symbols from the kernel to check if all external symbols are defined. This is done in a build step called MODPOST. This step obtains the symbols by reading Module.symvers from the kernel source tree.

If a Module.symvers file is present in the directory where the external module is being built, this file will be read too. During the MODPOST step, a new Module.symvers file will be written containing all exported symbols that were not defined in the kernel.

if Module.symvers file is not present, then an external module might be using an exported symbols from another external module, kbuild needs to have full knowledge of all symbols to avoid spitting out warnings about undefined symbols.

For this situation, there are three solutions:

1) Use a top-level kbuild file: If you have two modules, foo.ko and bar.ko, where foo.ko needs symbols from bar.ko, you can use a common top-level kbuild file so both modules are compiled in the same build. Consider the following directory layout:

    ./foo/ <= contains foo.ko
    ./bar/ <= contains bar.ko

    The top-level kbuild file would then look like:

    #./Kbuild (or ./Makefile):
        obj-y := foo/ bar/

    And executing

        $ make -C $KDIR M=$PWD

    will then do the expected and compile both modules with
    full knowledge of symbols from either module.

2) Use an extra Module.symvers file: When an external module is built, a Module.symvers file is generated containing all exported symbols which are not defined in the kernel. To get access to symbols from bar.ko, copy the Module.symvers file from the compilation of bar.ko to the directory where foo.ko is built. During the module build, kbuild will read the Module.symvers file in the directory of the external module, and when the build is finished, a new Module.symvers file is created containing the sum of all symbols defined and not part of the kernel.

3) Use "make" variable KBUILD_EXTRA_SYMBOLS: If it is impractical to copy Module.symvers from another module, you can assign a space separated list of files to KBUILD_EXTRA_SYMBOLS in your build file. These files will be loaded by modpost during the initialization of its symbol tables.

More details 1

Best Answer

Related Solutions

Kernel Modules – Compile Linux Kernel Module Without Module.symvers

Related Question