Introduction To Linux Kernel Development

Demystifying the Linux Kernel: A Developer’s Roadmap to Linux Kernel Internals, Architecture and Development

What you'll learn

Learn how Linux kernel works with a high-level understanding of various kernel subsystems

Setup your own development environment for exploring Linux kernel development on a VirtualBox VM

Learn about important concepts related to modern operating systems

Learn how to custom compile and boot a binary image from official Linux kernel sources

Learn how to create a Linux bootable image with custom built Linux kernel and busybox as userspace

Learn how to create custom initramfs image with busybox as user-land

Learn how to navigate the kernel sources, learn new features and APIs

Learn how to create Linux kernel modules and understand development process of loadable kernel modules

Learn how to interface procfs and debugfs via Loadable Kernel Modules

Learn the tips, techniques and best practices to become a proficient Linux kernel developer

Learn how to create patches that can be submitted to the official Linux kernel community

Requirements

Programming skills using the C programming language

Knowledge on Linux command-line interface - using the bash shell, basic shell scripting and basic linux commands for managing files and processes

Basic understanding of the computer hardware architecture

A laptop / desktop based on x86 architecture (Intel / AMD) with enough memory (atleast 16 GB) and storage (atleast 128 GB) with support for running VirtualBox VMs

A working OS setup - either Windows 10+, MacOS (x86) or any desktop Linux distribution with latest version of VirtualBox installed.

Description

This course provides a comprehensive introduction to Linux kernel design and architecture, aimed at equipping you with both theoretical knowledge and practical skills. I will begin by covering essential operating system concepts and terminologies, ensuring that you have a strong foundation. From there, you'll dive into the intricate workings of the Linux kernel, learning how to build it from source code and create a fully functional, custom bootable Linux system. This includes setting up a BusyBox user-space environment to complete the operating system, giving you a hands-on understanding of the system's internals.In addition to kernel building, this course will teach you how to develop your own Linux kernel modules, with a deep dive into loadable kernel modules (LKMs). You'll explore how to extend the kernel's functionality dynamically, enabling you to create, load, and debug modules efficiently. The course also delves into key features like kthreads, interfacing with the procfs (/proc) filesystem, allowing you to expose any module / kernel related statisitics to user-space, and also interfacing with debugfs (/sys/kernel/debug), allowing you to expose variables from within kernel-space to user-space for diagnostics and debugging.Furthermore, you'll gain experience in contributing to the Linux kernel by learning how to create patches and apply them following the official Linux kernel development workflow. Upon completing this course, you will be proficient in exploring, managing, and modifying the Linux kernel source code, ready to embark on a path toward becoming a skilled Linux kernel developer.

Overview

Section 1: Introduction

Lecture 1 An overview on the Linux ecosystem and OS stack

Lecture 2 Brief History of Linux

Lecture 3 Key Features of the Linux Kernel

Lecture 4 The Linux Kernel Development Process

Section 2: Setting up your Linux Kernel Development Environment

Lecture 5 Setting ArchLinux on VirtualBox VM (Windows / Linux / MacOS x86)

Section 3: A Primer on OS Concepts

Lecture 6 Fundamental concepts related of Operating Systems design and architecture

Lecture 7 High level architecture of an operating system kernel

Lecture 8 IRQ subsystems and other core kernel features

Lecture 9 Monolithic vs Microkernel architecture

Lecture 10 Cooperative vs Preemptive multitasking

Lecture 11 Virtual memory and Demand Paging

Section 4: Building a custom Linux kernel and boot image

Lecture 12 Building a custom kernel image from the sources and booting the new kernel

Lecture 13 Booting custom Linux image with busybox as user-space

Lecture 14 Creating a custom Linux bootable image using initramfs with busybox

Section 5: High level architecture of the Linux kernel

Lecture 15 Understanding "Everything is a File" paradigm on Linux

Lecture 16 Linux Kernel subsystems and core architectural layers

Section 6: Navigating the Linux kernel sources

Lecture 17 Linux kernel source tree layout: a high-level overview

Lecture 18 Navigating the Kernel sources using cscope and LXR

Lecture 19 Linux Kernel Boot Process: High-level code walkthrough of core kernel boot

Lecture 20 Linux Kernel Boot Process: Subsystem initialization to user-space init

Section 7: Loadable Kernel Modules

Lecture 21 An overview on Loadable Kernel Modules

Lecture 22 Writing your first loading kernel module

Lecture 23 Loadable kernel module: features and diagnostics

Lecture 24 An overview on kthreads and module parameters

Lecture 25 Validating module parameters

Lecture 26 Creating Loadable Kernel Modules based on multiple source files

Lecture 27 Passing module parameters and managing modules via module aliases

Lecture 28 Develop a loadable kernel module to add entries into /proc (procfs) filesystem

Lecture 29 Exposing variables as files in debug filesystem (/sys/kernel/debug)

Lecture 30 Creating and submitting patches to the Linux kernel community

Section 8: Conclusion

Lecture 31 Ending notes and future directions

Beginner level Linux enthusiasts interested on exploring into Linux kernel internals and development,Systems Engineers working on other operating systems and interested to explore on Linux kernel features,Linux kernel developers / Device driver developers interested in refreshing their knowledge on fundamental concepts of Linux kernel