LINUX Kernel Internals and device drivers

Course Prerequisites: Participants should have: Mandatory: A firm understanding of user- level UNIX or LINUX and some experience using the OS (includes vi editor and various user- level tools such as find, du, cut, redirection, awk, grep, etc.) Strong 'C' programming skills Application development exposure on UNIX/Linux platform using 'C' Preferable, not mandatory: In- depth application development experience and usage of system calls on any UNIX or LINUX platform using 'C' Duration : 6 days Format: Morning Session: Theory Afternoon/Evening Session: Laboratory hands- on (participants will design & implement programs and/or case studies covered in the Theory session) Requirements: LCD display projector (daily) White board Marker pens and white- board eraser For lab: Suggested man:machine ratio: 1:1 is optimal, 2:1 is viable. System H/W Requirements: Intel- based PCs (Pentium4, 256MB RAM or more preferable) running LINUX as the O.S. System S/W Requirements: LINUX O.S. - preferably RedHat Linux 7.3 with kernel version 2.4.18 The Linux O.S. should be installed as a "Development System" - must include -the 'C' development system (C complier & linker with std C library) -vi / other editors -kernel sources (the kernel source RPM should be installed subsequently) -kernel source for 2.4.20 vanilla kernel Preferable: X Window System installed (for ease of use) Debugger (gdb) Important: Every participant (or at max 2 participants) should have a separate independent LINUX desktop system to use for this course. This is as a particular participant's system can crash; having them completely stand- alone prevents this from affecting others (if a single LINUX server system is shared via network access, one participant crashing the kernel will force all others to lose data and stop work). The systems to be used for lab sessions should be "test" systems - this is as during kernellevel development they could crash and even suffer data loss. DAY-WISE COVERAGE Day 1 Module 1 : A Brief History Introduction to Linux Linux Variants The Birth of Linux: Linus Torvalds' historic post OSDLs Linux Timeline The GNU project GNU [L]GPL Module 2: LINUX System Programming Fundamentals A brief mention on Process Privileges- Process Credentials SUID, SGID executables Process execution executing a process the exec family of system calls Process creation with the fork system call Waiting for a Child Process Orphans and Zombies Signals and signalling with POSIX sigaction Signals in Linux POSIX: The sigaction() system call Signal Flags for special behaviour Executing critical code: Blocking signal(s) from delivery to a process when required Lab Session: Implement the: The assignments provided by the instructor The remaining programs reviewed during the session. Day 2 Module 2: LINUX System Programming Fundamentals (contd.) Real- time signal handling support Using the SA_NODEFER flag Sending signals to other processes Piping: Using the pipe, fork, dup and exec API in one stroke Tracing a process with strace A Conceptual Introduction to POSIX Threading on Linux The multithreading concept Pthreads on Linux Module 3 : Kernel Architecture and the Process Descriptor Layout of the kernel source tree Architecture Process descriptor- the task_struct structure Module 4 : Process Creation and the Scheduler Process Creation The INIT_TASK macro Process Creation the __clone() function and flags fork() kernel implementation The Linux kernel scheduler Internal working of the kernel scheduler Brief Note on the 2.5/2.6 kernel scheduler Module 5 : Open File kernel data structures The Open Files Table - the files_struct structure The File Table - the file structure The File Operations pointer - the file_operations structure Lab Session: Implement the: The assignments provided by the instructor The remaining programs (if any) reviewed during the session. Day 3 Module 6 : Linux Memory Management Hardware Segmentation Paging Paging on the x86 Process Page Tables Linux Memory Zones Zone allocator Buddy System Memory Map - page structure Swapping and the Page Cache VM LRU Page Lists Page Reclamation Page Life Cycle Process VM Mapping Kernel Threads Memory Regions - VMAs VM Management Policy Kernel data structures- overall relationships Module 7 : Building a fresh LINUX Kernel Overview of the process Download and extraction Configuration Compile and build Boot option setting Case Study: Building a kernel with the Magic SysRq key enabled and other specific features Lab Session: Kernel build Day 4 Module 8 : System Call Implementation and LKMs System Calls LINUX x86 System Call Implementation The syscall[n] macros The sys_call_table Loadable Kernel Modules (LKMs) Intercepting a system call using LKMs Additional Notes Compiling Modules Loading and Unloading Symbol exporting The nm utility Memory allocation API in the kernel Case Study on LKMs Module 9 : The /proc filesystem What is the /proc filesystem Exploring the /proc filesystem A first quick session on /proc Kernel data in /proc Session 2 on /proc : kernel data Using the sysctl facility Sysctl - the kernel branch Sysctl - the fs branch Sysctl - the vm branch Real-world case- study of user- level procfs usage Lab Session: Implement the exit() trapping module Case study/Project I: the exec module (details will be provided). Day 5 Module 10: LINUX Device Drivers What is a device driver User- space and kernel- space Writing a device driver - the basics Block and character device files The VFS layer and driver registration Writing a character device driver for Linux - the framework registering with the kernel the major-wide open and fop setup minor- specific open Default processing on null fop entries Writing our own character driver: the cz and cnul memory devices Using the proc filesystem within a kernel module/driver for reading for writing Case Studies Case # 1: the cz driver Lab Session: Implement the cz and cnul device driver Implement the above using the procfs interfaces as well Module 11: I/O Port Drivers Linux Hardware I/O Management Memory Barriers Port I/O operations Portability issues The x86 parallel port specification Case Study #3: Build a Linux device driver to drive an actual parallel port hardware device (device will be provided by the instructor during the session for testing the driver) Day 6 Module 12 : LINUX Device Drivers - Advanced Aspects Blocking I/O and Wait Queues Kernel implementation of sleep_on_* and wait_event_* routines Simple blocking I/O implementation: the sleepy driver Additional tests (slpy2) Handling Blocking and Non- blocking I/O Using semaphores for mutual exclusion control Blocking I/O - for read()/write() operations in device drivers Module 13 : LINUX Device Drivers - Interrupt Handling Control of Interrupts Interrupt Handlers Installing an Interrupt Handler Tasklets and Bottom Halves The ppd driver features tour- Module parameter passing IRQ request Procfs entries Blocking I/O mode Interrupt handling with tasklet Task Queues Module 14 : Kernel Synchronization The need for synchronization in the kernel Linux's synchronization techniques Using spinlocks Module 15 : Linux kernel debugging with kgdb Using the kernel debugger kgdb Hardware and Software requirements Hardware and Software setup Initiating a debugging session on the target system Lab Session: Implement the cz and cnul device driver Case study/Project II: the vcp module (details will be provided by the instructor) Implement Case study/project III Case 4: Enhance Case 3 project, by adding on an interrupt handler. Have a tasklet service it. Appendices Appendix A : LINUX Resources Appendix B : Bibliography Appendix C : Misc. Useful Topics Kernel Initialization Dynamic Kernel Timers Using the GNU debugger gdb Tracing processes with strace