Formation Noyau Linux & développement de drivers

Introducing the Linux kernel (architecture, compilation)

Introducing the kernel development API

• kernel module API

• char, network and block devices

• kernel support for PCI, USB and platform device

Introducing the device tree

Debugging and profiling kernel and drivers

A practical work is available for each item with a “star” (*).

Linux introduction

Introducing the Linux project

Licensing !

Linux (UNIX) architecture (user/kernel space)

Introducing “systemd”

Using Linux kernel sources

• Obtaining the source code

• Configuration

• Native (x86) and cross compilation (ARM) *

The kernel module API

Writing a simple “Hello World” module *

• The “init” and “exit” functions

• Writing a Makefile *

• Loading and unloading module using “kmod”

Module dependencies *

Using module parameters *

The char driver API

Module vs driver

Drivers categories (char, block, network)

Char driver syscalls (open, read, write, close, ioctl)

Registering a char driver *

Using kernel “classes” *

Using the CDEV interface *

Locking features (“spinlock” and “mutex”) *

Managing hardware

• Memory allocation *

• Interrupt handling *

• I/O ports and memory-mapped access *

• Memory mapping (the “mmap” system call) *

• DMA *

Writing a generic PCI driver *

Writing a simple USB driver (HID) *

Using the platform device/driver API for embedded systems

• Introducing the device tree (with the QEMU/ARM platform)

• DT syntax and examples *

• Using “configfs” to load a DT overlay *

A practical work is available for each item with a “star” (*).

The network driver API

Using Linux network

Introducing network drivers

The “net_device” and “net_device_ops” structures

Socket buffer (SKB)

Writing and testing the “faketh” dummy network driver *

The block driver API

• Block driver vs char driver

• The new “blk-mq” framework (Linux kernel 5.x)

• Writing a simple block driver (using ramdisk) *

Interacting with user space

Device node approach limitation (USB but no hotplug !)

Understanding “sysfs”

Using “udev” *

“Netlink” sockets

Writing and testing rules *

modalias (device / driver association) *

Using “udevadm”

Debugging drivers

Using GDB in kernel space (QEMU/ARM)

Debugging static kernel and module (.ko)

Profiling kernel and drivers with Ftrace (debugfs) -> trace-cmd