- 9 (Registered)
This training is targeted primarily at software professionals – tech leads, system programmers / developers, maintainers and testers – who would like to delve much deeper into the internal functioning of the Linux operating system. This may be in order to work on a project involving this directly or indirectly (for example, for those on an application development project on the Linux platform, this training would give them tremendous insight into optimization and code tweaking based on internal factors). Opensource (and closed-source commercial) contributors / developers (or to-be contributors) would find this training very useful as well.
This training is based on the latest 2.6.x / 3.x / 4.x Linux kernel. It starts with a quick and comprehensive look at the overall Linux OS architecture, monolithic kernel approach. It then moves into deep technical discussion of various kernel internal topics: kernel architecture, process descriptor, task list, task creation (with code walkthrough), CPU scheduler design and implementation, virtual memory and memory management.
In-depth coverage continues on: Linux device driver with VFS layer, char device framework in Linux, interface like sysfs, proc, netlink, debugfs , interrupt, I/O, kernel mechanisms, platform device drivers, device tree, DMA, and block device drivers.
Throughout, professional / industry best practices are taught and encouraged.
2 days or 16 hours
It is very important that the prerequisite(s) marked as Mandatory below be met by all participants intending to attend this training, either by having successfully attended a training program (mentioned below), or having the equivalent knowledge / skill sets.
- Good working knowledge of and experience programming using the ‘C’
- Successfully attended the “LINUX for Software Developers” training program -or-have the equivalent knowledge / skill
- Successfully attended the “Advanced LINUX Programming” training program -or-have the equivalent knowledge / skill Implies knowledge / skill sets of: POSIX library and system call API set, process management, IPC mechanisms, etc.
- Participants should have knowledge of Linux systems programming (userspace library and system calls usage), basic Linux kernel internals.
Optional / Advantageous:
- Extensive user-space development experience on a POSIX
- VFS – An Introduction
- Role of the kernel VFS Layer
- The Open Files Table – the files_struct structure
- The File Table – the file structure
- The File Operations pointer – the file_operations structure
- Kernel VFS filesystem I/O call graph.
- Device Drivers – an Introduction
- Block and Character Drivers
- Major, Minor number
- Official Device Registry
- Inode Changes
- User-Space vs Kernel-Space Drivers.
- The Linux Character Device Driver Framework
- Kernel-Space Character Drivers
- The kernel “mem” driver
- The VFS layer and driver registration
- Copying Memory between User and Kernel spaces
- Available kernel APIs.
- Writing a character device driver for Linux – the Framework
- Registering with the kernel
- The major-wide open and fop setup
- Minor-specific open
- Writing our own character driver: the zero and null memory devices
- Device Nodes Management
- Default Behaviour of methods
- Enhanced zero source functionality
- Interfacing with Userspace
- A mention of
- Lab Assigment:
- Accessing IO Memory
- Accessing hardware registers and memory
- ioremap, ioread, iowrite, etc
- From kernel source tree drivers
- Using the “Device IO Memory Read/Write” OSS project (time allowing, can demonstrate the same).
- Linux Character Device Drivers II
- Blocking I/O and Wait Queues
- Kernel implementation of the wait_event_* routines
- Awakening from a wait queue
- Simple blocking I/O implementation: the sleepy driver
- Writing Reentrant-Safe driver code
- Handling Blocking and Non-blocking I/O
- Using mutexes for mutual exclusion control
- Blocking I/O in practice – how to correctly handle read() / write()
- operations in char device drivers.
- Hardware Interrupts and Writing IRQ Handlers for Driver Authors
- Installing an Interrupt Handler
- Interrupt Handler Flags
- (Fairly) Recent Changes in Hardware Interrupt Handling in the Linux Kernel
- Implementing an Interrupt Handler
- Handler Arguments and Return Value
- Threaded Interrupts
- Interrupt Control
- Deferred Functionality Mechanisms in the 2.6 Linux Kernel
- Tasklets and Bottom-Half Processing
- A note on Work Queues
- Which One do I Use – A Quick Comparison.
- Modern Linux Driver Model
- The Sysfs filesystem
- Buses, Devices, Drivers
- The Linux Driver Model
- Driver frameworks
- Bus Drivers
- Device Drivers – Unified Model
- Probing and Removal hooks.
- Platform Drivers and the DT
- Platform Devices and Drivers:
- What is a Platform Device
- Platform devices under sysfs
- Platform Driver
- Device Enumeration
- SMSC911x ethernet
- Nokia 770 keypad.
- Device Tree:
- What is the Device Tree
- Usage on (ARM) Linux, Examples
- Integrating the DT into the kernel.
- Block Device Drivers – Essentials
- Block Devices Handling
- The Generic Block Layer
- I/O Schedulers
- Block Driver Data Structures and Methods
- The Bio Structure
- A Simple Linux block device driver
- Code walk-through and test.
- Real time virtual classess
- Pre course reading material
- Suppliment resources
- Language: English
- Certificate of completion