The Ultimate Learning Path for System Programming

1. Linux User Space Debugging
– Debugging Linux User Applications (gdb, valgrind, strace, ltrace)

2. Introduction to Linux Kernel Programming
– Understanding Kernel Modules vs. Device Drivers
– Advantages and Disadvantages of Kernel Modules
– Compilation Process for Linux Kernel Modules
– Key Commands for Kernel Modules Management (lsmod, rmmod, insmod, etc.)
– Parameter Passing to Linux Kernel Modules
– Exporting Symbols in the Kernel
– Kernel Panics, Oops, BUGs, and WARNs

3. Process Management in the Kernel
– Creation of Kernel Threads
– Module Metadata and Printk Functionality

4. Character Device Drivers Deep Dive
– Writing Character Device Drivers from Scratch
– Understanding Various File Operations
– Device Number and Device File Concepts
– Allocating Device Numbers (Static vs. Dynamic)
– Creating Device Files (Manual vs. Udev)
– Registering Devices with the Kernel
– Data Transfer Between User Space and Kernel Space
– Handling Error Cases in Ioctl Implementation
– Signalling User Space from Kernel Space
– Access Control Mechanisms in Kernel

5. Memory Management in the Linux Kernel
– Understanding Physical vs. Virtual Address Spaces
– Distinguishing Kernel Space from User Space
– Concepts of Pages, Page Faults, and Address Conversion
– Understanding Low Memory and High Memory
– Memory Allocation Mechanisms in Linux (Buddy Allocator)
– Dynamic Memory Allocation in Linux Kernel
– Kernel Stack Management

6. Synchronization in Linux Kernel Programming
– Understanding Concurrency: Preemption, Context Switch, Race Condition, etc.
– Synchronization Techniques: Per CPU Variables, Atomic Variables, Spinlocks, Semaphores, Mutexes, and more.
– Sequence Locks and Read Copy Update (RCU) Techniques

7. Linux Kernel Development and Compilation
– Linux Kernel Development Landscape
– Developer, Maintainer, and Sub-maintainer Roles
– Tips for Submitting Patches
– Various Linux Kernel Trees (Mainline, Stable, Linux-next)
– The Kernel Release Process and its Types
– Building and Modifying the Linux Kernel
– Configuring, Compiling, and Installing Linux Kernel from Source
– Different Configuration Techniques (Menuconfig, Xconfig, Oldconfig, etc.)
– Cross-Compilation of Linux Kernel
– Building Specific Kernel Components

8. Hardware Communication with Linux Device Drivers
– Basics of IO Communication
– IO Mapped IO vs. Memory Mapped IO
– Accessing IO from User Space
– Understanding PCI and SMBIOS
– Dive into Specific Kernel Modules
– IO Mapped IO Drivers (Speaker, RTC, Keyboard)
– Memory Mapped IO Drivers (Hardware Random Generator, GPIO, UART)

9. Interrupts and Bottom Halves in Linux Kernel
– Interrupts, Exceptions, and Their Types
– Hardware Interrupt Controllers: PIC, IO APIC, Local APIC
– The Process of Interrupt Handling in the Kernel
– Linux Driver Interrupts (Keyboard, Mouse, Ethernet)
– Delving into Keylogger Creation in the Kernel
– Differentiating Between Top and Bottom Halves (Threaded IRQs, Softirqs, Tasklets, Workqueues)

10. Deep Dive into System Calls
– The Nitty-Gritty of Inline Assembly
– Basics and Types of Inline Assembly
– Use Cases in the Linux Kernel (Interrupts, Atomic Operations, I/O Ports, etc.)
– System Calls in Linux
– Introduction and Mechanisms of User-to-Kernel Space Switching
– The Process of Adding a New System Call
– Interacting with Kernel Symbol Tables
– Advanced Kernel Modules: Overwriting Symbol Tables, Sniffing System Call Parameters, etc.

10. Timing Subsystem:
– Programming timing in user space
– Timing Hardware
– Jiffies
– Low resolution & High resolution timers
– POSIX Clocks: CLOCK_BOOTTIME, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_PROCESS_CPUTIME_ID, CLOCK_THREAD_CPUTIME_ID
– Timing System calls: ctime, gettimeofday, clock_gettime, clock_settime, clock_getres, times, getrusage
– Setting time from userspace
– How to measure time for a particular instruction
– Hardware Devices used in timing measurement: RTC, TSC, Programmable Interval Timer, APIC, High Precision Event Timer

11. Embedded Linux using Yocto (Part 1):
– Yocto Project Terminology: poky, bitbake, oe-core, metadata, recipe, classes, configuration, layers, image, and packages
– Setting up a build environment for Yocto development
– Building and running Yocto images on various platforms including QEMU, Raspberry Pi3, and Beagle Bone Black
– Yocto Project Releases: Choosing the right one
– Booting Process in popular boards

12. Embedded Linux using Yocto (Part 2):
– Understanding bitbake operators
– Creating and customizing layers and images
– Introduction to image variables and features
– Basics of Yocto recipes
– Logging functions in Yocto

13. Embedded Linux using Yocto (Part 3):
– Understand FILES and PACKAGES variables
– Creating custom PACKAGES
– Writing recipes for static and dynamic libraries
– Build time vs. Run time dependencies: RDEPENDS vs. DEPENDS
– Recipes for Autotools and CMake
– Devshell
– Customizing the boot splash screen

14. Embedded Linux using Yocto (Part 4):
– Understanding the internals of the shared state cache
– Utilizing commands like bitbake-dumpsig and bitbake-diffsigs
– Incremental vs. clean builds
– Kernel development in Yocto: source, configuration, patches
– Yocto Linux Kernel Recipes and customizations
– Understanding package groups and their recipes
– Writing recipes for out-of-tree modules

15. Linux Kernel Testing:
– Introduction to Linux Kernel testing
– Tools for testing the Linux Kernel: Linux Test Project (LTP) & LTP-DDT

16. Debugging Linux Kernel (Part 1):
– Introduction to debugging techniques
– Learning about ftrace, the official Linux Kernel tracer
– Debugging use cases: Analyzing latencies, tracing context switches, observing kernel flow, etc.

17. Debugging Linux Kernel (Part 2):
– Debugging the Linux Kernel using KGDB
– KGDB setup and use on platforms like Raspberry Pi3
– Remote debugging with KGDB
– Debugging Linux Kernel Modules (In-Tree, out-of-tree)
– Use of GDB Scripts present in the Linux Kernel