Kernelmodules zijn stukjes code die op verzoek in de kernel kunnen worden geladen en verwijderd. Ze breiden de functionaliteit van de kernel uit zonder dat het systeem opnieuw hoeft te worden opgestart. Aangepaste codes kunnen via twee methoden aan Linux-kernels worden toegevoegd.

• De basismanier is om de code toe te voegen aan de kernelbronboom en de kernel opnieuw te compileren.
• Een efficiëntere manier is om dit te doen door code aan de kernel toe te voegen terwijl deze actief is. Dit proces wordt het laden van de module genoemd, waarbij module verwijst naar de code die we aan de kernel willen toevoegen.

Omdat we deze codes tijdens runtime laden en ze geen deel uitmaken van de officiële Linux-kernel, worden deze laadbare kernelmodules (LKM) genoemd, die verschilt van de basiskernel. De basiskernel bevindt zich in de map /boot en wordt altijd geladen wanneer we onze machine opstarten, terwijl LKM's worden geladen nadat de basiskernel al is geladen. Niettemin maken deze LKM een groot deel uit van onze kernel en communiceren ze met de basiskernel om hun functies te voltooien. LKM's kunnen een verscheidenheid aan taken uitvoeren, maar vallen in principe onder drie hoofdcategorieën

• apparaatstuurprogramma
• bestandssysteemstuurprogramma en
• Systeemoproepen.

Dus welk voordeel bieden LKM's? Een groot voordeel dat ze hebben is dat we de kernel niet telkens opnieuw hoeven te herbouwen telkens wanneer we een nieuw apparaat toevoegen of als we een oud apparaat upgraden. Dit bespaart tijd en helpt ook om onze basiskernel foutvrij te houden. Een bruikbare vuistregel is dat we onze basiskernel niet mogen veranderen als we eenmaal een werkende basiskernel hebben. Het helpt ook bij het diagnosticeren van systeemproblemen. Stel bijvoorbeeld dat we een module aan de basiskernel hebben toegevoegd (dat wil zeggen dat we onze basiskernel hebben aangepast door deze opnieuw te compileren) en dat de module een bug bevat. Dit zal fouten veroorzaken bij het opstarten van het systeem en we zullen nooit weten welk deel van de kernel problemen veroorzaakt. Terwijl als we de module tijdens runtime laden en dit problemen veroorzaakt, we het probleem onmiddellijk zullen kennen en de module kunnen ontladen totdat we deze hebben opgelost. LKM's zijn zeer flexibel in de zin dat ze met één enkele opdrachtregel kunnen worden geladen en gelost. Dit helpt bij het besparen van geheugen, omdat we de LKM alleen laden als we ze nodig hebben. Bovendien zijn ze niet langzamer dan de basiskernel, omdat het aanroepen van een van beide simpelweg code uit een ander deel van het geheugen laadt. **Waarschuwing: LKM's zijn geen gebruikersruimteprogramma's. Ze maken deel uit van de kernel. Ze hebben het systeem vrij en kunnen het gemakkelijk laten crashen. So now that we have established the use loadable kernel modules we are going to write a hello world kernel module. That will print a message when we load the module and an exit message when we unload the module. Code: CPP

   /**    * @file hello.c    * @author Akshat Sinha    * @date 10 Sept 2016    * @version 0.1    * @brief An introductory 'Hello World!' loadable kernel    * module (LKM) that can display a message in the /var/log/kern.log    * file when the module is loaded and removed. The module can accept    * an argument when it is loaded -- the name which appears in the    * kernel log files.   */   #include         /* Needed by all modules */   #include         /* Needed for KERN_INFO */   #include         /* Needed for the macros */   /// < The license type -- this affects runtime behavior   MODULE_LICENSE  (  'GPL'  );   /// < The author -- visible when you use modinfo   MODULE_AUTHOR  (  'Akshat Sinha'  );   /// < The description -- see modinfo   MODULE_DESCRIPTION  (  'A simple Hello world LKM!'  );   /// < The version of the module   MODULE_VERSION  (  '0.1'  );   static     int     __init     hello_start  (  void  )   {      printk  (  KERN_INFO     'Loading hello module...  n  '  );      printk  (  KERN_INFO     'Hello world  n  '  );      return     0  ;   }   static     void     __exit     hello_end  (  void  )   {      printk  (  KERN_INFO     'Goodbye Mr.  n  '  );   }   module_init  (  hello_start  );   module_exit  (  hello_end  );   

Verklaring voor de bovenstaande code: Kernelmodules moeten ten minste twee functies hebben: een 'start' (initialisatie) functie genaamd init_module() die wordt aangeroepen wanneer de module in de kernel wordt geïnsmodeerd en een 'end' (opruim) functie genaamd cleanup_module() die wordt aangeroepen net voordat deze wordt germmoded. Eigenlijk zijn er dingen veranderd vanaf kernel 2.3.13. U kunt nu elke gewenste naam gebruiken voor de start- en eindfuncties van een module. In feite is de nieuwe methode de voorkeursmethode. Veel mensen gebruiken echter nog steeds init_module() en cleanup_module() voor hun start- en eindfuncties. In deze code hebben we hello_start() als init-functie en hello_end() als opschoonfunctie gebruikt. Een ander ding dat je misschien is opgevallen is dat we in plaats van de printf()-functie printk() hebben gebruikt. Dit komt omdat de module niets op de console zal afdrukken, maar het bericht in /var/log/kern.log zal loggen. Daarom wordt het gebruikt om kernelmodules te debuggen. Bovendien zijn er acht mogelijke tekenreeksen op logniveau gedefinieerd in de header die vereist zijn bij het gebruik van printk(). We hebben ze opgesomd in volgorde van afnemende ernst:

• KERN_EMERG: Gebruikt voor noodberichten, meestal berichten die aan een crash voorafgaan.
• KERN_ALERT: Een situatie die onmiddellijke actie vereist.
• KERN_CRIT: Kritieke omstandigheden hebben vaak betrekking op ernstige hardware- of softwarefouten.
• KERN_ERR: gebruikt om foutcondities te rapporteren; apparaatstuurprogramma's gebruiken vaak KERN_ERR om hardwareproblemen te melden.
• KERN_WARNING: Waarschuwingen voor problematische situaties die op zichzelf geen ernstige problemen met het systeem veroorzaken.
• KERN_NOTICE: Situaties die normaal zijn, maar toch het vermelden waard. Op dit niveau worden een aantal beveiligingsgerelateerde aandoeningen gerapporteerd.
• KERN_INFO: Informatieve berichten. Veel stuurprogramma's drukken op dit niveau informatie af over de hardware die ze bij het opstarten aantreffen.
• KERN_DEBUG: Gebruikt voor het debuggen van berichten.
We hebben KERN_INFO gebruikt om het bericht af te drukken. Het systeem voorbereiden om de code uit te voeren: The system must be prepared to build kernel code and to do this you must have the Linux headers installed on your device. On a typical Linux desktop machine you can use your package manager to locate the correct package to install. For example under 64-bit Debian you can use:

akshat@gfg:~$ sudo apt-get install build-essential linux-headers-$(uname -r)  

Makefile om de broncode te compileren:

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

**Opmerking: vergeet de tabbladruimten in Makefile niet De module compileren en laden: Run the make command to compile the source code. Then use insmod to load the module.

akshat@gfg:~$ make make -C /lib/modules/4.2.0-42-generic/build/ M=/home/akshat/Documents/hello-module modules make[1]: Entering directory `/usr/src/linux-headers-4.2.0-42-generic' CC [M] /home/akshat/Documents/hello-module/hello.o Building modules stage 2. MODPOST 1 modules CC /home/akshat/Documents/hello-module/hello.mod.o LD [M] /home/akshat/Documents/hello-module/hello.ko make[1]: Leaving directory `/usr/src/linux-headers-4.2.0-42-generic'  

Now we will use insmod to load the hello.ko object.

akshat@gfg:~$ sudo insmod hello.ko  

De module testen: You can get information about the module using the modinfo command which will identify the description author and any module parameters that are defined:

akshat@gfg:~$ modinfo hello.ko filename: /home/akshat/Documents/hello-module/hello.ko version: 0.1 description: A simple Hello world LKM author: Akshat Sinha license: GPL srcversion: 2F2B1B95DA1F08AC18B09BC depends: vermagic: 4.2.0-42-generic SMP mod_unload modversions  

To see the message we need to read the kern.log in /var/log directory.

akshat@gfg:~$ tail /var/log/kern.log ... ... Sep 10 17:43:39 akshat-gfg kernel: [26380.327886] Hello world To unload the module we run rmmod: akshat@gfg:~$ sudo rmmod hello Now run the tail command to get the exit message. akshat@gfg:~$ tail /var/log/kern.log ... Sep 10 17:43:39 akshat-gfg kernel: [26380.327886] Hello world Sep 10 17:45:42 akshat-gfg kernel: [26503.773982] Goodbye Mr.