Linux Kernel ModulesEddy Reyes eddy@tasqr.io

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

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

Lets Back Up For a Second...

What exactly is the Linux Kernel?

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.

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

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 kernels user is other programs Linux conforms to the POSIX specification.

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

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

Kernel And Hardware

Kernel is the middle-man for hardware access.

Disk Kernel

System Call

cat ~/file

interrupt

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)

Linux vs. Linux Ecosystem

Linux originally referred only to the kernel. Linus only works on the kernel He doesnt 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)

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

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.

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.

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.

Hello World Kernel Module Example#include #include

MODULE_AUTHOR(Eddy Reyes);

MODULE_LICENSE(GPL);

int init_module(void)

{

printk(KERN_ALERT Hello world\n);

return 0;

}

void cleanup_module(void)

{

printk(KERN_ALERT Goodbye, cruel world\n);

}

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.

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 kernel! Still must be thread-safe.

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 M=`pwd` modules Produces: hello.ko

Assumes current directory is the module source.

Running Your Kernel Module

To manually load your module: insmod hello.ko Wheres our hello world message?

dmesg

To unload your module: rmmod hello.ko

Kernel Module Dependenciesinsmod/rmmod can be cumbersome... You must manually enforce inter-module dependencies.

Modprobe automatically manages dependent modules Copy hello.ko into /lib/modules/ Run depmod modprobe hello / modprobe -r hello

Dependent modules are automatically loaded/unloaded.

More Interesting Example...

Lets make a character device /dev/hello-char When you read from it, it says hello Doesnt let you write into itCharacter devices are tracked by the kernel via major and minor numbers Major == type of device, Minor == nth device

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

}

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

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.

Using Your Device

Demo...

Linux Device Model

If you write a real device driver, dont 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.

Congratulations!

Weve built a couple kernel modules together!

Any lingering questions?