Training > Linux Kernel Development > Linux Kernel Internals and Development (LFD420)
Image Image INSTRUCTOR-LED COURSE

Linux Kernel Internals and Development (LFD420)

Dive into Linux kernel development—explore Linux architecture, master essential kernel development methods, and learn to collaborate effectively with the Linux developer community.

Image
Who Is It For

This course is designed to provides experienced programmers with a solid understanding of the Linux kernel. Students should be proficient in the C programming language, basic Linux (UNIX) utilities such as ls, grep and tar, and be comfortable with any of the available text editors (e.g. emacs, vi, etc.).
read less read more
Image
What You’ll Learn

In this course you will learn how Linux is architected, how kernel algorithms work, hardware and memory management, modularization techniques and debugging, how the kernel developer community operates and how to efficiently work with it, and much more.
read less read more
Image
What It Prepares You For

You will come away from this course with a detailed understanding of the theory and philosophy behind the Linux kernel, and the ability to develop and debug Linux kernel code.
read less read more
Course Outline
Expand All
Collapse All
Image Introduction
- Objectives
- Who You Are
- The Linux Foundation{
- Copyright and No Confidential Information
- The Linux Foundation{ Training
- Certification Programs and Digital Badging
- Linux Distributions
- Platforms
- Preparing Your System
- Using and Downloading a Virtual Machine
- Things Change in Linux and Open Source Projects
- Documentation and Links
Image Preliminaries
- Procedures
- Kernel Versions
- Kernel Sources and Use of git
- Labs
Image How to Work in OSS Projects **
- Overview on How to Contribute Properly
- Know Where the Code is Coming From: DCO and CLA
- Stay Close to Mainline for Security and Quality
- Study and Understand the Project DNA
- Figure Out What Itch You Want to Scratch
- Identify Maintainers and Their Work Flows and Methods
- Get Early Input and Work in the Open
- Contribute Incremental Bits, Not Large Code Dumps
- Leave Your Ego at the Door: Don't Be Thin-Skinned
- Be Patient, Develop Long Term Relationships, Be Helpful
Image Kernel Architecture I
- UNIX and Linux **
- Monolithic and Micro Kernels
- Object-Oriented Methods
- Main Kernel Components
- User-Space and Kernel-Space
Image Kernel Programming Preview
- Error Numbers and Getting Kernel Output
- Task Structure
- Memory Allocation
- Transferring Data between User and Kernel Spaces
- Object-Oriented Inheritance - Sort Of
- Linked Lists
- String to Number Conversions
- Jiffies
- Labs
Image Modules
- What are Modules?
- A Trivial Example
- Compiling Modules
- Modules vs Built-in
- Module Utilities
- Automatic Module Loading
- Module Usage Count
- The module struct
- Module Licensing
- Exporting Symbols
- Resolving Symbols **
- Labs
Image Kernel Architecture II
- Processes, Threads, and Tasks
- Process Context
- Kernel Preemption
- Real Time Preemption
- Dynamic Kernel Patching
- Run-time Alternatives **
- Porting to a New Platform **
- Labs
Image Kernel Initialization
- Overview of System Initialization
- System Boot
- Das U-Boot for Embedded Systems**
- Kernel Startup
Image Kernel Configuration and Compilation
- Installation and Layout of the Kernel Source
- Kernel Browsers
- Kernel Configuration Files
- Kernel Building and Makefiles
- initrd and initramfs
- Labs
Image System Calls
- What are System Calls?
- Available System Calls
- How System Calls are Implemented
- Adding a New System Call
- Labs
Image Kernel Style and General Considerations
- Coding Style
- kernel-doc **
- Using Generic Kernel Routines and Methods
- Making a Kernel Patch
- sparse
- Using likely() and unlikely()
- Writing Portable Code, CPU, 32/64-bit, Endianness
- Writing for SMP
- Writing for High Memory Systems
- Power Management
- Keeping Security in Mind
- Mixing User- and Kernel-Space Headers **
- Labs
Image Race Conditions and Synchronization Methods
- Concurrency and Synchronization Methods
- Atomic Operations
- Bit Operations
- Spinlocks
- Seqlocks
- Disabling Preemption
- Mutexes
- Semaphores
- Completion Functions
- Read-Copy-Update (RCU)
- Reference Counts
- Labs
Image SMP and Threads
- SMP Kernels and Modules
- Processor Affinity
- CPUSETS
- SMP Algorithms - Scheduling, Locking, etc.
- Per-CPU Variables **
- Labs
Image Processes
- What are Processes?
- The task_struct
- Creating User Processes and Threads
- Creating Kernel Threads
- Destroying Processes and Threads
- Executing User-Space Processes From Within the Kernel
- Labs
Image Process Limits and Capabilities **
- Process Limits
- Capabilities
- Labs
Image Monitoring and Debugging
- Debuginfo Packages
- Tracing and Profiling
- sysctl
- SysRq Key
- oops Messages
- Kernel Debuggers
- debugfs
- Labs
Image Scheduling
- Main Scheduling Tasks
- SMP
- Scheduling Priorities
- Scheduling System Calls
- The 2.4 schedule() Function **
- O(1) Scheduler **
- Time Slices and Priorities
- Load Balancing
- Priority Inversion and Priority Inheritance **
- The CFS Scheduler
- Calculating Priorities and Fair Times
- Scheduling Classes
- Scheduler Details
- Labs
Image Memory Addressing
- Virtual Memory Management
- Systems With and Without MMU and the TLB
- Memory Addresses
- High and Low Memory
- Memory Zones
- Special Device Nodes
- NUMA
- Paging
- Page Tables
- page structure
- Kernel Samepage Merging (KSM) **
- Labs
Image Huge Pages
- Huge Page Support
- Transparent Huge Pages
- libhugetlbfs
- Labs
Image Memory Allocation
- Requesting and Releasing Pages
- Buddy System
- Slabs and Cache Allocations
- Memory Pools
- kmalloc()
- vmalloc()
- Early Allocations and bootmem()
- Memory Defragmentation
- Labs
Image Process Address Space
- Allocating User Memory and Address Spaces
- Locking Pages
- Memory Descriptors and Regions
- Access Rights
- Allocating and Freeing Memory Regions
- Page Faults
- Labs
Image Disk Caches and Swapping
- Caches
- Page Cache Basics
- What is Swapping?
- Swap Areas
- Swapping Pages In and Out
- Controlling Swappiness
- The Swap Cache
- Reverse Mapping **
- OOM Killer
- Labs
Image Device Drivers**
- Types of Devices
- Device Nodes
- Character Drivers
- An Example
- Labs
Image Signals
- What are Signals?
- Available Signals
- System Calls for Signals
- Sigaction
- Signals and Threads
- How the Kernel Installs Signal Handlers
- How the Kernel Sends Signals
- How the Kernel Invokes Signal Handlers
- Real Time Signals
- Labs
Image Closing and Evaluation Survey
- Evaluation Survey

** These sections may be considered in part or in whole as optional. They contain either background reference material, specialized topics, or advanced subjects. The instructor may choose to cover or not cover them depending on classroom experience and time constraints.
Prerequisites
To make the most of this course, you must:

Be proficient in the C programming language, basic Linux (UNIX) utilities such as ls, grep and tar, and be comfortable with any of the available text editors (e.g. emacs, vi, etc.) Experience with any major Linux distribution is helpful but not strictly required.

Reviews
Feb 2026
The practical aspects of the class, i.e. working on kernel development during the class.
Feb 2026
The training manual is really detailed and informative.
Nov 2025
The training material and labs are pretty good.
Nov 2025
The fact that the lab solutions were given to students up front, so that when working through the labs it was easy to refer to a known-good source if you hit any blockers or problems, or just to verify what you were doing, was on the correct path. This prevented me from 'getting behind' with some of the labs, meaning I could still work through them, but could come back to them later in my own time to finish my own attempt(s).
Nov 2025
Doing hands on kernel module development really helped to make the concepts click, even where the explanations were lacking a bit.
Nov 2025
I feel ready to start working on real tasks in kernel and system programming.
Nov 2025
The course provides a very good overview, and the training material contains a lot of useful details.
Sep 2025
Detailed course notes, good selection of material, and interesting lab exercises.
Sep 2025
The code samples in the book.
Sep 2025
The course and the reading material offered are officially accredited by Linux Foundation, this adds credibility.
Jun 2025
It provided me with a very good update on my outdated knowledge of Linux Kernel internals. I would recommend the course.
Jun 2025
The material was very thorough, very concrete, and great exercises were provided.
Jun 2025
I now have a holistic view of the kernel, and have acquired a methodology to understand how to navigate the kernel code. With the knowledge, I feel equipped to explore the kernel code on my own.
Jun 2025
A really good, high-quality course that I will be recommending to friends.
Mar 2025
Practical labs, as well as the overview of functions or macros associated with a module made it easier for me to understand and execute.
Mar 2025
The amount of content, as well as the expertise and experience of the instructor was well displayed.
Mar 2025
The manual itself is really nice, and I like that I get to keep this as a resource so that I can re-visit the labs etc.
Feb 2025
The instructor's diagrams were very helpful towards understanding the concepts. The time given to labs was good - it did not feel rushed. The course notebook was concise, and will be a good reference going forward.
Feb 2025
Diagrams were helpful for visualizing (easier to understand this, compared to reading blocks of code). The instructor was friendly and knowledgeable. The memory management sections towards the end were particularly interesting for me.
Feb 2025
The book will be my most valuable take away from this course, I can use it as a resource whenever I need to work in Linux kernel.
Feb 2025
Having a prepared lab was very good, given the limited time available.
Feb 2025
The labs were enjoyable, I'll go through the module again to try all the labs, while experimenting with them.
Feb 2025
I am very glad that this training helped me to clear my mind about a lot of things, including learning on my own. Thank you very much to you all. I will consider taking other Linux Foundation training courses when I have a chance.
Dec 2024
I liked the sheer detail and relevant references during the course.
Nov 2024
I have come away with a far greater understanding of Linux kernel internals, as well as an increased confidence in this area.
Nov 2024
I really enjoyed the labs, I felt that they were very well designed.
Nov 2024
I liked how much detail went into the course, it allowed me to learn in even more depth some of the concepts I already knew.
Nov 2024
The exercises working with the kernel were engaging, and learning about the history of Linux's development, as well as its ongoing efforts was interesting.
Oct 2024
I liked the diversity of the topics.
Oct 2024
A lot of information about Linux, and the Linux kernel developer community in general.
Oct 2024
The course was very well structured, and a lot of topics were covered in just 4 days.
Sep 2024
It was surprisingly hands-on, and included a good number of exercises. A very good overview to start deep diving into more topics.
Sep 2024
Well designed, instructed and reinforced.
Aug 2024
The content, and how each topic was approached, along with the labs.
Aug 2024
The coverage of CPU scheduling, process address space, and memory architecture was excellent.
Aug 2024
Great course. Hoping to take more.
Jun 2024
Written materials and lab exercises were of good quality and interesting.
Jun 2024
I liked how the instructor pointed out the underlying fundamental topics for each section, and emphasized that certain topics should already be understood if the student took Comp Sci college courses.
Jun 2024
The instructor had a lot of experience and knowledge about the topic. Many stories he told that were not covered in the text book were really beneficial. He also answered our questions really well.
Jun 2024
Tim is an affable professor, with a great attitude. When labs were more of an "applied learning" rather than following exact directions, the learning was better.
Jun 2024
Very focused on many topics. The chapters were sorted sensibly by the instructor.
Jun 2024
The instructor was often able to answer questions about details / reasons, and showed some extra material on the command line or in code, I enjoyed that.