Linux kernel code

Module Programming
● Module Initialization
● Module Cleanup
● Compiling and Loading a module
● The Makefile
● Module Parameters
● Kernel Symbol Table

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.

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.

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.

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.

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”.

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)

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);

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);

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.

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

Compiling the Module
linux:~ $ make
linux:~ $ sudo insmod hello.ko
linux:~ $ dmesg
linux:~ $ lsmod
linux:~ $ sudo rmmod hello
linux:~ $ dmesg

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

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.

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.

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.

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).

Linux kernel code

More Related Content

What's hot (10)

Viewers also liked (20)

Similar to Linux kernel code (20)

Recently uploaded (20)

Linux kernel code