LFD435 Developing Embedded Linux Device Drivers

Ziele der Schulung

In dieser 4-tägigen Schulung "LFD435 Entwicklung von Gerätetreibern für Embedded Linux-Systeme" entwickeln Sie Gerätetreiber für Embedded-Linux-Systeme und erwerben essenzielles Wissen über den Linux-Kernel durch praxisnahe Labs mit emulierten Entwicklungszielen auf Basis von RISC-V. Dieser Kurs befähigt erfahrene Programmierer dazu, Gerätetreiber zu entwickeln und zu verbessern und dabei praktische, reale Entwicklungserfahrung zu sammeln. Nach erfolgreichem Abschluss dieses Kurses sind Sie mit den verschiedenen Arten von Device Drivers unter Linux vertraut und erhalten eine Einführung in zahlreiche relevante APIs, die beim Schreiben von Gerätetreibern verwendet werden. Die Übungen zur Veranschaulichung dieser Konzepte werden auf ARM-Hardware durchgeführt, um Entwickler mit Cross-Compiling und der Entwicklung für Embedded-Zielsysteme vertraut zu machen.

Dieser Kurs bereitet Sie gezielt auf die Entwicklung von Gerätetreibern für Embedded-Linux-Systeme vor.

Zielgruppe Seminar

• Programmierer
• Entwickler

Voraussetzungen

Kenntnisse grundlegender Kernel-Schnittstellen und -Methoden, insbesondere:

• Schreiben, Kompilieren, Laden und Entladen von Kernel-Modulen
• Verständnis von Synchronisationsmechanismen (Synchronization Primitives)
• Grundkenntnisse der Speicherallokation und Speicherverwaltung im Kernel
• Kenntnisse auf dem Niveau des Kurses LFD420 (Kernel Internals and Development)
• Vor Kursbeginn werden Ihnen vorbereitende Materialien zur Verfügung gestellt

Seminarinhalt

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

Hinweise

Prüfung und Zertifizierung

Diese Schulung beinhaltet keine Prüfung.

Open Badge für dieses Seminar - Ihr digitaler Kompetenznachweis

Durch die erfolgreiche Teilnahme an einem Kurs bei IT-Schulungen.com erhalten Sie zusätzlich zu Ihrem Teilnehmerzertifikat ein digitales Open Badge (Zertifikat) – Ihren modernen Nachweis für erworbene Kompetenzen.

Ihr Open Badge ist jederzeit in Ihrem persönlichen und kostenfreien Mein IT-Schulungen.com-Konto verfügbar. Mit wenigen Klicks können Sie diesen digitalen Nachweis in sozialen Netzwerken teilen, um Ihre Expertise sichtbar zu machen und Ihr berufliches Profil gezielt zu stärken.

Übersicht: Linux Foundation Schulungen Portfolio

Mehr zu den Vorteilen von Badges

Kundenbewertungen

Seminare kurz vor der Durchführung