Linux Kernel Modules are pieces of code that can be loaded into the Linux kernel to extend its capabilities without having to rebuild the kernel. One practical use of a Linux kernel module is to reboot the system. This can be achieved by leveraging the emergency_restart API , which is a powerful function provided by the Linux kernel to force a system reboot.

Command line execution

Terminalbash
sed in scenarios where the system is in a critical state, as it can lead to data loss if unsaved data is present. Creating a Linux Kernel Module to Reboot the System Here, we will create a simple  Linux kernel module  that uses the  emergency_restart API  to reboot the system. Follow these steps to get started. Step 1: Set Up Your Development Environment Install Kernel Headers : Kernel headers are needed to compile kernel modules. Use the following command to install them:    sudo apt-get install linux-headers-$(uname -r) Create a Working Directory : Create a directory to store the module source code.    mkdir ~/kernel_module_reboot    cd ~/kernel_module_reboot Step 2: Write the Kernel Module Code Create a file named  reboot_module.c  and add the following code: #include <linux/module.h> #include <linux/kernel.h> #include <linux/reboot.h> MODULE_LICENSE("GPL"); MODULE_AUTHOR("Your Name"); MODULE_DESCRIPTION("A simple Linux kernel module to reboot the system using emergency_restart API"); static int __init reboot_module_init(void) {     printk(KERN_INFO "Reboot Module Loaded: Rebooting 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); Explanation : The  emergency_restart()  function is called in the module’s initialization function ( reboot_module_init() ), which causes the system to reboot as soon as the module is loaded. MODULE_LICENSE() ,  MODULE_AUTHOR() , and  MODULE_DESCRIPTION()  provide metadata about the module. Step 3: Compile the Kernel Module To compile the kernel module, create a  Makefile  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 Step 4: Load the Kernel Module Use the  insmod  command to load the kernel module: sudo insmod reboot_module.ko Note : As soon as the module is loaded, the system will reboot immediately due to the  emergency_restart()  call. Step 5: Remove the Kernel Module  (Optional) If you need to remove the module after testing (in case you modify it to delay the reboot), use: sudo rmmod reboot_module Common Issues and Troubleshooting 1. Missing Kernel Headers If you encounter errors about missing kernel headers during compilation, make sure that the correct kernel headers are installed. Run: sudo apt-get install linux-headers-$(uname -r) 2. Permission Denied Loading kernel modules requires  root privileges . Always use  sudo  when running commands like  insmod  or  rmmod . 3. System Not Rebooting If the system does not reboot, ensure that the kernel supports the  emergency_restart  function. Some kernel versions or configurations may disable this feature for stability reasons. Best Practices for Using emergency_restart API Use Caution : Only use  emergency_restart  when absolutely necessary, as it can lead to data loss if files are open or changes are not saved. Testing Environment : Test the kernel module in a virtual machine or non-critical environment to avoid unintended disruptions. Log Messages : Use  printk()  to log messages that can help in debugging if the module does not work as expected. Conclusion Creating a  Linux kernel module  to reboot the system using the  emergency_restart API  is a powerful way to manage system behavior, especially in emergency scenarios. By following the steps outlined in this guide, you can create and load a kernel module that reboots your system instantly. However, use this functionality with caution, as improper use can lead to data loss and system instability. Understanding how the  emergency_restart API  works and how to implement it in a kernel module enhances your Linux kernel programming skills, providing you with more control over system-level operations.

Risk level: destructive. Review the command before running it.

Implementation details

In this post, we will explore what emergency_restart API is, how to create a kernel module to utilize this API, and the steps involved to reboot the Linux system effectively. Whether you are a beginner learning about Linux kernel programming or an experienced developer looking for a solution to automate system restarts, this guide provides all the information you need. What is the emergency_restart API? The emergency_restart API is a function in the Linux kernel that forces the system to immediately reboot without performing the usual system shutdown procedures. It is a part of the kernel’s reboot handling and is useful in scenarios where a controlled shutdown is not possible or desirable.

Gotchas and common issues

  • Permission checks - verify user access rights and sudo privileges before executing system-level operations.

  • Environment configuration - double-check path variables and dependency versions to prevent runtime failures.

  • Backup safeguards - maintain configuration backups before applying system or database modifications.

Following these steps ensures clean configuration and reliable execution for powerfully reboot linux with a kernel module: using emergency_restart api.