LFD435 Entwicklung von Gerätetreibern für Embedded Linux-Systeme

Seminarinformationen

Seminar - Ziel

In diesem 4-tägigen Seminar "LFD435 Entwicklung von Gerätetreibern für eingebettete Linux-Systeme" erwerben die Teilnehmer umfassendes Wissen über die Entwicklung von Gerätetreibern für Linux-Systeme sowie ein grundlegendes Verständnis des Linux-Kernels. Der Kurs bietet Einblicke in verschiedene Arten von Gerätetreibern in Linux und stellt geeignete APIs für die Programmierung solcher Treiber vor.

Durch praktische Übungen auf ARM-Hardware, wie Cross-Compiling und die Entwicklung von Treibern für eingebettete Zielplattformen, wird die Vorgehensweise praxisnah vermittelt. Der Kurs konzentriert sich insbesondere auf die detaillierte Betrachtung von Funktionen, die hauptsächlich in Gerätetreibern zum Einsatz kommen, sowie auf die Kernel-Architektur und Algorithmen.

Teilnehmer - Zielgruppe

• Softwareentwickler
• Programmierer

Kurs - Voraussetzungen

Für eine optimale Teilnahme am Kurs empfehlen wir folgende Vorkenntnisse:

Kenntnisse der wesentlichen Kernel-Schnittstellen und -Techniken, wie dem Kompilieren und Schreiben bzw. Laden und Entladen von ModulenAnwendung von SynchronisationsfunktionenGrundlagen der Speicherzuweisung und -verwaltung

Seminardauer

• 4 Tage
• 09:00 Uhr bis 17:00 Uhr

Schulungsunterlagen

• nach Absprache

Seminar-Inhalt / Agenda

Einführung

• Ziele
• Wer Sie sind
• Die Linux Foundation
• Copyright und keine vertraulichen Informationen
• Linux Foundation Training
• Zertifizierungsprogramme und Digital Badging
• Linux-Distributionen
• Ihr System vorbereiten
• Dinge ändern sich in Linux
• Dokumentation und Links

Vorbereitungen

• Abläufe
• Kernel-Versionen
• Kernel-Quellen und Verwendung von git
• Hardware
• Staging Tree
• Labs

Arbeiten in OSS-Projekten

• Überblick über korrektes Contributing
• Code-Herkunft kennen: DCO und CLA
• Nah am Mainline bleiben für Sicherheit und Qualität
• Projekt-DNA studieren und verstehen
• Herausfinden, welches Problem Sie lösen wollen
• Maintainer und deren Workflows und Methoden identifizieren
• Frühzeitig Input einholen und offen arbeiten
• In kleinen Schritten beitragen, nicht große Code-Dumps
• Ego draußen lassen: nicht empfindlich reagieren
• Geduld haben, langfristige Beziehungen aufbauen, hilfreich sein

Cross-Development Toolchain

• Das Compiler Triplet
• Built-in Linux Distribution Cross Compiler
• Linaro
• CodeSourcery
• crosstool-ng
• Buildroot
• OpenEmbedded
• Yocto Project
• Labs

QEMU

• Was ist QEMU?
• Warum QEMU verwenden?
• Emulierte Architekturen
• Image-Formate
• Labs

Booten eines Target-Development-Boards von uSD

• Warum verwenden wir uSD-Karten?
• Software auf eine uSD-Karte bringen
• Booten von Flash
• Warum uSD-Karten keine gute Idee sind
• Labs

Booten eines Target-Development-Boards über Ethernet

• Virtuelle Hardware verwenden
• Eine einfachere Art der Entwicklung
• Boot-Sequenz mit TFTP und NFSroot
• Ziele des Labs
• Labs

Kernel-Konfiguration, Kompilierung, Booten

• Kernel für das Development Board konfigurieren
• Labs

Device Drivers

• Gerätetypen
• Mechanism vs. Policy
• Binary Blobs vermeiden
• Power Management
• Wie Anwendungen Device Drivers verwenden
• System Call Zugriff auf ein Device nachvollziehen
• Error Numbers
• printk()
• devres: Managed Device Resources
• Labs

Modules und Device Drivers

• Die module_driver() Macros
• Modules und Hot Plug
• Labs

Memory Management und Allocation

• Virtueller und physischer Speicher
• Memory Zones
• Page Tables
• kmalloc()
• get_free_pages()
• vmalloc()
• Slabs und Cache Allocations
• Labs

Character Devices

• Device Nodes
• Major- und Minor-Nummern
• Reservieren von Major/Minor Numbers
• Zugriff auf Device Nodes
• Registrierung des Devices
• udev
• dev_printk() und verwandte Funktionen
• file_operations Struktur
• Driver Entry Points
• file- und inode-Strukturen
• Miscellaneous Character Drivers
• Labs

Kernel Features

• Komponenten des Kernels
• User-Space vs. Kernel-Space
• Was sind System Calls?
• Verfügbare System Calls
• Scheduling-Algorithmen und Task Structures
• Process Context
• Labs

Transfer zwischen User- und Kernel-Space

• Transfer zwischen Spaces
• put_user(), get_user() und copy_to_user()/copy_from_user()
• Direkter Transfer: Kernel I/O und Memory Mapping
• Kernel I/O
• Mapping von User Pages
• Memory Mapping
• User-Space Funktionen für mmap()
• Driver Entry Point für mmap()
• Zugriff auf Dateien aus dem Kernel
• Labs

Platform Drivers

• Was sind Platform Drivers?
• Hauptdatenstrukturen
• Registrierung von Platform Devices
• Beispiel
• Hardcoded Platform Data
• Neuer Ansatz: Device Trees
• Labs

Device Trees

• Was sind Device Trees?
• Was Device Trees tun und nicht tun
• Device Tree Syntax
• Device Tree Walkthrough
• Device Tree Bindings
• Device Tree Support in Bootloadern
• Nutzung von Device Tree Daten in Treibern
• Koexistenz und Migration alter Treiber
• Labs

Interrupts und Exceptions

• Was sind Interrupts und Exceptions?
• Exceptions
• Asynchronous Interrupts
• MSI
• Interrupts aktivieren/deaktivieren
• Was man zur Interrupt-Zeit nicht tun darf
• IRQ-Datenstrukturen
• Interrupt Handler installieren
• Labs

Timing Measurements

• Arten von Zeitmessungen
• Jiffies
• Aktuelle Zeit abrufen
• Clock Sources
• Real Time Clock
• Programmable Interval Timer
• Time Stamp Counter
• HPET
• Tickless Systeme

Kernel Timers

• Verzögerungen einfügen
• Was sind Kernel Timers?
• Low Resolution Timer Funktionen
• Low Resolution Timer Implementierung
• High Resolution Timers
• Verwendung von High Resolution Timers
• Labs

IOCTLS

• Was sind ioctls?
• Driver Entry Point für ioctls
• Definieren von ioctls
• Labs

Unified Device Model und sysfs

• Unified Device Model
• Grundlegende Strukturen
• Real Devices
• sysfs
• kset- und kobject-Beispiele
• Labs

Firmware

• Was ist Firmware?
• Firmware laden
• Labs

Sleeping und Wait Queues

• Was sind Wait Queues?
• Schlafen und Aufwachen
• Details zum Sleep
• Exclusive Sleeping
• Details zum Wakeup
• Polling
• Labs

Interrupt Handling: Deferrable Functions und User Drivers

• Top Half und Bottom Half
• Softirqs
• Tasklets
• Work Queues
• Neue Work Queue API
• Kernel Threads erstellen
• Threaded Interrupt Handlers
• Interrupt Handling im User-Space
• Labs

Hardware I/O

• Memory Barriers
• I/O Memory allokieren und mappen
• Zugriff auf I/O Memory

Direct Memory Access (DMA)

• Was ist DMA?
• DMA direkt zu User Space
• DMA und Interrupts
• DMA Memory Constraints
• DMA Masks
• DMA API
• DMA Pools
• Scatter/Gather Mappings
• Labs

Memory Technology Devices (MTD) und Flash Filesystems

• Was sind MTD Devices?
• NAND vs. NOR vs. eMMC
• Driver und User Modules
• Flash Filesystems

USB Drivers

• Was ist USB?
• USB Topologie
• Terminologie
• Endpoints
• Descriptors
• USB Device Classes
• USB Support in Linux
• Registrierung von USB Device Drivers
• Datentransfer
• Beispiel eines USB Drivers
• Labs

Abschluss und Evaluation Survey

• Evaluation Survey

Kernel Architecture I

• UNIX und Linux
• Monolithische und Micro-Kernels
• Object-Oriented Methods
• Hauptkomponenten des Kernels
• User-Space und Kernel-Space

Kernel Programming Preview

• Task Structure
• Memory Allocation
• Datentransfer zwischen User- und Kernel-Space
• Object-Oriented Inheritance – sozusagen
• Linked Lists
• Jiffies
• Labs

Modules

• Was sind Modules?
• Ein triviales Beispiel
• Kompilieren von Modules
• Modules vs. built-in
• Module Utilities
• Automatisches Laden von Modules
• Module Usage Count
• Module Licensing
• Exporting Symbols
• Symbolauflösung
• Labs

Kernel Architecture II

• Prozesse, Threads und Tasks
• Kernel Preemption
• Real-Time Preemption Patch
• Labs

Kernel-Konfiguration und Kompilierung

• Installation und Struktur des Kernel Source
• Kernel Browser
• Kernel-Konfigurationsdateien
• Kernel Build und Makefiles
• initrd und initramfs
• Labs

Kernel Style und allgemeine Überlegungen

• Coding Style
• Nutzung generischer Kernel-Routinen
• Kernel Patch erstellen
• sparse
• likely() und unlikely()
• Portabler Code, CPU, 32/64-bit, Endianness
• SMP-fähiger Code
• High Memory Systeme
• Power Management
• Security im Blick behalten
• Labs

Race Conditions und Synchronisationsmethoden

• Concurrency und Synchronisation
• Atomic Operations
• Bit Operations
• Spinlocks
• Seqlocks
• Preemption deaktivieren
• Mutexes
• Semaphores
• Completion Functions
• Read-Copy-Update (RCU)
• Reference Counts
• Labs

Memory Addressing

• Virtuelles Memory Management
• Systeme mit und ohne MMU und TLB
• Memory Addresses
• High und Low Memory
• Memory Zones
• Special Device Nodes
• NUMA
• Paging
• Page Tables
• Page Structure
• Labs

Memory Allocation

• Anfordern und Freigeben von Pages
• Buddy System
• Slabs und Cache Allocations
• Memory Pools
• kmalloc()
• vmalloc()
• Early Allocations und bootmem()
• Memory Defragmentierung
• Labs

Weitere Schulungen zu Thema Linux Foundation