The document provides an introduction to Linux kernel modules. It discusses that kernel modules extend the capabilities of the Linux kernel by executing code as part of the kernel. It then describes the anatomy of a kernel module, including initialization and cleanup functions. The document demonstrates a simple "hello world" kernel module example and how to build, load and unload kernel modules. It also introduces the idea of character device drivers as a more advanced kernel module example.

1. Linux Kernel
Modules
Eddy Reyes eddy@tasqr.io

2. Eddy Reyes
Founder of Tasqr (www.tasqr.io)
In my past life:
● IBM- AIX kernel developer
● Lifesize- Linux device driver developer
● Various other non-kernel software
development

3. Linux Kernel Modules
In this presentation, I will show what is a Linux
Kernel Module
● Kernel module-
○ Code that executes as part of the Linux kernel
○ Extends the capabilities and sometimes might
modify the behavior of the kernel

4. Let’s Back Up For a Second...
What exactly is the Linux Kernel?

5. Your Computer == Pile of Hardware
Your average computer (or phone) has a quite
large variety of hardware.
● CPU, Disk, NIC, GPU, Speakers, Display,
RAM, DVD Drive, Game Controller,
Webcam, Microphone, GSM Radio, WiFi,
Keyboard, Mouse, Touch Screen, etc.

6. What Is the Kernel?
Very simple answer: it's a program that makes
your hardware look and feel like an OS to other
programs
Hardware (CPU, Keyboard, Disk, Monitor)
Linux Kernel
GNOME bash cat Chome grep

7. Who Uses the Kernel?
The kernel provides a way for other programs
to use the hardware under a common model
called an “Operating System”
● The kernel is not designed for direct human
consumption (no UI)
● The kernel’s user is other programs
● Linux conforms to the POSIX specification.

8. Hardware Protection
Most modern processors protect access to
hardware
● User Mode… running program:
○ Has no access to hardware
○ Has its own dedicated address space
● Privileged Mode… running program:
○ Can mess with all hardware
○ Has access to single shared global address space

9. When Does Kernel Code Execute?
The Kernel has 2 primary entry points:
● On behalf of a process
○ When that process calls a system call
● In response to a hardware interrupt
○ You just pressed a key
○ Your disk just finished storing a block of data
○ A network packet just arrived
○ The timer just ticked

10. Kernel And Hardware
Kernel is the middle-man for hardware access.
Disk Kernel
System Call
cat ~/file
interrupt

11. System Call Layer
The kernel provides system calls for user
programs to perform actions that require
Privileged Mode:
● Example: cat ~/my-file
○ fd = open(“/home/eddy/myfile”)
○ contents = read(fd)
○ close(fd)
○ print(contents)

12. Linux vs. Linux Ecosystem
“Linux” originally referred only to the kernel.
● Linus only works on the kernel
● He doesn’t care a whole lot about what
happens outside of that
○ Except when something irritates him :-)
All the programs you use live outside of the
kernel (GNU/Linux, all distros)

13. Back to Kernel Modules
Almost all problems are solved in user space
programs.
● Why do we need kernel modules?
○ I have some hardware I want to make work in Linux
○ I want to create a program that resides in the kernel
and runs in privileged mode
■ In practice, almost never happens

14. To Write a Kernel Module...
● Kernel Modules are written in the C
programming language.
● You must have a Linux kernel source tree to
build your module.
● You must be running the same kernel you
built your module with to run it.

15. Anatomy of a Kernel Module
A kernel module file has several typical
components:
● MODULE_AUTHOR(“your name”)
● MODULE_LICENSE(“GPL”)
○ The license must be an open source license (GPL,
BSD, etc.) or you will “taint” your kernel.
■ Tainted kernel loses many abilities to run other
other open source modules and capabilities.

16. Anatomy of a Kernel Module
● int init_module(void)
○ Called when the kernel loads your module.
○ Initialize all your stuff here.
○ Return 0 if all went well, negative if something blew
up.
● void cleanup_module(void)
○ Called when the kernel unloads your module.
○ Free all your resources here.

17. Hello World Kernel Module Example
#include <linux/kernel.h>
#include <linux/module.h>
MODULE_AUTHOR(“Eddy Reyes”);
MODULE_LICENSE(“GPL”);
int init_module(void)
{
printk(KERN_ALERT “Hello worldn”);
return 0;
}
void cleanup_module(void)
{
printk(KERN_ALERT “Goodbye, cruel worldn”);
}

18. Kernel Programming Environment
● Kernel has no libc, none of the standard headers and
libraries you are used to.
○ i.e. No system calls, no standard buffered output
(stdio.h)
● No memory protection!
○ You can stomp on any other part of memory, no one
will stop you.

19. Kernel Programming Environment
● One big single namespace
○ You have access to all “exported” symbols from your
kernel module.
○ Exported functions are called “kernel services”
● Always multi-threaded
○ All modules must be thread-safe, like it or not
○ What about single-processor systems?
■ No concurrency, but Linux is a preemptable

20. Building Your Kernel Module
● Accompany your module with a 1-line GNU Makefile:
○ obj-m += hello.o
○ Assumes file name is “hello.c”
● Run the magic make command:
○ make -C <kernel-src> M=`pwd` modules
○ Produces: hello.ko
Assumes current directory is the module source.

21. Running Your Kernel Module
● To manually load your module:
○ insmod hello.ko
○ Where’s our hello world message?
■ dmesg
● To unload your module:
○ rmmod hello.ko

22. Kernel Module Dependencies
insmod/rmmod can be cumbersome...
● You must manually enforce inter-module dependencies.
Modprobe automatically manages dependent modules
● Copy hello.ko into /lib/modules/<version>
● Run depmod
● modprobe hello / modprobe -r hello
Dependent modules are automatically loaded/unloaded.

23. More Interesting Example...
Let’s make a character device
● /dev/hello-char
● When you read from it, it says “hello”
● Doesn’t let you write into it
Character devices are tracked by the kernel via
major and minor numbers
● Major == type of device, Minor == nth device

24. Hello Char Device
Linux Kernel uses an “ops” struct pattern that
allows you to fill in behaviors via callbacks.
struct file_operations fops = {
.open = open_dev,
.close = close_dev,
.read = read_dev,
.write = write_dev
}

25. Registering Your Device
Kernel Service- register_chrdev()
● Accepts:
○ Major number (0 tells the kernel to pick one)
○ Device type name (appears in /proc/devices)
○ Pointer to fops struct
● Call this in the init_module() routine

26. Reading / Writing From Your Device
● cat /dev/hello-char
○ Calls your read_dev() function
● echo hi >/dev/hello-char
○ Calls your write_dev() function
read_dev must return 0 when the device has no more data.

27. Using Your Device
Demo...

28. Linux Device Model
If you write a real device driver, don’t follow this
example. Further reading:
● Linux Device Model
○ Much richer API for modules that implement device
drivers
○ Integrates with udev
○ Not available on tainted kernels!
■ Must be open source to use this.

29. Congratulations!
We’ve built a couple kernel modules together!
Any lingering questions?