Creating a Linux Kernel Module to Reboot the System Using emergency_restart API

The Linux kernel offers a powerful set of APIs for system control, including the ability to reboot the system programmatically. One such API is emergency_restart, a function designed to reboot the system immediately without the usual shutdown sequence. This is particularly useful in critical scenarios where the system needs to be restarted without delay. In this blog post, we’ll guide you through creating a simple Linux kernel module that utilizes the emergency_restart API to reboot your system.

Understanding the emergency_restart API

The emergency_restart function is part of the Linux kernel’s reboot mechanisms. Unlike the standard reboot function, which attempts to gracefully shut down processes and unmount file systems, emergency_restart immediately resets the system. This function is typically used in scenarios where a clean shutdown is not possible, such as in the event of a critical system failure.

Here’s the basic prototype of the emergency_restart function:

void emergency_restart(void);

This function takes no arguments and does not return any value. Once called, it forces an immediate system reboot.

Step 1: Setting Up Your Development Environment

Before writing the kernel module, ensure you have the necessary development tools installed on your Linux system. You’ll need the following:

• A Linux-based operating system (preferably Ubuntu or another Debian-based distribution).
• Kernel headers and source code.
• Development tools like gcc, make, and git.

To install these tools on Ubuntu, you can use:

sudo apt-get update
sudo apt-get install build-essential linux-headers-$(uname -r)

Step 2: Writing the Kernel Module

Now, let’s write a simple kernel module that calls the emergency_restart function. Create a new file named reboot_module.c and add the following code:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/reboot.h>

static int __init reboot_module_init(void) {
    printk(KERN_INFO "Reboot module loaded.\n");
    printk(KERN_INFO "Rebooting the system using emergency_restart.\n");
    emergency_restart();
    return 0;
}

static void __exit reboot_module_exit(void) {
    printk(KERN_INFO "Reboot module unloaded.\n");
}

module_init(reboot_module_init);
module_exit(reboot_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A Linux kernel module to reboot the system using emergency_restart API");

Explanation of the Code:

1. Including Headers: We include necessary headers such as module.h for module development, kernel.h for kernel-related functions, init.h for initialization macros, and reboot.h for the emergency_restart function.
2. Module Initialization Function: The reboot_module_init function is executed when the module is loaded. It logs a message and then immediately calls emergency_restart to reboot the system.
3. Module Exit Function: The reboot_module_exit function is executed when the module is unloaded. However, in this case, the system will already have rebooted, so this function is unlikely to be called.
4. Module Metadata: The MODULE_LICENSE, MODULE_AUTHOR, and MODULE_DESCRIPTION macros provide information about the module.

Step 3: Compiling and Testing the Module

To compile the kernel module, you’ll need to create a Makefile. Create a file named Makefile in the same directory as reboot_module.c with the following content:

obj-m += reboot_module.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

Compile the module by running:

make

This will generate a file named reboot_module.ko, which is your kernel module.

Step 4: Loading the Kernel Module

Load the module using the insmod command:

sudo insmod reboot_module.ko

As soon as the module is loaded, the system will immediately reboot due to the emergency_restart call.

Conclusion

Creating a Linux kernel module to reboot the system using the emergency_restart API is a straightforward process. This powerful API allows for immediate system reboots, which can be critical in scenarios where a graceful shutdown is not possible. While this is a simple example, it demonstrates the basic steps involved in writing and testing a kernel module that interacts with low-level system functionality.