+ All Categories
Home > Software > Linux kernel modules

Linux kernel modules

Date post: 16-Jul-2015
Author: eddy-reyes
View: 183 times
Download: 4 times
Share this document with a friend
Embed Size (px)
Popular Tags:
of 29 /29
Linux Kernel Modules Eddy Reyes [email protected]
  • Linux Kernel ModulesEddy Reyes [email protected]

  • 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


  • 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


  • 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


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


    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


    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?


    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


  • 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?