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.

1. Kernel Module Programming
BY:
MONIS JAVED
NALIN SHARMA
OBEDULLAH

2. WHAT IS KERNEL?
a program 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 THE KERNEL
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

Monolithic Kernel

Micro Kernel

Hybrid Kernel

Nano Kernel

Exo Kernel

5. MONOLITHIC KERNEL





Entire operating system 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 with only 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 the ability 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. INTRODUCING KERNEL MODULES

9. KERNEL MODULES

Linux Kernel has 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…

A module 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…

Kernel modules 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. MODULE PROGRAMMING

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 MODULES GET 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 is handed 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 uses insmod 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 to insert 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 BEGIN TO GET INTO THE CODE

19. MODVERSIONING

Everyone's system is different 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. STEPS


#cd /usr/src/linux-headers-3.8.0-34-generic/
#make menuconfig

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 must have 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 registers a 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() is not 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 the priority 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 COMPILATION OF
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 insert module 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 makefile is 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 will have 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 MAKE A “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 FUNCTION NAME:
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 MULTIPLE FILES: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 can be 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 VS APPLICATION
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 Kernel Module Programming Guide
by
Peter Jay Salzman
Michael Burian
Ori Pomerantz

40. THANK YOU