Downloaded 147 times
Uploaded byNalin Sharma
Linux Kernel Programming
This document discusses kernel modules in Linux. It begins by defining the kernel as the central part of the operating system that manages processes, memory, devices, and storage. Kernel modules allow new functionality to be added to the kernel at runtime without rebooting. Common module commands like insmod, lsmod and rmmod are described. The document outlines how modules are loaded and unloaded by the kernel and provides a simple "hello world" example of a kernel module.
In this document
Powered by AI
Introduction to kernel module programming by Monis Javed, Nalin Sharma, and Obedullah.
The kernel is the central part of the operating system that controls interactions between applications and hardware.
The kernel manages processes, memory, devices, and storage, playing a critical role in resource allocation.
Different types of kernels include Monolithic, Micro, Hybrid, Nano, and Exo kernels, each with distinct architectures.
Monolithic kernels include the entire OS in kernel space and have speed and size limitations; examples are Linux and MSDOS.
Micro kernels manage only critical tasks like memory and CPU, delegating others to user mode, used in systems like QNX.
Hybrid kernels allow selective operation modes for tasks, seen in Windows NT, 2000, XP, Vista, 7, 8, and Mac OS X.
A brief introduction to kernel modules which extend kernel functionality at runtime.
Kernel modules allow Linux to add features dynamically, preventing system reboots and enabling flexibility.
Device drivers are examples of modules that allow kernel interaction with hardware efficiently.
An introduction to kernel module programming.
Key commands for managing kernel modules include modinfo, lsmod, insmod, rmmod, depmod, and modprobe.
Details on how modules are loaded into the kernel, involving commands like lsmod and modprobe, and handling dependencies.
Demonstrates loading a module (e.g., msdos.o) along with its dependency (fat.o) using insmod and modprobe.
Setting up to write kernel module code.
Each kernel requires specific module versions to work correctly, dependent on CONFIG_MODVERSIONS.
Initial steps to configure the Linux kernel for module development.
Simple example of a kernel module that prints 'Hello world' on initialization.
Kernel modules require init_module and cleanup_module functions for loading and unloading.
The printk() function is for logging within the kernel, not for user communication.
Explains different priority levels for printk() messages used for logging and controlling visibility.
Steps to compile and insert a kernel module: writing code, creating a Makefile, and loading the module.
A Makefile simplifies the compilation of multiple source files into a kernel module.
Renaming the init and exit functions for kernel modules using macros like --module_init() and module_exit().
Explains creating kernel modules that span multiple files and their compilation process.
Describes the rmmod command for safely unloading kernel modules, ensuring they are no longer in use.
Comparison between kernel modules and application programs focusing on execution context and function use.
Cites 'The Linux Kernel Module Programming Guide' as a primary reference for the content covered.
Closing remarks and thanks for attending the presentation.
More Related Content
Similar to Linux Kernel Programming
Linux Kernel Programming
- 1. Kernel Module Programming BY: MONISJAVED NALIN SHARMA OBEDULLAH
- 2. WHAT IS KERNEL? aprogram having control over everything that occurs in system. central part of operating system. it acts as an interface between the user applications and the hardware.
- 3. ROLE OF THEKERNEL Kernel is responsible for: Process Management - allocating resources to a process. - synchronization among processes. Memory Management - allocating and deallocating memory to programs. Device Management - controlling several devices attached to the system. Storage Management - disk management. - disk scheduling.
- 4. TYPES OF KERNEL MonolithicKernel Micro Kernel Hybrid Kernel Nano Kernel Exo Kernel
- 5. MONOLITHIC KERNEL Entire operatingsystem works in kernel space. Larger in size as they retain full privilege access over various components like file system, IPC, IO/device management etc. Slower to load because of large size. Recompilation is required to add more features or remove bugs. Example includes: Linux based OS, MSDOS etc.
- 6. MICRO KERNEL Deals withonly critical activities such as controlling memory and CPU. Everything else is handled under user mode. Kernel don’t have to worry about lower level functionality. Example include: QNX ,Minix.
- 7. HYBRID KERNEL have theability to pick and choose what they want to run in user mode and what they want to run in supervisor mode. Example : Windows NT,2000, XP, Vista,7,8, Mac OS X.
- 8.
- 9. KERNEL MODULES Linux Kernelhas ability to extend its set of features at run time. Modules are pieces of code that can be loaded and unloaded into the kernel upon demand. They extend the functionality of the kernel without the need to reboot the system.
- 10. KERNEL MODULES CONTD… Amodule run in kernel mode. Without loadable kernel modules, an operating system would have to include all possible anticipated functionality already compiled directly into the base kernel. This require rebooting kernel every time when new functionality is added.
- 11. KERNEL MODULES CONTD… Kernelmodules allow a Linux system to be set up with a standard minimal kernel without any extra device drivers built in. For example, one type of module is the device driver, which allows the kernel to access hardware connected to the system.
- 12.
- 13. MODULE COMMANDS • modinfo: display information about a kernel module • lsmod : list loaded modules • insmod : Install loadable kernel module • rmmod : Unload loadable modules • depmod : handle dependency descriptions for loadable kernel modules • modprobe : High level handling of loadable modules
- 14. HOW DO MODULESGET INTO THE KERNEL? modules already loaded into the kernel can be listed by running lsmod, which gets its information by reading the file /proc/modules. When the kernel needs a feature that is not resident in the kernel, the kernel module daemon kmod executes modprobe to load the module in. modprobe is passed a string in one of two forms: · A module name like soft or ppp. · A more generic identifier like
- 15. CONTD…... If modprobe ishanded a generic identifier, it first looks for that string in the file /etc/modules.conf. If it finds an alias line like: alias char−major−10−30 soft it knows that the generic identifier refers to the module soft.o Next, modprobe looks through the file /lib/modules/version/modules.dep, to see if other modules must be loaded before the requested module may be loaded. This file is created by depmod −a and contains module dependencies.
- 16. CONTD…. Lastly, modprobe usesinsmod to first load any prerequisite modules into the kernel, and then the requested module. modprobe directs insmod to /lib/modules/version/, the standard directory for modules. insmod is intended to be fairly dumb about the location of modules, whereas modprobe is aware of the default location of modules.
- 17. CONTD… Example: We need toinsert module msdos.o which requires fat.o module to be already loaded. This can be done in two ways: 1. using insmod insmod /lib/modules/2.5.1/kernel/fs/fat/fat.o insmod /lib/modules/2.5.1/kernel/fs/msdos/msdos. o 2. using modprobe
- 18. BEFORE WE BEGINTO GET INTO THE CODE
- 19. MODVERSIONING Everyone's system isdifferent and everyone has their own groove. A module compiled for one kernel won't load if you boot a different kernel. unless you enable CONFIG_MODVERSIONS in the kernel.
- 20.
- 22. HELLO WORLD PROGRAM /*hello−1.c − The simplest kernel module.*/ #include <linux/module.h> /* Needed by all modules */ #include <linux/kernel.h> /* Needed for KERN_ALERT */ int init_module(void) { printk("Hello world n"); return 0; //A non 0 return means init_module failed; module can't be loaded. } void cleanup_module(void) { printk(KERN_ALERT "Goodbye world 1.n"); }
- 23. Kernel modules musthave at least two functions: a "start" (initialization) function called init_module() which is called when the module is insmoded into the kernel, and an "end" (cleanup) function called cleanup_module() which is called just before it is rmmoded.
- 24. init_module() either registersa handler for something with the kernel, or it replaces one of the kernel functions with its own code (usually code to do something and then call the original function). The cleanup_module() function is supposed to undo whatever init_module() did, so the module can be unloaded safely.
- 25. INTRODUCING PRINTK() printk() isnot meant to communicate information to the user. It is used to log information or give warnings. each printk() statement comes with a priority. There are 8 priorities and the kernel has macros for them. The header file linux/kernel.h describes what each priority means.
- 26. PRINTK() CONTD… 1. KERN_EMERG"<0>" /* emergency message*/ 2. KERN_ALERT "<1>" /* action must be taken immediately*/ 3 KERN_CRIT "<2>" /* critical conditions*/ 4. KERN_ERR "<3>" /* error conditions*/ 5. KERN_WARNING "<4>" /* warning conditions*/ 6. KERN_NOTICE 7. KERN_INFO "<5>" /* normal but significant condition*/ "<6>" /* informational message*/ 8. KERN_DEBUG "<7>" /* debug-level messages*/ Default : DEFAULT_MESSAGE_LOGLEVEL
- 27. PRINTK() CONTD… If thepriority is less than int console_loglevel, the message is printed on your current terminal. We use a high priority, like KERN_ALERT, to make sure the printk() messages get printed to your console rather than just logged to your logfile.
- 28. STEPS FOR COMPILATIONOF KERNEL MODULE 1. write the kernel module code with filename like filename.c 2. make a file containing code for compiling the module and save it using name “Makefile”. 3. now compile the module code by issuing command make. To see what kind of information it is , type:modinfo filename.ko
- 29. CONTD… 4. now insertmodule by command modprobe filename.ko OR insmod filename.ko - you can see your inserted module in cat /proc/modules OR by command lsmod
- 30. MAKE FILE A makefileis a script for appropriate compilation of different type of sources to the appropriate object code. Makefiles are used to define the procedure to compile and link your program. as number of files increases it's very difficult to compile and link them one by one.
- 31. CONTD…. Also you willhave to remember the dependencies between these files. Makefiles are used to automate these tasks so just define your rules once and instead of compiling and linking individual files you just need to execute the makefile.
- 32. HOW TO MAKEA “MAKEFILE” FOR KERNEL MODULE: obj-m += filename.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
- 33. RENAME YOUR FUNCTIONNAME: you can rename the init and cleanup functions of your modules. This is done with the --module_init() and module_exit() These are macros defined in linux/init.h
- 34. EXAMPLE: #include <linux/module.h> #include <linux/kernel.h> #include<linux/init.h> static int _init myname(void) { printk(KERN_INFO “Hello world?”); return 0; } static void _exit yourname(void) { printk(KERN_INFO “Goodbye”); } module_init(myname); module_exit(yourname);
- 35. MODULES SPANNING MULTIPLEFILES:Modules Spanning Multiple Files: First we invent an object name for our combined module, Second we tell make what object files are part of that module.
- 36. begin.c end.c #include <linux/kernel.h> #include <linux/kernel.h> #include<linux/module.h> #include <linux/module.h> int init_module(void) void cleanup_module() { { printk(KERN_INFO "Hello, printk(KERN_INFO worldn"); "Goodbyen"); return 0; } } Makefile :obj-m += beginend.o beginend-objs := begin.o end.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
- 37. MODULE UNLOADING Modules canbe unloaded using rmmod command. rmmod ensures the restriction that the modules are not in use. Unlinked from the kernel and unlisted from the list of kernel modules Dependency is released
- 38. KERNEL MODULES VSAPPLICATION PROGRAM Applications perform a single task from beginning to end. Kernel module just registers itself in order to serve future requests. Application can use library function (like printf) but a module can only use functions exported by kernel (like printk). A module runs in kernel space, whereas applications run in user space.
- 39. REFERENCES The Linux KernelModule Programming Guide by Peter Jay Salzman Michael Burian Ori Pomerantz
- 40.