├── .gitignore ├── Lessons ├── Module1 │ ├── L1.1.md │ ├── L1.2.md │ ├── L1.3.md │ ├── L1.4.md │ └── L1.5.md ├── Module10 │ ├── L10.1.md │ ├── L10.2.md │ ├── L10.3.md │ └── L10.4.md ├── Module11 │ ├── L11.1.md │ ├── L11.2.md │ └── L11.3.md ├── Module12 │ ├── L12.1.md │ ├── L12.2.md │ └── L12.3.md ├── Module2 │ ├── L2.1.md │ ├── L2.2.md │ ├── L2.3.md │ ├── L2.4.md │ ├── L2.5.md │ └── L2.6.md ├── Module3 │ ├── L3.1.md │ ├── L3.2.md │ ├── L3.3.md │ ├── L3.4.md │ └── L3.5.md ├── Module4 │ ├── L4.1.md │ ├── L4.2.md │ ├── L4.3.md │ ├── L4.4.md │ └── L4.5.md ├── Module5 │ ├── L5.1.md │ ├── L5.2.md │ ├── L5.3.md │ └── L5.4.md ├── Module7 │ ├── L7.1.md │ ├── L7.2.md │ └── L7.3.md ├── Module8 │ ├── L8.1.md │ ├── L8.2.md │ ├── L8.3.md │ └── L8.4.md └── Module9 │ ├── L9.1.md │ ├── L9.2.md │ ├── L9.3.md │ ├── L9.4.md │ └── L9.5.md └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | .idx -------------------------------------------------------------------------------- /Lessons/Module1/L1.1.md: -------------------------------------------------------------------------------- 1 | ## Lesson 1.1: What is **Linux Operating System** 2 | [![yt-video](https://i.ytimg.com/vi/sWbUDq4S6Y8/hq720.jpg)](https://www.youtube.com/watch?v=sWbUDq4S6Y8) 3 | --- 4 | 5 | The **Linux Operating System**, often compared to **Unix**, is based on the **Linux Kernel**, which acts as the core of the system. The **Kernel** functions like the control center, handling the communication between the computer’s hardware and its resources to ensure smooth and efficient operations. 6 | 7 | However, the **Linux Kernel** on its own does not form a complete operating system. To create a fully functional environment, it is combined with various software packages and tools, forming what is known as **Linux distributions**. These distributions equip users to run applications and perform tasks securely and efficiently, with various versions available to cater to specific user needs and preferences. 8 | 9 | Linux distributions come in different _flavors_, each tailored to suit particular use cases, offering a versatile platform for users. 10 | -------------------------------------------------------------------------------- /Lessons/Module1/L1.2.md: -------------------------------------------------------------------------------- 1 | ## Lesson 1.2: What is **Linux Kernel?** 2 | [![yt-video](https://i.ytimg.com/vi/sHWEYeaBpew/hq720.jpg)](https://www.youtube.com/watch?v=sHWEYeaBpew) 3 | 4 | The **Linux® kernel** is the central component of a **Linux Operating System (OS)** and serves as the core interface between a computer’s **hardware** and its **processes**. It manages communication between the two, ensuring that system resources are utilized as efficiently as possible. 5 | 6 | The kernel gets its name from its role—like a _seed inside a hard shell_—because it resides at the core of the operating system and controls the primary functions of the hardware, whether that hardware is a **phone**, **laptop**, **server**, or any other type of computer. 7 | -------------------------------------------------------------------------------- /Lessons/Module1/L1.3.md: -------------------------------------------------------------------------------- 1 | ## Lesson 1.3: **Roles and Responsibilities of the Linux Kernel** 2 | [![yt-video](https://i.ytimg.com/vi/IvGdY6luTtU/hq720.jpg)](https://www.youtube.com/watch?v=IvGdY6luTtU) 3 | 4 | The **Linux Kernel** has four primary roles: 5 | 6 | 1. **Memory Management**: Keeps track of how much memory is used, what it’s used for, and where it’s stored. 7 | 2. **Process Management**: Determines which processes can utilize the **central processing unit (CPU)**, when they can do so, and for how long. 8 | 3. **Device Drivers**: Serves as a mediator and interpreter between the hardware and processes. 9 | 4. **System Calls and Security**: Manages requests for services from processes while ensuring system security. 10 | 11 | When implemented properly, the kernel operates invisibly to the user within its designated area known as **kernel space**, where it allocates memory and monitors data storage. In contrast, the user interacts with applications, such as **web browsers** and **files**, which exist in **user space**. These applications communicate with the kernel via a **system call interface (SCI)**. 12 | 13 | To illustrate, think of the kernel as a diligent **personal assistant** to a powerful executive (the hardware). Its responsibilities include relaying messages and requests (processes) from employees and the public (users) to the executive, remembering what is stored where (memory), and determining who has access to the executive at any given time and for how long. 14 | -------------------------------------------------------------------------------- /Lessons/Module1/L1.4.md: -------------------------------------------------------------------------------- 1 | ## Lesson 1.4: **Overview of Linux Distributions** 2 | [![yt-video](https://i.ytimg.com/vi/gJE0ukV5gFY/hq720.jpg)](https://www.youtube.com/watch?v=gJE0ukV5gFY) 3 | 4 | Unlike other operating systems, such as **Microsoft**, which combine all components internally and release them as a single package, **Linux** takes a different approach. Various parts of Linux are developed by different organizations. 5 | 6 | These components include the **kernel**, **shell utilities**, **X server**, **system environment**, **graphical programs**, and more. If you wish, you can access the code for each of these components and assemble them yourself. However, this process is not straightforward; it requires a significant amount of time and expertise, as all parts must be assembled correctly to function properly. 7 | 8 | This flexibility allows users to create custom distributions tailored to their specific needs, showcasing the versatility and collaborative nature of the Linux ecosystem. 9 | -------------------------------------------------------------------------------- /Lessons/Module1/L1.5.md: -------------------------------------------------------------------------------- 1 | ## Lesson 1.5: **Understanding Operating Systems** 2 | 3 | [![yt-video](https://i.ytimg.com/vi/mXw9ruZaxzQ/hq720.jpg)](https://www.youtube.com/watch?v=mXw9ruZaxzQ) 4 | 5 | An **Operating System (OS)** serves as an interface between the **computer user** and the **computer hardware**. It is a software that performs essential tasks such as **file management**, **memory management**, **process management**, handling **input and output**, and controlling peripheral devices like **disk drives** and **printers**. 6 | 7 | The OS enables applications to interact with a computer's hardware, and the core components of the operating system are encapsulated in a component known as the **kernel**. 8 | 9 | The primary purposes of an Operating System are to facilitate communication between applications (software) and the computer's hardware and to manage the system's hardware and software resources effectively. 10 | 11 | Some popular operating systems include: 12 | 13 | - **Linux Operating System** 14 | - **Windows Operating System** 15 | - **VMS** 16 | - **OS/400** 17 | - **AIX** 18 | - **z/OS** 19 | 20 | Today, operating systems are found in nearly every device, including **mobile phones**, **personal computers**, **mainframe computers**, **automobiles**, **TVs**, and even **toys**. 21 | -------------------------------------------------------------------------------- /Lessons/Module10/L10.1.md: -------------------------------------------------------------------------------- 1 | ### Lesson 10.1: Rust in the Linux Project Overview 2 | Learn about Rust’s role in the Linux kernel and why it’s being introduced: 3 | - **Rust’s Advantages:** Memory safety, concurrency, and other benefits Rust brings to kernel development. 4 | - **Linux Project Goals:** How Rust integrates with C and the Linux kernel’s goals for Rust support. 5 | 6 | This lesson sets the stage for Rust-based kernel development. 7 | -------------------------------------------------------------------------------- /Lessons/Module10/L10.2.md: -------------------------------------------------------------------------------- 1 | ### Lesson 10.2: Writing Kernel Modules in Rust 2 | Explore creating kernel modules in Rust and understand how it differs from C: 3 | - **Rust Kernel Module Structure:** Basics of module structure, setup, and teardown functions in Rust. 4 | - **Interop with C:** How Rust interacts with C components in the kernel. 5 | - **Module Compilation and Testing:** Building and testing Rust kernel modules. 6 | 7 | You’ll complete this lesson with an understanding of writing Rust modules for the kernel. 8 | -------------------------------------------------------------------------------- /Lessons/Module10/L10.3.md: -------------------------------------------------------------------------------- 1 | ### Lesson 10.3: Developing Device Drivers in Rust 2 | An overview of using Rust to write device drivers for secure, efficient code: 3 | - **Driver Structure in Rust:** Key components and differences from C drivers. 4 | - **Hardware Access and Memory Safety:** Leveraging Rust’s safety features in device drivers. 5 | - **Testing Rust Drivers:** Techniques for testing and debugging Rust-based drivers. 6 | 7 | This lesson enables you to develop safe, reliable device drivers in Rust. -------------------------------------------------------------------------------- /Lessons/Module10/L10.4.md: -------------------------------------------------------------------------------- 1 | ### Lesson 10.4: Submitting Rust-Based Patches 2 | Learn how to prepare and submit Rust code patches to the kernel: 3 | - **Patch Requirements:** Following Rust and kernel standards for Rust submissions. 4 | - **Submitting Patches:** Using Git to format, sign, and submit patches for review. 5 | - **Community Involvement:** Engaging with the Linux and Rust communities for feedback. 6 | 7 | By the end, you’ll know how to contribute Rust-based code to the Linux kernel. 8 | -------------------------------------------------------------------------------- /Lessons/Module11/L11.1.md: -------------------------------------------------------------------------------- 1 | ### Lesson 11.1: Networking in the Linux Community 2 | Understand how to participate effectively in the Linux kernel community: 3 | - **Mailing Lists and Forums:** Using mailing lists and forums to stay updated and communicate. 4 | - **Community Guidelines:** Following etiquette and maintaining professional collaboration. 5 | - **Mentorship Programs:** Opportunities to receive mentorship within the Linux community. 6 | 7 | This lesson prepares you for active, positive community involvement. -------------------------------------------------------------------------------- /Lessons/Module11/L11.2.md: -------------------------------------------------------------------------------- 1 | ### Lesson 11.2: Reviewing and Testing Patches 2 | Learn how to review patches from other contributors and provide helpful feedback: 3 | - **Patch Review Guidelines:** Best practices for reviewing and suggesting improvements. 4 | - **Testing Process:** Techniques for testing patches and validating their functionality. 5 | - **Quality Assurance:** Ensuring patches meet project standards and do not introduce regressions. 6 | 7 | By the end, you’ll know how to contribute by reviewing and testing community patches. 8 | -------------------------------------------------------------------------------- /Lessons/Module11/L11.3.md: -------------------------------------------------------------------------------- 1 | ### Lesson 11.3: Becoming a Linux Maintainer 2 | Explore the responsibilities and expectations of becoming a maintainer: 3 | - **Role of a Maintainer:** Key responsibilities, such as reviewing patches and managing contributions. 4 | - **Maintainer Workflows:** Tools and practices for efficient management. 5 | - **Documentation and Communication:** Effective documentation and transparency for collaborators. 6 | 7 | This lesson prepares you for advanced contributions and potential leadership in the Linux community. 8 | -------------------------------------------------------------------------------- /Lessons/Module12/L12.1.md: -------------------------------------------------------------------------------- 1 | ### Lesson 12.1: Understanding Kernel Security Vulnerabilities 2 | Explore common security vulnerabilities that affect the Linux kernel: 3 | - **Types of Vulnerabilities:** Buffer overflows, race conditions, privilege escalation, and others. 4 | - **Security Impact:** Real-world consequences of kernel vulnerabilities and security breaches. 5 | 6 | You’ll gain a deeper understanding of kernel security concerns and common exploit methods. 7 | -------------------------------------------------------------------------------- /Lessons/Module12/L12.2.md: -------------------------------------------------------------------------------- 1 | ### Lesson 12.2: Implementing Kernel Security Features 2 | This lesson focuses on security features that help protect the kernel: 3 | - **Access Control Mechanisms:** Techniques like SELinux and AppArmor for controlled access. 4 | - **Security Modules:** Using the Linux Security Module (LSM) framework for custom security policies. 5 | - **Hardening the Kernel:** Configuration options to reduce the attack surface and enhance security. 6 | 7 | By the end, you’ll be equipped to implement and configure key kernel security features. 8 | -------------------------------------------------------------------------------- /Lessons/Module12/L12.3.md: -------------------------------------------------------------------------------- 1 | # Lesson 12.3: Kernel Hardening Techniques 2 | 3 | ## Overview 4 | Kernel hardening is a critical component of system security. In this lesson, we explore techniques to protect the kernel from vulnerabilities and potential exploits, enhancing the overall security of the operating system. 5 | 6 | ## Learning Objectives 7 | By the end of this lesson, you will be able to: 8 | - Understand the importance of kernel hardening in system security. 9 | - Identify common kernel hardening techniques. 10 | - Implement basic security practices to protect the kernel from attacks. 11 | 12 | ## Key Topics 13 | 14 | ### 1. Introduction to Kernel Hardening 15 | - **What is Kernel Hardening?** 16 | - Importance of kernel as the core component of the operating system. 17 | - Overview of why kernel hardening is essential for security. 18 | 19 | - **Threats to the Kernel** 20 | - Common threats: buffer overflows, privilege escalation, and code execution attacks. 21 | 22 | ### 2. Kernel Hardening Techniques 23 | - **Address Space Layout Randomization (ASLR)** 24 | - Randomizing memory address spaces to prevent predictable attacks. 25 | - How ASLR complicates buffer overflow exploits. 26 | 27 | - **Control Flow Integrity (CFI)** 28 | - Ensuring that code execution follows legitimate paths. 29 | - Techniques to prevent arbitrary code execution. 30 | 31 | - **Mandatory Access Control (MAC)** 32 | - Enhancing security with SELinux and AppArmor. 33 | - Role-based access control and limiting access to kernel resources. 34 | 35 | - **Kernel Module Signing** 36 | - Verifying the integrity and authenticity of kernel modules before loading. 37 | - Preventing unauthorized modules from tampering with the kernel. 38 | 39 | - **Seccomp (Secure Computing Mode)** 40 | - Restricting the system calls a process can make. 41 | - Implementing syscall filters to reduce attack surface. 42 | 43 | - **Stack Canaries** 44 | - Inserting guard values to detect stack buffer overflow attacks. 45 | - How stack canaries detect and prevent stack-based exploits. 46 | 47 | ### 3. Practical Hardening Measures 48 | - **Configuring Kernel Security Parameters** 49 | - Adjusting kernel parameters using `sysctl` for better security. 50 | - Examples: limiting core dumps, disabling unused features. 51 | 52 | - **Patch Management and Kernel Updates** 53 | - Importance of keeping the kernel up-to-date with security patches. 54 | - Tools and practices for managing kernel patches. 55 | 56 | - **Minimal Kernel Build** 57 | - Customizing the kernel to only include essential components. 58 | - Reducing the attack surface by minimizing kernel modules. 59 | 60 | ## Summary 61 | In this lesson, we covered various kernel hardening techniques that play a vital role in system security. By implementing these techniques, administrators can significantly reduce the risk of kernel-level exploits and improve overall system resilience. 62 | 63 | ## Further Reading and Resources 64 | - [Linux Kernel Documentation](https://www.kernel.org/doc/) 65 | - [Seccomp Documentation](https://man7.org/linux/man-pages/man2/seccomp.2.html) 66 | - SELinux [Beginner’s Guide](https://wiki.centos.org/HowTos/SELinux) 67 | 68 | ## Assessment 69 | - **Quiz:** Multiple-choice questions on kernel hardening concepts. 70 | - **Exercise:** Configure basic kernel hardening settings on a test system. 71 | 72 | ## Next Lesson 73 | **Lesson 12.4: System Auditing and Monitoring Tools** 74 | -------------------------------------------------------------------------------- /Lessons/Module2/L2.1.md: -------------------------------------------------------------------------------- 1 | ## Lesson 2.1: **Basic Components of an Operating System** 2 | [![yt-video](https://i.ytimg.com/vi/XXPBl20J22w/hq720.jpg)](https://www.youtube.com/watch?v=XXPBl20J22w) 3 | 4 | The **basic components** of an **Operating System (OS)** work together to manage the computer’s resources and provide a user interface. These components include: 5 | 6 | - **Kernel**: The core of the OS that manages hardware resources like CPU, memory, and I/O devices. 7 | - **File System**: Manages data storage, retrieval, and organization of files. 8 | - **User Interface (UI)**: Provides a way for users to interact with the computer, either through a **Graphical User Interface (GUI)** or **Command-Line Interface (CLI)**. 9 | - **Process Management**: Controls the execution of processes, ensuring proper resource allocation and scheduling. 10 | - **Memory Management**: Keeps track of memory usage and optimizes the allocation of RAM to various processes. 11 | - **Device Drivers**: Interface between hardware devices and the OS, allowing communication with peripherals like printers, keyboards, and disk drives. 12 | 13 | These components work together to ensure that the OS functions efficiently and can meet the needs of users and applications. 14 | -------------------------------------------------------------------------------- /Lessons/Module2/L2.2.md: -------------------------------------------------------------------------------- 1 | ## Lesson 2.1: **Processes, Threads, and Scheduling** 2 | [![Process States](https://upload.wikimedia.org/wikipedia/commons/thumb/8/83/Process_states.svg/400px-Process_states.svg.png)](https://en.wikipedia.org/wiki/Process_state) 3 | 4 | Processes and threads are key components of modern operating systems. They enable multitasking and efficient CPU usage: 5 | 6 | - **Processes**: A process is a program in execution, which includes the program code and its current activity. Each process operates in its own memory space and is managed by the operating system. 7 | - **Threads**: Threads are the smallest units of processing that can be scheduled by the operating system. A single process can have multiple threads that share the same memory space, allowing for more efficient execution. 8 | - **Scheduling**: The operating system's scheduler manages the execution of processes and threads, allocating CPU time and optimizing performance. Scheduling algorithms determine the order in which processes are executed, impacting overall system responsiveness and efficiency. 9 | 10 | Understanding these concepts is essential for grasping how modern operating systems function and manage resources effectively. 11 | -------------------------------------------------------------------------------- /Lessons/Module2/L2.3.md: -------------------------------------------------------------------------------- 1 | ## Lesson 2.3: **Introduction to Memory Management** 2 | [![Memory Management](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e1/Operating_system_placement.svg/165px-Operating_system_placement.svg.png)](https://en.wikipedia.org/wiki/Memory_management) 3 | 4 | Memory management is a crucial function of an operating system that handles the allocation, tracking, and management of a computer's memory resources. It ensures that applications have sufficient memory to execute while maintaining system stability and efficiency. 5 | 6 | Key aspects of memory management include: 7 | 8 | - **Memory Allocation**: The process of assigning memory to various applications and services based on their requirements. 9 | - **Paging and Segmentation**: Techniques that divide memory into manageable sections, allowing for efficient use and reducing fragmentation. 10 | - **Virtual Memory**: A method that uses disk space to extend the apparent amount of memory available, enabling larger applications to run on systems with limited physical memory. 11 | - **Garbage Collection**: The automatic reclamation of memory that is no longer in use, helping to prevent memory leaks and optimize performance. 12 | 13 | Effective memory management helps in optimizing system performance, enhancing the user experience, and ensuring that applications run smoothly. 14 | 15 | For more detailed information, visit the [Memory Management page on Wikipedia](https://en.wikipedia.org/wiki/Memory_management). 16 | -------------------------------------------------------------------------------- /Lessons/Module2/L2.4.md: -------------------------------------------------------------------------------- 1 | ## Lesson 2.4: **File Systems Overview** 2 | [![File System](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e1/Operating_system_placement.svg/165px-Operating_system_placement.svg.png)](https://en.wikipedia.org/wiki/File_system) 3 | 4 | A **file system** is a crucial component of an operating system that manages how data is stored, organized, and retrieved on storage devices. It provides a systematic way to store files, ensuring that they can be easily accessed and managed. 5 | 6 | ### Key Functions of a File System: 7 | - **Data Organization**: File systems organize data into files and directories, making it easier for users and applications to locate and manage information. 8 | - **File Naming**: They define conventions for naming files and directories, which helps in avoiding conflicts and maintaining clarity. 9 | - **Access Control**: File systems implement permissions and access control mechanisms to protect files from unauthorized access or modification. 10 | - **Data Integrity**: They ensure data integrity through techniques such as journaling, which keeps track of changes to prevent data loss in case of system failures. 11 | 12 | ### Common Types of File Systems: 13 | - **FAT32**: A simple file system used widely in portable storage devices. 14 | - **NTFS**: A robust file system used by Windows that supports large files and advanced features. 15 | - **ext4**: A popular file system for Linux, known for its reliability and performance. 16 | 17 | Understanding file systems is essential for efficient data management and effective use of storage resources. For more detailed information, check out the [File System page on Wikipedia](https://en.wikipedia.org/wiki/File_system). 18 | -------------------------------------------------------------------------------- /Lessons/Module2/L2.5.md: -------------------------------------------------------------------------------- 1 | ## Lesson 2.5: **Interprocess Communication Basics** 2 | [![Interprocess Communication](https://upload.wikimedia.org/wikipedia/commons/thumb/e/ef/ArchitectureCloudLinksSameSite.png/260px-ArchitectureCloudLinksSameSite.png)](https://en.wikipedia.org/wiki/Inter-process_communication) 3 | 4 | **Interprocess Communication (IPC)** refers to the mechanisms provided by the operating system that enable processes to communicate with each other and synchronize their actions. IPC is essential for creating applications that require cooperation among multiple processes. 5 | 6 | ### Key IPC Mechanisms: 7 | - **Pipes**: A unidirectional communication channel that allows one process to send data to another. 8 | - **Message Queues**: Allow processes to send and receive messages in a queued manner, ensuring that messages are stored until they can be processed. 9 | - **Shared Memory**: Enables multiple processes to access a common memory space, allowing for fast data exchange. 10 | - **Sockets**: Facilitate communication between processes over a network, enabling data exchange between applications running on different machines. 11 | 12 | ### Importance of IPC: 13 | - **Resource Sharing**: IPC allows processes to share resources efficiently, enhancing system performance. 14 | - **Synchronization**: Helps synchronize actions among processes, preventing race conditions and ensuring data consistency. 15 | - **Modularity**: Encourages the development of modular applications, where different processes can perform distinct functions and communicate seamlessly. 16 | 17 | Understanding IPC is crucial for developing efficient and effective multi-process applications. For more detailed information, visit the [Interprocess Communication page on Wikipedia](https://en.wikipedia.org/wiki/Inter-process_communication). 18 | -------------------------------------------------------------------------------- /Lessons/Module2/L2.6.md: -------------------------------------------------------------------------------- 1 | ## Lesson 2.6: **Introduction to Device Drivers** 2 | [![Device Drivers](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e1/Operating_system_placement.svg/165px-Operating_system_placement.svg.png)](https://en.wikipedia.org/wiki/Device_driver) 3 | 4 | **Device drivers** are specialized software components that allow the operating system and applications to communicate with hardware devices. They serve as intermediaries, translating the operating system's instructions into device-specific commands and vice versa. 5 | 6 | ### Key Functions of Device Drivers: 7 | - **Hardware Abstraction**: Device drivers abstract the complexity of hardware interactions, enabling applications to use devices without needing to understand their underlying details. 8 | - **Resource Management**: They manage device resources, ensuring that multiple applications can access hardware without conflicts. 9 | - **Error Handling**: Device drivers monitor hardware status and report errors back to the operating system, facilitating troubleshooting and recovery. 10 | 11 | ### Types of Device Drivers: 12 | - **Kernel-mode Drivers**: Run in the kernel space with high privileges, allowing direct access to hardware. 13 | - **User-mode Drivers**: Operate in user space, providing an additional layer of security and stability. 14 | 15 | Understanding device drivers is essential for developing hardware-dependent applications and ensuring that hardware devices function correctly within the operating system. For more detailed information, check out the [Device Driver page on Wikipedia](https://en.wikipedia.org/wiki/Device_driver). 16 | -------------------------------------------------------------------------------- /Lessons/Module3/L3.1.md: -------------------------------------------------------------------------------- 1 | ## Lesson 3.1: **Fundamentals of Rust** 2 | [![Rust Programming](https://img.youtube.com/vi/5C_HPTJg5ek/hqdefault.jpg)](https://www.youtube.com/watch?v=5C_HPTJg5ek) 3 | 4 | **Rust** is a systems programming language focused on safety, speed, and concurrency. It is designed to prevent common programming errors such as null pointer dereferencing and buffer overflows, making it a popular choice for developing secure and efficient applications. 5 | 6 | ### Key Features of Rust: 7 | - **Memory Safety**: Rust’s ownership model ensures memory safety without needing a garbage collector. This model prevents data races and ensures that references are always valid. 8 | - **Concurrency**: Rust provides powerful concurrency primitives, allowing developers to write multi-threaded programs safely and efficiently. 9 | - **Performance**: Rust is compiled to machine code, offering performance comparable to C and C++ while maintaining safety guarantees. 10 | - **Rich Type System**: Rust’s type system includes features like algebraic data types and pattern matching, enhancing expressiveness and robustness. 11 | 12 | ### Learning Rust: 13 | - **Installation**: Rust can be installed using the official installer, `rustup`, which manages Rust versions and associated tools. 14 | - **Tooling**: Rust comes with a package manager called `Cargo`, which simplifies dependency management and project setup. 15 | - **Community**: The Rust community is active and supportive, offering a wealth of resources, including documentation, forums, and online courses. 16 | 17 | For more detailed information on Rust programming, check out the [official Rust website](https://www.rust-lang.org/). 18 | -------------------------------------------------------------------------------- /Lessons/Module3/L3.2.md: -------------------------------------------------------------------------------- 1 | ## Lesson 3.2: **Rust Memory Management** 2 | [![Rust Memory Management](https://img.youtube.com/vi/mlf7QYhXkdc/hqdefault.jpg)](https://www.youtube.com/watch?v=mlf7QYhXkdc) 3 | 4 | Rust employs a unique memory management system that emphasizes safety and efficiency without the need for a garbage collector. Here are the key concepts: 5 | 6 | ### Ownership 7 | - Every piece of data in Rust has a single owner at a time. 8 | - When the owner goes out of scope, Rust automatically deallocates the memory. 9 | 10 | ### Borrowing 11 | - Rust allows references to data without transferring ownership through **borrowing**. 12 | - Borrowing can be either mutable or immutable: 13 | - **Immutable Borrowing**: Multiple references can be created, but none can modify the data. 14 | - **Mutable Borrowing**: Only one mutable reference can exist at a time, preventing data races. 15 | 16 | ### Lifetimes 17 | - Rust uses **lifetimes** to ensure that references are valid for as long as they are needed. 18 | - Lifetimes help the compiler understand how long a reference should be considered valid, preventing dangling references. 19 | 20 | ### Benefits of Rust's Memory Management 21 | - **Safety**: Eliminates common memory-related bugs like null pointer dereferencing and buffer overflows. 22 | - **Performance**: Achieves performance similar to C and C++ while maintaining safety. 23 | - **No Runtime Overhead**: Memory management is handled at compile time, resulting in no additional runtime costs. 24 | 25 | For more in-depth information on Rust's memory management features, check out the [official Rust documentation on Ownership](https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html) and additional resources on [borrowing and lifetimes](https://doc.rust-lang.org/book/ch10-00-generics.html). 26 | -------------------------------------------------------------------------------- /Lessons/Module3/L3.3.md: -------------------------------------------------------------------------------- 1 | ## Lesson 3.3: **Concurrency in Rust** 2 | [![Concurrency in Rust](https://img.youtube.com/vi/06WcsNPUNC8/hqdefault.jpg)](https://www.youtube.com/watch?v=06WcsNPUNC8) 3 | 4 | Concurrency is a core feature of Rust, allowing developers to write safe and efficient concurrent programs. Rust's approach to concurrency is built around the principles of safety and freedom from data races. 5 | 6 | ### Key Concepts of Concurrency in Rust: 7 | 8 | - **Ownership and Borrowing**: Rust’s ownership model inherently prevents data races by ensuring that data has a single owner at a time. When a thread borrows data, it must respect the borrowing rules, which significantly reduce the chances of conflicting accesses. 9 | 10 | - **Threads**: Rust provides a lightweight threading model. Threads can be spawned easily using the standard library's `thread::spawn` function, which creates a new thread to execute a closure concurrently. 11 | 12 | - **Message Passing**: Rust encourages message passing through channels, which are safe and efficient. The `std::sync::mpsc` module allows threads to communicate by sending messages between them, helping to avoid shared state issues. 13 | 14 | - **Synchronization Primitives**: Rust offers synchronization primitives like mutexes and condition variables in the `std::sync` module. These are used to manage access to shared resources and coordinate thread execution safely. 15 | 16 | - **Fearless Concurrency**: Rust's type system and ownership model enable **fearless concurrency**, allowing developers to write concurrent code without the typical fears associated with data races and unsafe memory access. 17 | 18 | ### Conclusion 19 | Rust's concurrency model makes it a powerful choice for writing safe, concurrent applications. By leveraging ownership, borrowing, and message passing, developers can effectively manage concurrent tasks without compromising safety. 20 | 21 | For more information on concurrency in Rust, check out the [official Rust documentation on Concurrency](https://doc.rust-lang.org/book/ch16-00-concurrency.html) and additional resources. 22 | -------------------------------------------------------------------------------- /Lessons/Module3/L3.4.md: -------------------------------------------------------------------------------- 1 | ## Lesson 3.4: **Working with Rust Crates** 2 | [![Working with Rust Crates](https://img.youtube.com/vi/SMcQ3kceDTo/hqdefault.jpg)](https://www.youtube.com/watch?v=SMcQ3kceDTo) 3 | 4 | Rust's package management system, **Cargo**, allows developers to manage dependencies efficiently through **crates**. A crate is a package of Rust code that can be shared and reused. 5 | 6 | ### Key Concepts of Rust Crates: 7 | 8 | - **Creating a New Crate**: You can create a new crate using the Cargo command: 9 | ```bash 10 | cargo new my_crate 11 | -------------------------------------------------------------------------------- /Lessons/Module3/L3.5.md: -------------------------------------------------------------------------------- 1 | ## Lesson 3.5: **Writing Efficient Rust Code** 2 | [![Writing Efficient Rust Code](https://img.youtube.com/vi/usJDUSrcwqI/hqdefault.jpg)](https://www.youtube.com/watch?v=usJDUSrcwqI) 3 | 4 | Writing efficient Rust code involves understanding how Rust manages resources and optimizing performance without sacrificing safety. Here are key practices to enhance the efficiency of your Rust programs: 5 | 6 | ### Key Practices for Efficiency: 7 | 8 | - **Use Borrowing and Ownership**: Leverage Rust's ownership model to minimize unnecessary copies of data. By borrowing data instead of moving it, you can avoid performance overhead. 9 | 10 | - **Avoid Unnecessary Cloning**: Cloning can be expensive, especially for large data structures. Use references whenever possible to access data without duplication. 11 | 12 | - **Minimize Heap Allocations**: Prefer stack allocations over heap allocations for performance-critical code. Use collections like `Vec` judiciously and try to allocate in bulk when possible. 13 | 14 | - **Leverage Iterators**: Rust's iterators are optimized for performance and can help you write more expressive code. Use methods like `.map()`, `.filter()`, and `.fold()` to process data efficiently. 15 | 16 | - **Use Zero-Cost Abstractions**: Rust's abstractions (like traits) are designed to have zero runtime cost. Utilize these abstractions to keep your code clean while maintaining performance. 17 | 18 | - **Profile and Benchmark**: Use tools like `cargo bench` and `perf` to identify performance bottlenecks in your code. Optimize the critical paths based on profiling results. 19 | 20 | - **Understand Unsafe Code**: While Rust emphasizes safety, sometimes you need to use `unsafe` code to achieve maximum performance. Understand when and how to apply it cautiously. 21 | 22 | ### Conclusion 23 | By applying these practices, you can write Rust code that is not only safe but also efficient. Understanding the language's principles and using its features effectively can lead to significant performance improvements. 24 | 25 | For further reading on writing efficient Rust code, check out the [official Rust documentation](https://doc.rust-lang.org/book/ch18-00-patterns.html) and additional resources on optimization strategies. 26 | -------------------------------------------------------------------------------- /Lessons/Module4/L4.1.md: -------------------------------------------------------------------------------- 1 | ## Lesson 4.1: **Installing Linux** 2 | [![Installing Linux](https://upload.wikimedia.org/wikipedia/commons/thumb/3/35/Tux.svg/150px-Tux.svg.png)](https://www.youtube.com/results?search_query=installing+linux) 3 | 4 | In this lesson, you'll learn how to install various Linux distributions, such as Ubuntu and Fedora. We cover creating bootable USB drives, using virtual machines, and performing dual-boot installations. 5 | -------------------------------------------------------------------------------- /Lessons/Module4/L4.2.md: -------------------------------------------------------------------------------- 1 | ## Lesson 4.2: **Basic Linux Commands** 2 | [![Basic Linux Commands](https://upload.wikimedia.org/wikipedia/commons/thumb/b/b7/POSIX_Utilities.pdf/page1-191px-POSIX_Utilities.pdf.jpg)](https://en.wikipedia.org/wiki/Linux_commands) 3 | 4 | Master essential Linux commands for navigating the file system, managing processes, and monitoring system performance. Learn how to effectively use `ls`, `cd`, `cp`, `mv`, and more. 5 | -------------------------------------------------------------------------------- /Lessons/Module4/L4.3.md: -------------------------------------------------------------------------------- 1 | ## Lesson 4.3: **Linux File System Hierarchy** 2 | [![Linux File System Hierarchy](https://upload.wikimedia.org/wikipedia/commons/thumb/d/d6/Ubuntu_Filesystem_Hierarchy.png/300px-Ubuntu_Filesystem_Hierarchy.png)](https://en.wikipedia.org/wiki/Filesystem_Hierarchy_Standard) 3 | 4 | Explore the Linux file system hierarchy, understanding the role of directories such as `/home`, `/etc`, `/var`, and `/usr`. Learn how to navigate and manage files within this structure. 5 | -------------------------------------------------------------------------------- /Lessons/Module4/L4.4.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Krimson-Squad/LinuxKernel_DevRoadmap/796ea4922ad9088ac5d7a152a50e8599b4180cdb/Lessons/Module4/L4.4.md -------------------------------------------------------------------------------- /Lessons/Module4/L4.5.md: -------------------------------------------------------------------------------- 1 | # Lesson 4.4: **Linux Package Management** 2 | [![Linux Package Management](https://upload.wikimedia.org/wikipedia/commons/thumb/3/3b/Synaptic_screenshot.png/220px-Synaptic_screenshot.png)](https://en.wikipedia.org/wiki/Package_manager) 3 | 4 | This lesson covers how to install, update, and remove software using package managers like `apt`, `yum`, and `dnf`. Learn about repositories, dependencies, and handling broken packages. 5 | -------------------------------------------------------------------------------- /Lessons/Module5/L5.1.md: -------------------------------------------------------------------------------- 1 | ## Lesson 5.1: **Introduction to System Programming** 2 | [![yt-video](https://i.ytimg.com/vi/gR1FnnNzMvk/hq720.jpg)](https://www.youtube.com/watch?v=gR1FnnNzMvk) 3 | 4 | Learn about system programming, where code interacts directly with the kernel to perform tasks such as file manipulation, process control, and communication. 5 | -------------------------------------------------------------------------------- /Lessons/Module5/L5.2.md: -------------------------------------------------------------------------------- 1 | ## Lesson 5.2: **Understanding System Calls** 2 | [![yt-video](https://i.ytimg.com/vi/CHs9WwvEKdg/hq720.jpg)](https://www.youtube.com/watch?v=CHs9WwvEKdg) 3 | 4 | 5 | System calls are the interface between user applications and the kernel. Understand the role of common system calls like `open()`, `read()`, `write()`, and `close()` for performing low-level operations. 6 | -------------------------------------------------------------------------------- /Lessons/Module5/L5.3.md: -------------------------------------------------------------------------------- 1 | ## Lesson 5.3: **Signals and Their Uses** 2 | [![yt-video](https://i.ytimg.com/vi/JWQfR_3ddYA/hq720.jpg)](https://www.youtube.com/watch?v=JWQfR_3ddYA) 3 | 4 | 5 | Signals allow for asynchronous communication between processes in Linux. Learn how signals are used to manage processes, terminate them, or notify them of events. 6 | -------------------------------------------------------------------------------- /Lessons/Module5/L5.4.md: -------------------------------------------------------------------------------- 1 | ## Lesson 5.4: **Memory Mapping in Linux** 2 | [![yt-video](https://i.ytimg.com/vi/7aONIVSXiJ8/hq720.jpg)](https://www.youtube.com/watch?v=7aONIVSXiJ8) 3 | 4 | 5 | This lesson explores how memory mapping is used in Linux for efficient file access and sharing memory between processes. 6 | -------------------------------------------------------------------------------- /Lessons/Module7/L7.1.md: -------------------------------------------------------------------------------- 1 | ### Lesson 7.1: Installing Development Tools 2 | In this lesson, we’ll cover the essential tools needed for kernel development, including: 3 | - **Compilers:** Overview of GCC and Clang, with steps for installation. 4 | - **Build Tools:** Discussing Make, CMake, and other build systems commonly used in kernel development. 5 | - **Version Control Systems:** Introduction to Git for managing source code, including basic commands for cloning, committing, and creating branches. 6 | 7 | This lesson ensures you have the foundational tools ready to begin kernel development effectively. -------------------------------------------------------------------------------- /Lessons/Module7/L7.2.md: -------------------------------------------------------------------------------- 1 | ### Lesson 7.2: Configuring Your Development Environment 2 | Learn how to set up and optimize your development environment for productivity and efficiency: 3 | - **Editor Configuration:** Recommended IDEs and editors (like Vim and VSCode), setting up syntax highlighting and linting. 4 | - **Debugging Tools:** Overview of GDB, KGDB, and other kernel debugging tools and how to configure them. 5 | - **Environment Variables:** Important variables like `PATH` and `ARCH` that affect kernel builds and debugging. 6 | 7 | By the end of this lesson, your environment will be configured to streamline your workflow. -------------------------------------------------------------------------------- /Lessons/Module7/L7.3.md: -------------------------------------------------------------------------------- 1 | This lesson covers the process of downloading, building, and troubleshooting the Linux kernel: 2 | - **Obtaining Kernel Source:** Steps to download the latest stable or experimental source code from kernel.org or via Git. 3 | - **Build Configuration:** Introduction to kernel configuration options using tools like `make menuconfig`. 4 | - **Building the Kernel:** Compilation steps and flags, common errors, and troubleshooting methods. 5 | 6 | You’ll complete this lesson with a functional kernel build on your machine -------------------------------------------------------------------------------- /Lessons/Module8/L8.1.md: -------------------------------------------------------------------------------- 1 | ### Lesson 8.1: Finding Good First Issues 2 | This lesson introduces ways to identify beginner-friendly issues in the Linux kernel project: 3 | - **Resources for Finding Issues:** Websites and repositories listing good first issues, including GitHub and the kernel’s Bugzilla. 4 | - **Evaluating Issues:** Criteria for selecting issues that match your skills and experience. 5 | - **Approaching Issues:** Understanding issue requirements, setting up a local testing environment, and asking for guidance when needed. 6 | 7 | By the end, you’ll know where and how to begin with small contributions. -------------------------------------------------------------------------------- /Lessons/Module8/L8.2.md: -------------------------------------------------------------------------------- 1 | ### Lesson 8.2: Understanding the Linux Kernel Community 2 | An overview of the Linux kernel community structure and best practices for collaboration: 3 | - **Community Structure:** Roles of maintainers, contributors, and the hierarchy of the kernel organization. 4 | - **Communication Channels:** Mailing lists, IRC channels, and other forums where kernel development discussions take place. 5 | - **Etiquette and Collaboration:** Guidelines for respectful and productive interactions within the community. 6 | 7 | This lesson equips you to engage with the community effectively and with confidence. -------------------------------------------------------------------------------- /Lessons/Module8/L8.3.md: -------------------------------------------------------------------------------- 1 | 2 | ### Lesson 8.3: Coding Style and Conventions 3 | Learn the Linux kernel’s coding standards and why they’re essential for consistency: 4 | - **Code Formatting:** Proper indentation, bracket use, and spacing conventions. 5 | - **Naming Conventions:** Guidelines for naming functions, variables, and files. 6 | - **Best Practices:** Avoiding common mistakes, following guidelines on function size, and readability. 7 | 8 | You’ll gain the skills to write code that adheres to kernel standards, making your contributions easier to review. -------------------------------------------------------------------------------- /Lessons/Module8/L8.4.md: -------------------------------------------------------------------------------- 1 | ### Lesson 8.4: Submitting Your First Patch 2 | A step-by-step guide to preparing and submitting your first patch to the Linux kernel: 3 | - **Patch Formatting:** Proper formatting for patches, following guidelines for line length and content structure. 4 | - **Commit Messages:** Writing concise, descriptive commit messages that explain changes clearly. 5 | - **Using Git for Patches:** Commands to create patches, add sign-offs, and submit via email or Git. 6 | 7 | By the end, you’ll be ready to submit well-prepared patches to the kernel community. -------------------------------------------------------------------------------- /Lessons/Module9/L9.1.md: -------------------------------------------------------------------------------- 1 | ### Lesson 9.1: Kernel Debugging Techniques 2 | Explore various debugging methods and tools to diagnose and fix issues in the kernel: 3 | - **Kernel Logs:** Using `dmesg` and other log tools to monitor kernel activity and locate errors. 4 | - **Debugging Tools:** Overview of GDB, KGDB, and KDB, including basic commands and setups. 5 | - **Tracing and Profiling:** Using tools like `ftrace`, `perf`, and `systemtap` to analyze kernel performance and track issues. 6 | 7 | This lesson enables you to effectively troubleshoot and debug complex kernel problems. 8 | -------------------------------------------------------------------------------- /Lessons/Module9/L9.2.md: -------------------------------------------------------------------------------- 1 | ### Lesson 9.2: Developing Kernel Modules 2 | Learn to create kernel modules that extend kernel functionality without altering the core kernel: 3 | - **Module Structure:** Anatomy of a kernel module, including `init` and `exit` functions. 4 | - **Module Compilation:** Steps to compile and load kernel modules into the running kernel. 5 | - **Testing and Debugging Modules:** Techniques to test, unload, and debug kernel modules. 6 | 7 | After this lesson, you’ll be equipped to build modular, maintainable extensions to the kernel. 8 | -------------------------------------------------------------------------------- /Lessons/Module9/L9.3.md: -------------------------------------------------------------------------------- 1 | ### Lesson 9.3: Writing Device Drivers 2 | A deep dive into creating device drivers to interface with hardware: 3 | - **Driver Structure:** Key components of a driver, including initialization, cleanup, and device-specific functions. 4 | - **Device File Management:** Managing file descriptors, device nodes, and communication with user space. 5 | - **Testing Drivers:** Testing strategies for drivers, including emulating hardware when needed. 6 | 7 | This lesson prepares you to write and test drivers for a range of hardware devices. -------------------------------------------------------------------------------- /Lessons/Module9/L9.4.md: -------------------------------------------------------------------------------- 1 | ### Lesson 9.4: Kernel and Hardware Interaction 2 | An exploration of how the kernel interfaces with hardware: 3 | - **Interrupt Handling:** Configuring and managing hardware interrupts in the kernel. 4 | - **Memory Management:** How the kernel manages hardware memory and the basics of DMA (Direct Memory Access). 5 | - **Hardware Abstraction:** Using kernel APIs for standardized access to hardware. 6 | 7 | By the end, you’ll understand how the kernel communicates with hardware and manages resources. 8 | -------------------------------------------------------------------------------- /Lessons/Module9/L9.5.md: -------------------------------------------------------------------------------- 1 | ### Lesson 9.5: Networking in the Kernel 2 | An introduction to networking components within the Linux kernel: 3 | - **Networking Stack:** Overview of the kernel’s networking architecture and layers. 4 | - **Socket Programming:** Basics of kernel socket programming and network interface management. 5 | - **Network Protocols:** Discussion of common network protocols handled within the kernel, like TCP/IP. 6 | 7 | This lesson gives you a foundation for working on networking features within the kernel. 8 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Linux Kernel Developer Roadmap 2 | 3 | ## Syllabus 4 | 5 | ### Module 1: Introduction to Linux and the Kernel 6 | - [**Lesson 1.1:**](./Lessons/Module1/L1.1.md) Introduction to Linux 7 | - [**Lesson 1.2:**](./Lessons/Module1/L1.2.md) What is the Linux Kernel? 8 | - [**Lesson 1.3:**](./Lessons/Module1/L1.3.md) Roles and Responsibilities of the Linux Kernel 9 | - [**Lesson 1.4:**](./Lessons/Module1/L1.4.md) Overview of Linux Distributions 10 | - [**Lesson 1.5:**](./Lessons/Module1/L1.5.md) Understanding Operating Systems 11 | 12 | ### Module 2: Operating System Fundamentals 13 | - [**Lesson 2.1:**](./Lessons/Module2/L2.1.md) Basic Components of an Operating System 14 | - [**Lesson 2.2:**](./Lessons/Module2/L2.2.md) Processes, Threads, and Scheduling 15 | - [**Lesson 2.3:**](./Lessons/Module2/L2.3.md) Introduction to Memory Management 16 | - [**Lesson 2.4:**](./Lessons/Module2/L2.4.md) File Systems Overview 17 | - [**Lesson 2.5:**](./Lessons/Module2/L2.5.md) Interprocess Communication Basics 18 | - [**Lesson 2.6:**](./Lessons/Module2/L2.6.md) Introduction to Device Drivers 19 | 20 | ### Module 3: Learning Rust Programming Language 21 | - [**Lesson 3.1:**](./Lessons/Module3/L3.1.md) Fundamentals of Rust 22 | - [**Lesson 3.2:**](./Lessons/Module3/L3.2.md) Rust Memory Management 23 | - [**Lesson 3.3:**](./Lessons/Module3/L3.3.md) Concurrency in Rust 24 | - [**Lesson 3.4:**](./Lessons/Module3/L3.4.md) Working with Rust Crates 25 | - [**Lesson 3.5:**](./Lessons/Module3/L3.5.md) Writing Efficient Rust Code 26 | 27 | ### Module 4: Getting Started with Linux 28 | - [**Lesson 4.1:**](#) Installing Linux 29 | - [**Lesson 4.2:**](#) Basic Linux Commands 30 | - [**Lesson 4.3:**](#) Linux File System Hierarchy 31 | - [**Lesson 4.4:**](#) Linux Package Management 32 | - [**Lesson 4.5:**](#) Managing Users and Permissions 33 | 34 | ### Module 5: Linux Internals 35 | - [**Lesson 5.1:**](#) Introduction to System Programming 36 | - [**Lesson 5.2:**](#) Understanding System Calls 37 | - [**Lesson 5.3:**](#) Signals and their Uses 38 | - [**Lesson 5.4:**](#) Memory Mapping in Linux 39 | 40 | ### Module 6: Exploring the Linux Kernel 41 | - [**Lesson 6.1:**](#) Architecture of the Linux Kernel 42 | - [**Lesson 6.2:**](#) Process Management in Linux 43 | - [**Lesson 6.3:**](#) Linux Memory Management 44 | - [**Lesson 6.4:**](#) Linux I/O Systems 45 | - [**Lesson 6.5:**](#) File Systems in Linux 46 | - [**Lesson 6.6:**](#) Linux Network Subsystem 47 | - [**Lesson 6.7:**](#) Introduction to Device Drivers 48 | 49 | ### Module 7: Setting Up a Kernel Development Environment 50 | - [**Lesson 7.1:**](#) Installing Development Tools 51 | - [**Lesson 7.2:**](#) Configuring Your Development Environment 52 | - [**Lesson 7.3:**](#) Downloading and Building the Linux Kernel 53 | 54 | ### Module 8: Making Your First Contributions 55 | - [**Lesson 8.1:**](#) Finding Good First Issues 56 | - [**Lesson 8.2:**](#) Understanding the Linux Kernel Community 57 | - [**Lesson 8.3:**](#) Coding Style and Conventions 58 | - [**Lesson 8.4:**](#) Submitting Your First Patch 59 | 60 | ### Module 9: Advanced Linux Kernel Development 61 | - [**Lesson 9.1:**](#) Kernel Debugging Techniques 62 | - [**Lesson 9.2:**](#) Developing Kernel Modules 63 | - [**Lesson 9.3:**](#) Writing Device Drivers 64 | - [**Lesson 9.4:**](#) Kernel and Hardware Interaction 65 | - [**Lesson 9.5:**](#) Networking in the Kernel 66 | 67 | ### Module 10: Linux Kernel Development with Rust 68 | - [**Lesson 10.1:**](#) Rust in the Linux Project Overview 69 | - [**Lesson 10.2:**](#) Writing Kernel Modules in Rust 70 | - [**Lesson 10.3:**](#) Developing Device Drivers in Rust 71 | - [**Lesson 10.4:**](#) Submitting Rust-Based Patches 72 | 73 | ### Module 11: Contributing to the Linux Community 74 | - [**Lesson 11.1:**](#) Networking in the Linux Community 75 | - [**Lesson 11.2:**](#) Reviewing and Testing Patches 76 | - [**Lesson 11.3:**](#) Becoming a Linux Maintainer 77 | 78 | ### Module 12: Linux Kernel Security 79 | - [**Lesson 12.1:**](#) Understanding Kernel Security Vulnerabilities 80 | - [**Lesson 12.2:**](#) Secure Coding Practices for the Kernel 81 | - [**Lesson 12.3:**](#) Kernel Hardening Techniques 82 | --------------------------------------------------------------------------------