Kernel Module Programming

Kernel Modules
What exactly is a kernel module ?
• 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.
• For example, one type of module is the device driver, which
allows the kernel to access hardware connected to the
system.
• Without modules, we would have to build monolithic
kernels
• Larger kernels,disadvantage of requiring us to rebuild and
reboot the kernel every time for new functionality.

OS Basics
• Linux operates in two modes
• Kernel mode (kernel space) and
• User mode (user space)
• So kernel architectures depending upon this
• Monolithic
• Micro-kernel

Monolithic kernels
• Kernel implemented as an only one process
• Large program where all the functional
components of the kernel have access to all
of its internal data structures and routines
Micro-kernels
• kernel perform only the essential
operations
• Everything else should be performed in
user space
• Memory management, file systems and
IPC communications are not inside the
kernel

And the linux kernel is...?
• Monolithic, but it is also modular
• Kernel can dynamically load parts of the kernel
code(Modules)
• Possible to extend the kernel capabilities without
modifying the rest of the code
• Possible to insert the module while the kernel is
running
• Keeps the kernel size to a minimum and makes
the kernel very flexible

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

How Do Modules Get Into The Kernel?

Modules already loaded into the kernel can be seen
by running lsmod

kernel daemon(kerneld daemon or kmod) execs
modprobe to load the module in
• modprobe is passed a string in one of two forms:
-A module name like softdog or ppp.
-A more generic identifier like char-major-10-30.

• If modprobe is handed a generic identifier, it first looks for
that string in the file
/etc/modprobe.conf--> /lib/modules/version/modules.alias
• If it finds an alias line like:
alias char-major-10-30 softdog
• Then dependencies are seen
• For example, msdos.ko requires the fat.ko module to be already
loaded into the kernel.
• modprobe uses insmod to first load any prerequisite modules into
the kernel, and then the requested module

• Linux distributions provide modprobe, insmod and depmod
as a package called modutils or mod-utils.

• Until 2.4 kernel versions, module file & object file had
same extension i.e. .o

• From 2.4 & above to differentiate between object file &
module file, module file has extension .ko

Module Unloading
• Modules can be unloaded using rmmod
command
• rmmod ensures the restriction that the modules
are not in use
• Automatically removed from the system by
`kerneld' when they are no longer used
• cleanup_module function of the concerned
module is called to freeup the kernel resources it
has allocated
• Unlinked from the kernel and unlisted from the
list of kernel modules
• Dependency is released

Module Functions
• 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
• Typically, init_module( ) either registers a handler for
something with the kernel.
• An "end" (cleanup) function called cleanup_module ( )
which is called just before it is rmmoded.
• The cleanup_module( ) function is supposed to undo
whatever init_module( ) did, so the module can be unloaded
safely.

Module Functions
• As of Linux 2.4, you can rename the init
and cleanup functions

• This is done with the module_init() and
module_exit() macros

• These macros are defined in linux/init.h.

Using printk( )
• printk seems to be the similar function like printf
• Since we are dealing with kernel programming , kernel can’t
access user library functions
• So only functions used by modules are the one defined by
kernel.
• printk( ) happens to be a logging mechanism for the kernel,
and is used to log information or give warnings.
• There are 8 priorities and the kernel has macros for them,
and you can view them (and their meanings) in
linux/kernel.h.

Using printk( )
• If you don't specify a priority level, the default priority,
DEFAULT_MESSAGE_LOGLEVEL, will be used

• We usually use a high priority, like KERN_ALERT

• When you write real modules, you'll want to use priorities
that are meaningful for the situation at hand.

Differences between
Modules
And
Programmes

How programmes begin and end

Program begins with a main() function, executes a bunch
of instructions and terminates upon completion of those
instructions.
• Module begins with either the init_module or the function
you specify with module_init call.
• This is the entry function for modules; it tells the kernel
what functionality the module provides and sets up the
kernel to run the module's functions when they're needed.
• Once it does this, entry function returns and the module
does nothing until the kernel wants to do something with
the code that the module provides.

How modules begin and end

• All modules end by calling either cleanup_module
or the function you specify with the module_exit
call.
• This is the exit function for modules; it undoes
whatever entry function did.
• It unregisters the functionality that the entry
function registered.
• Every module must have an entry function and an
exit function.

Functions available to Programmes

• Programmers use functions they don't define all the
time.

• A prime example of this is printf().

• You use these library functions which are provided
by the standard C library.

Functions available to Modules
• Kernel modules are different here, too.The only
functions you can use are the ones provided by the
kernel.
• That's because modules are object files whose
symbols get resolved upon insmod'ing.
• The definition for the symbols comes from the
kernel itself.
• Symbols have been exported by your kernel,the
information is available from
– /proc/ksyms (old versions)-->
– /proc/kallsyms

User Space vs Kernel Space
• Library functions are higher level, run completely in
user space and provide a more convenient interface for
the programmer
• System calls run in kernel mode on the user's behalf and
are provided by the kernel itself.
• Library function calls one or more system calls, and
these system calls execute in supervisor mode since they
are part of the kernel itself.
• Once the system call completes its task, it returns and
execution gets transferred back to user mode.

Namespace
• When writing kernel code, even the smallest module will be
linked against the entire kernel, so this is definitely an issue.
• The best way to deal with this is to declare all your variables
as static and to use a well-defined prefix for your symbols.
• By convention, all kernel prefixes are lowercase.
• If you don't want to declare everything as static, another
option is to declare a symbol table and register it with a
kernel.
• The file /proc/ksyms-->/proc/kallsyms holds all the symbols
that the kernel knows about and which are therefore
accessible to your modules since they share the kernel's
codespace.

Codespace
• The kernel has its own space of memory as well.
• Since a module is code which can be dynamically
inserted and removed in the kernel, it shares the
kernel's codespace rather than having its own.
• Therefore, if your module segfaults, the kernel
segfaults.
• In general it is true for any operating system which
uses a monolithic kernel.

Application to Module Programming

An introduction to device drivers
• One class of modules is the device driver, which provides
functionality for hardware like a TV card or a serial port.
• On unix, each piece of hardware is represented by a file
located in /dev named a device file which provides the
means to communicate with the hardware.
• The device driver provides the communication on behalf of
a user program.

References
The Linux Kernel Module Programming Guide by
Peter Jay Salzman
http://en.wikipedia.org/wiki/Linux_Kernel_Module
http://ftp.kernel.org/pub/linux/utils/kernel/module-
init-tools/
http://en.wikipedia.org/wiki/Modprobe
http://ftp.kernel.org/pub/linux/utils/kernel/modutils/
http://www.linuxhq.com/guides/LKMPG/mpg.html
Linux Loadable Kernel Module HOWTO by Bryan
Henderson

Thank You ...

Saurabh S. Bangad

Kernel Module Programming

More Related Content

What's hot

Viewers also liked

Similar to Kernel Module Programming

Recently uploaded

In this document

Kernel Module Programming