Linux kernel code
5 likes820 views
Linux device drivers can be loaded as modules at runtime. A module begins with a module_init() function and ends with a module_exit() function. Modules export symbols and functions to be used by other modules. The Makefile is used to compile the module and modprobe loads dependent modules by examining the modules.dep file.
Linux kernel code
- 2. Module Programming ● Module Initialization ● Module Cleanup ● Compiling and Loading a module ● The Makefile ● Module Parameters ● Kernel Symbol Table
- 3. What are modules ? ● Simple pieces of C code. ● Each piece of code that can be added to the kernel at runtime is called module. ● No main() function like normal C programs. ● Module Initialization and Cleanup ● Mechanisms of registering and De-registering with the kernel.
- 4. Module Initialization ● A module always begin with the function you define with module_init( ). ● module_init(): ● This is the entry point for the module. ● It tells the kernel what functionality module provides. ● Once it's done, module remains in kernel waiting to be called. ● Calls are executed by user space application.
- 5. Module Cleanup ● A module ends by calling module_exit() function. ● module_exit(): ● Exit point for module. ● It will undo whatever initialization function performed. ● It unregisters the module from kernel. ● It returns all resources to the system.
- 6. Functions in Modules ● Standard C library functions cannot be used in module programming. ● Functions/Variables shared between modules have to be exported as kernel symbols into global space. ● To see the symbols exported into the kernel “cat /proc/kallsyms“ ● If symbol is not found, module will not be loaded to kernel and return back with an error.
- 7. Important MACRO'S ● module_init (<name for your init function>) ● module_exit (<name for your exit function>) ● Whatever name is passed to the above macros should be defined as the name of the init and exit functions. ● MODULE_LICENSE(“GPL”) ● Without this kernel gives warning message of “kernel tainted”.
- 8. License Terms ● Linux is licensed under version 2 of the GNU General Public License (GPL) . ● The GPL allows anybody to redistribute, and even sell a product covered by the GPL. ● The specific licenses recognized by the kernel are ● “GPL” (for any version of the GNU General Purpose License) ● “GPL v2” (for GPL version two only)
- 9. The Hello World Module Initialization #include <linux/init.h> #include <linux/module.h> static int __init hello_init(void) { printk(KERN_INFO“n Hello, Worldn”); return 0; } module_init(hello_init);
- 10. The Hello World Module Cleanup #include <linux/init.h> #include <linux/module.h> static void __exit hello_exit(void) { printk(KERN_INFO“n Goodye, Worldn”); } module_exit(hello_exit);
- 11. The Makefile ● Makefile is a file that describes the dependencies among files in your program and provides commands for updating each file. ● Once a suitable Makefile exists, each time you change some source files, this simple shell command: – make suffices to perform all necessary recompilations.
- 12. Makefile obj-m := hello.o KERN_SRC := /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) modules: make –C $(KERN_SRC) M=$(PWD) modules modules_install: make –C $(KERN_SRC) M=$(PWD) modules_install Clean: make –C $(KERN_SRC) M=$(PWD) clean
- 13. Compiling the Module linux:~ $ make linux:~ $ sudo insmod hello.ko linux:~ $ dmesg linux:~ $ lsmod linux:~ $ sudo rmmod hello linux:~ $ dmesg
- 14. Module Parameters ● Parameters may be passed to the modules during module insertion ● The macro “module_param(name, type,perm)” is used to initialize the parameter at runtime. It takes 3 arguments which are the parameter name, parameter type and the permissions associated with the parameter ● This macro may be defined anywhere in the module
- 15. The Kernel Symbol Table ● Global Kernel Space ● Modules can export services to other modules through the use of kernel macros “EXPORT_SYMBOL(name)” which takes the name of the parameter or function as argument. ● This exported function may be used by other modules in requirement of similar functionality as done by the exported function.
- 16. Modprobe ● Modprobe is a cleverer version of insmod. ● It inserts dependent modules after examining the contents of /lib/modules/X.Y.Z/modules.dep ● modules.dep is created by a utility callled depmod. ● Depmod creates a Makefile-like depency file based on symbols contained in the modules.
- 17. Insmod vs Modprobe ● modprobe works in similar way as that of insmod, but it also loads any other modules that are required by the module you want to load. ● If your module depends upon three more modules, you have to do insmod three times plus once for loading that module itself ● But with modprobe, one single time is enough. It solves the dependency and loads the modules which are required.
- 18. Precautions for Kernel Programming ● Do not use Infinite/never ending loops. ● We should avoid floating point numbers. ● Stack size is limited to 4KB. ● We don't have access to the libraries (user space).