How do I learn using both the TUI and the Web GUI?

Clone https://github.com/1nc0gn30/30-days-of-Linux-Fundamentals and run ./control-panel for the native C terminal TUI (with built-in Markdown reader, Flashcard Arena, and /tmp sandbox shells), or use the Astro Web GUI for browser command drills, XP tracking, and visual chmod/FHS calculators.

Is 30 Days of Linux Fundamentals completely free?

Yes, 100% of the 30 days, 90 study guides, C TUI drills, and web tools are open-source and unlocked by default with zero paywalls.

← Back to 30-Day Curriculum

WEEK 2 · SYSTEM OPS · TUI: ./control-panel --day 12

Day 12: Storage Engineering: Filesystems, Mounts & fstab

Format ext4/XFS partitions, configure persistent mounts in /etc/fstab, and verify filesystem integrity.

XP 0

Streak 0

Command Mastery 0%

Study Music

YouTube Study Radio

Pick a track or paste any YouTube URL.

🍳 Breakfast (Syntax) Session

Type commands, build streaks, and then review the source guide.

Live Terminal Drill

Re-type the command exactly to clear each challenge.

target$ loading...

0 / 12 mastered

Command Board

Tap a command when you practiced it in your own terminal.

Command Intel

Meaning

Command explanation will appear here.

Sample Output

Output preview will appear here.

Useful Fun Fact

Fun facts about the active command will appear here.

Last Run Output

Run a command to see result feedback.

Knowledge Boost

Faster learning with topic cues, mini-missions, and external docs.

Key Topics

⚡ 60-Second Mental Model (Student Digest)Lesson Overview1. **Introduction to the Linux Kernel**Practice Commands

Mini Missions

Mission 1: Run mount and explain the output in one sentence.
Mission 2: Run umount and explain the output in one sentence.
Mission 3: Run mkdir -p /tmp/linux-dojo-day-12 && cd /tmp/linux-dojo-day-12 and explain the output in one sentence.
Mission 4: Run bash and explain the output in one sentence.

Useful Resources

📖 Digestible Study Guide & Visual Architecture

Source: day-12-breakfast-guide.md · Synced with ./control-panel --day 12

Day 12 · Breakfast — Storage Engineering: Filesystems, Mounts, fstab & LVM

ZothOS × 1nc0gn30 Linux Dojo · Phase: Week 2 (System Ops) · Session: Breakfast (Morning Foundation & Core Command Syntax)

Core Commands: lsblk, blkid, mkfs.ext4, mount, umount, /etc/fstab

⚡ 60-Second Mental Model (Student Digest)

╔══════════════════════════════════════════════════════════════════════════════╗
║  ZOTHOS × 1NC0GN30 // PROCESS, KERNEL & NETWORK OPERATIONS PIPELINE          ║
╠══════════════════════════════════════════════════════════════════════════════╣
║                                                                              ║
║  ┌─────────────────┐    fork() / execve()    ┌────────────────────────────┐  ║
║  │  PID 1: systemd │ ──────────────────────► │  Active Daemons & Tasks    │  ║
║  └────────┬────────┘                         │  • nice / renice [-20..19] │  ║
║           │                                  │  • SIGTERM(15) / SIGKILL(9)│  ║
║           ▼                                  └─────────────┬──────────────┘  ║
║  ┌─────────────────┐    /proc & sysctl       ┌─────────────▼──────────────┐  ║
║  │ Kernel Modules  │ ◄─────────────────────► │ Network & Storage Stack    │  ║
║  │ lsmod / modprobe│                         │ ip route • ss • /etc/fstab │  ║
║  └─────────────────┘                         └────────────────────────────┘  ║
╚══════════════════════════════════════════════════════════════════════════════╝

Learning Pillar	How to Practice This Session
1. Native TUI (`./control-panel`)	Run `./control-panel` from repo root → Select Week 2 → Day 12 → Breakfast to drill interactive C lessons & quizzes.
2. Web Workstation (`astro-ui`)	Open `/day/12` → Select Breakfast tab → Type each target command in the live Mission Terminal to earn XP & streak mastery.
3. Safe Local Sandbox	Run `mkdir -p /tmp/linux-dojo-day-12 && cd /tmp/linux-dojo-day-12` to test every flag below without touching production files.

Welcome to Day 12 Breakfast! Today, we'll explore the fundamentals of the Linux kernel. Understanding the kernel is crucial for mastering Linux system administration and development. In this session, we'll cover kernel modules, kernel parameters, and kernel versioning.

Lesson Overview

1. Introduction to the Linux Kernel

Description:
The Linux kernel is the core component of a Linux operating system, managing hardware, system resources, and providing essential services. It acts as an intermediary between the hardware and user applications.

Key Concepts:

Kernel Architecture: Monolithic kernel with modules.

Responsibilities: Hardware abstraction, process management, memory management, device drivers, and system calls.

Commands:

Check the kernel version:

  unKernel Modules

Description:
Kernel modules are pieces of code that can be loaded into the kernel as needed. They extend the functionality of the kernel without requiring a reboot.

Key Concepts:

Module Loading: Dynamically add functionalities such as device drivers.
Commands:
List loaded modules:

lsmod

Load a module:

sudo modprobe <module_name>

Remove a module:

sudo rmmod <module_name>

Example: Load the usb_storage module to enable USB storage support.

3. Kernel Parameters
Description:
Kernel parameters are settings that control various aspects of the kernel's behavior. They can be configured at boot time or during runtime.

Key Concepts:

Boot Parameters: Passed to the kernel during system startup.
Runtime Parameters: Modified using sysctl.
Commands:

View current parameters:

sysctl -a

Set a parameter:

sudo sysctl -w <parameter>=<value>

Persistent changes: Edit /etc/sysctl.conf and apply changes:

sudo sysctl -p

Example: Adjust vm.swappiness to control how aggressively the kernel swaps memory pages.

4. Kernel Versioning
Description:
Kernel versioning helps in identifying the version of the kernel running on your system, which is important for compatibility and troubleshooting.

Key Concepts:

Version Format: major.minor.patch
Commands:
Check kernel version:

uname -r

Check detailed kernel information:

uname -a

Example: Verify kernel version compatibility with hardware drivers or software requirements.

Practice Commands

Check your current kernel version.
List all loaded kernel modules.
Load and then remove a dummy module (e.g., dummy).
View and set a kernel parameter, such as net.ipv4.ip_forward.
Edit /etc/sysctl.conf to make a persistent change to a kernel parameter.
Conclusion

In this Breakfast session, you've learned about the core components of the Linux kernel, how to work with kernel modules, configure kernel parameters, and understand kernel versioning. These fundamentals are essential for effective Linux system administration and development.

Feel free to experiment with the commands and configurations provided to deepen your understanding of the Linux kernel. Prepare for the next lesson as we continue to build on these concepts.

🥪 Lunch (Workflows) Session

Type commands, build streaks, and then review the source guide.

Live Terminal Drill

Re-type the command exactly to clear each challenge.

target$ loading...

0 / 12 mastered

Command Board

Tap a command when you practiced it in your own terminal.

Command Intel

Meaning

Command explanation will appear here.

Sample Output

Output preview will appear here.

Useful Fun Fact

Fun facts about the active command will appear here.

Last Run Output

Run a command to see result feedback.

Knowledge Boost

Faster learning with topic cues, mini-missions, and external docs.

Key Topics

⚡ 60-Second Mental Model (Student Digest)Lesson Overview1. **Understanding Kernel Modules**Practice Commands

Mini Missions

Mission 1: Run mount and explain the output in one sentence.
Mission 2: Run umount and explain the output in one sentence.
Mission 3: Run mkdir -p /tmp/linux-dojo-day-12 && cd /tmp/linux-dojo-day-12 and explain the output in one sentence.
Mission 4: Run bash and explain the output in one sentence.

Useful Resources

📖 Digestible Study Guide & Visual Architecture

Source: day-12-lunch-guide.md · Synced with ./control-panel --day 12

Day 12 · Lunch — Storage Engineering: Filesystems, Mounts, fstab & LVM

ZothOS × 1nc0gn30 Linux Dojo · Phase: Week 2 (System Ops) · Session: Lunch (Midday Operational Workflows & Flag Mastery)

Core Commands: lsblk, blkid, mkfs.ext4, mount, umount, /etc/fstab

⚡ 60-Second Mental Model (Student Digest)

╔══════════════════════════════════════════════════════════════════════════════╗
║  ZOTHOS × 1NC0GN30 // PROCESS, KERNEL & NETWORK OPERATIONS PIPELINE          ║
╠══════════════════════════════════════════════════════════════════════════════╣
║                                                                              ║
║  ┌─────────────────┐    fork() / execve()    ┌────────────────────────────┐  ║
║  │  PID 1: systemd │ ──────────────────────► │  Active Daemons & Tasks    │  ║
║  └────────┬────────┘                         │  • nice / renice [-20..19] │  ║
║           │                                  │  • SIGTERM(15) / SIGKILL(9)│  ║
║           ▼                                  └─────────────┬──────────────┘  ║
║  ┌─────────────────┐    /proc & sysctl       ┌─────────────▼──────────────┐  ║
║  │ Kernel Modules  │ ◄─────────────────────► │ Network & Storage Stack    │  ║
║  │ lsmod / modprobe│                         │ ip route • ss • /etc/fstab │  ║
║  └─────────────────┘                         └────────────────────────────┘  ║
╚══════════════════════════════════════════════════════════════════════════════╝

Learning Pillar	How to Practice This Session
1. Native TUI (`./control-panel`)	Run `./control-panel` from repo root → Select Week 2 → Day 12 → Lunch to drill interactive C lessons & quizzes.
2. Web Workstation (`astro-ui`)	Open `/day/12` → Select Lunch tab → Type each target command in the live Mission Terminal to earn XP & streak mastery.
3. Safe Local Sandbox	Run `mkdir -p /tmp/linux-dojo-day-12 && cd /tmp/linux-dojo-day-12` to test every flag below without touching production files.

Welcome to Day 12 Lunch! In this session, we'll delve deeper into the Linux kernel. We will cover more advanced aspects of kernel modules, kernel parameters, and kernel versioning. By the end of this lesson, you should have a solid understanding of these concepts and how to apply them practically.

Lesson Overview

1. Understanding Kernel Modules

Description:
Kernel modules are pieces of code that can be loaded into the kernel as needed. They help extend the kernel's functionality without requiring a system reboot. Modules can include device drivers, file systems, or system calls.

Detailed Steps:
1. View Loaded Modules:
- Command: lsmod
- Description: Lists all currently loaded kernel modules.
2. Load a Module:
- Command: sudo modprobe
- Description: Dynamically loads the specified module into the kernel.
3. Unload a Module:
- Command: sudo modprobe -r
- Description: Unloads the specified module from the kernel.
4. Check Module Information:
- Command: modinfo
- Description: Displays detailed information about a module.

Example Commands:

lsmod
sudo modprobe usb_storage
sudo modprobe -r usb_storage
modinfo usb_storage

2. Building and Installing Kernel Modules
Description:
Creating custom kernel modules involves writing code in C, compiling it, and loading it into the kernel. This allows you to add functionality tailored to specific needs.

Steps:

Write a Kernel Module:
File: hello.c
Example Code:

#include <linux/module.h>
#include <linux/kernel.h>

int init_module(void) {
    printk(KERN_INFO "Hello, Kernel World!\n");
    return 0;
}

void cleanup_module(void) {
    printk(KERN_INFO "Goodbye, Kernel World!\n");
}

MODULE_LICENSE("GPL");

Compile the Module:
Command:

make -C /lib/modules/$(uname -r)/build M=$(pwd) modules

Description: Uses the kernel build system to compile the module.
Load the Module:
Command:

sudo insmod hello.ko

Description: Inserts the compiled module into the kernel.
Remove the Module:
Command: sudo rmmod hello
Description: Removes the module from the kernel.
Example Commands:

make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
sudo insmod hello.ko
sudo rmmod hello

3. Kernel Parameters and Sysctl
Description:
Kernel parameters control various aspects of the kernel's operation. These parameters can be adjusted at boot time or dynamically using the sysctl command.

Common Parameters:

fs.file-max: Maximum number of file descriptors.
kernel.pid_max: Maximum number of process IDs.
vm.swappiness: Tendency to swap memory.
Commands:

View Parameters:
Command:

sysctl -a

Set a Parameter:
Command:

sudo sysctl -w <parameter>=<value>

Make Changes Persistent:
Edit: /etc/sysctl.conf
Apply Changes: sudo sysctl -p
Example Commands:

sysctl -a
sudo sysctl -w vm.swappiness=10
sudo nano /etc/sysctl.conf
sudo sysctl -p

4. Tuning Kernel Parameters for Performance
Description:
Optimizing kernel parameters can improve system performance. This involves adjusting settings related to memory management, process limits, and more.

Examples:

Change Maximum Open File Descriptors:
Command:

sudo sysctl -w fs.file-max=100000

Change Maximum User Processes:
Command:

sudo sysctl -w kernel.pid_max=65536

Adjust Swappiness:
Command:

sudo sysctl -w vm.swappiness=10

Example Commands:

sudo sysctl -w fs.file-max=100000
sudo sysctl -w kernel.pid_max=65536
sudo sysctl -w vm.swappiness=10

5. Kernel Versioning and Upgrades
Description:
Kernel versioning helps track changes and updates. Upgrading the kernel may be necessary for new features or hardware support.

Steps:

Check Current Kernel Version:
Command: uname -r
Upgrade Kernel:
Command:

sudo apt-get install linux-image-<new_version>

Update Bootloader:
Command:

sudo update-grub

Example Commands:

uname -r
sudo apt-get install linux-image-5.15.0-58-generic
sudo update-grub

6. Using the dmesg Command
Description:
The dmesg command displays the kernel's ring buffer, containing messages about hardware and system events. This is useful for debugging.

Commands:

View All Messages:
Command:

dmesg

Filter Messages:
Command:

dmesg | grep <keyword>

Clear Message Buffer:
Command:

sudo dmesg -C

Example Commands:

dmesg
dmesg | grep usb
sudo dmesg -C

7. Configuring the GRUB Bootloader
Description:
GRUB is the bootloader responsible for loading the kernel. Configuration involves setting default kernel versions and passing parameters.

Steps:

Update GRUB:
Command:

sudo update-grub

Edit GRUB Configuration:
File: /etc/default/grub
Example Edit: GRUB_DEFAULT="1>2"
Apply Changes:
Command:

sudo update-grub

Example Commands:

sudo update-grub
sudo nano /etc/default/grub
sudo update-grub

8. Understanding Kernel Oops and Panics
Description:
Kernel oops and panics indicate errors in the kernel. An oops is recoverable, while a panic halts the system. Understanding these is essential for system stability.

Logs and Troubleshooting:

View Logs:
Command:

cat /var/log/kern.log

Force a Kernel Panic:
Command:

echo c > /proc/sysrq-trigger (Use with caution)

Enable Crash Dumps:
Command:

sudo apt-get install kdump-tools

Example Commands:

cat /var/log/kern.log
echo c > /proc/sysrq-trigger
sudo apt-get install kdump-tools

9. Monitoring Kernel Activity
Description:
Monitoring kernel activity is crucial for system performance and troubleshooting. Various tools help track different aspects of kernel performance.

Tools:

Monitor CPU Activity:
Commands:

top, htop

Monitor Disk Activity:
Command:

iostat

Monitor Network Activity:
Commands:

iftop

nload

Detailed Process Monitoring:
Command:

ps aux

Example Commands:

top
htop
iostat
iftop
nload
ps aux

10. Custom Kernel Compilation
Description:
Compiling a custom kernel allows tailoring the kernel to specific hardware and needs. This advanced process requires careful configuration.

Steps:

Download Kernel Source:
Command:

wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.x.y.tar.xz

Extract and Configure:
Commands:

tar -xvf linux-5.x.y.tar.xz
cd linux-5.x.y
make menuconfig

Compile and Install:
Commands:

make -j $(nproc)
sudo make modules_install
sudo make install

Update Bootloader:
Command:

sudo update-grub

Example Commands:

wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.x.y.tar.xz
tar -xvf linux-5.x.y.tar.xz
cd linux-5.x.y
make menuconfig
make -j $(nproc)
sudo make modules_install
sudo make install
sudo update-grub

Practice Commands

View current kernel modules and load/unload a module.

Compile a basic kernel module and test it.

Adjust kernel parameters and verify changes.

Upgrade the kernel and check the version.

Use dmesg to view and filter kernel messages.

Update GRUB and configure default kernel options.

Check kernel logs for oops and panic messages.

Monitor system activity with various tools.

Compile and install a custom kernel.

#### Conclusion

In this lesson, we explored kernel modules, parameters, and versioning. Understanding these aspects is crucial for system performance and customization. Practice these commands and concepts to become proficient in managing and optimizing the Linux kernel.

🍽️ Dinner (Hardening) Session

Type commands, build streaks, and then review the source guide.

Live Terminal Drill

Re-type the command exactly to clear each challenge.

target$ loading...

0 / 12 mastered

Command Board

Tap a command when you practiced it in your own terminal.

Command Intel

Meaning

Command explanation will appear here.

Sample Output

Output preview will appear here.

Useful Fun Fact

Fun facts about the active command will appear here.

Last Run Output

Run a command to see result feedback.

Knowledge Boost

Faster learning with topic cues, mini-missions, and external docs.

Key Topics

⚡ 60-Second Mental Model (Student Digest)OverviewLesson Topics1. Introduction to Kernel Debugging2. Using kgdb for Kernel Debugging3. Understanding Kernel Crash Dumps with kdump

Mini Missions

Mission 1: Run mount and explain the output in one sentence.
Mission 2: Run umount and explain the output in one sentence.
Mission 3: Run mkdir -p /tmp/linux-dojo-day-12 && cd /tmp/linux-dojo-day-12 and explain the output in one sentence.
Mission 4: Run echo c > /proc/sysrq-trigger and explain the output in one sentence.

Useful Resources

📖 Digestible Study Guide & Visual Architecture

Source: day-12-dinner-guide.md · Synced with ./control-panel --day 12

Day 12 · Dinner — Storage Engineering: Filesystems, Mounts, fstab & LVM

ZothOS × 1nc0gn30 Linux Dojo · Phase: Week 2 (System Ops) · Session: Dinner (Evening Hardening, Pipelines & Verification Lab)

Core Commands: lsblk, blkid, mkfs.ext4, mount, umount, /etc/fstab

⚡ 60-Second Mental Model (Student Digest)

╔══════════════════════════════════════════════════════════════════════════════╗
║  ZOTHOS × 1NC0GN30 // PROCESS, KERNEL & NETWORK OPERATIONS PIPELINE          ║
╠══════════════════════════════════════════════════════════════════════════════╣
║                                                                              ║
║  ┌─────────────────┐    fork() / execve()    ┌────────────────────────────┐  ║
║  │  PID 1: systemd │ ──────────────────────► │  Active Daemons & Tasks    │  ║
║  └────────┬────────┘                         │  • nice / renice [-20..19] │  ║
║           │                                  │  • SIGTERM(15) / SIGKILL(9)│  ║
║           ▼                                  └─────────────┬──────────────┘  ║
║  ┌─────────────────┐    /proc & sysctl       ┌─────────────▼──────────────┐  ║
║  │ Kernel Modules  │ ◄─────────────────────► │ Network & Storage Stack    │  ║
║  │ lsmod / modprobe│                         │ ip route • ss • /etc/fstab │  ║
║  └─────────────────┘                         └────────────────────────────┘  ║
╚══════════════════════════════════════════════════════════════════════════════╝

Learning Pillar	How to Practice This Session
1. Native TUI (`./control-panel`)	Run `./control-panel` from repo root → Select Week 2 → Day 12 → Dinner to drill interactive C lessons & quizzes.
2. Web Workstation (`astro-ui`)	Open `/day/12` → Select Dinner tab → Type each target command in the live Mission Terminal to earn XP & streak mastery.
3. Safe Local Sandbox	Run `mkdir -p /tmp/linux-dojo-day-12 && cd /tmp/linux-dojo-day-12` to test every flag below without touching production files.

Overview

In this study guide, we'll explore advanced topics in Linux Kernel Basics, including kernel debugging, security enhancements, patching, and live patching. This guide covers key concepts, commands, and practical applications related to these topics.

Lesson Topics

1. Introduction to Kernel Debugging

Kernel debugging is crucial for diagnosing and fixing kernel issues. Key tools include:

kgdb: A debugger for the Linux kernel.

- Start debugging: gdb vmlinux
- Connect to the kernel: target remote /dev/ttyS0

kdump: A crash dumping mechanism.

- Configure: Edit /etc/default/grub and add crashkernel=128M
- Test: echo c > /proc/sysrq-trigger

ftrace: A tracing utility for debugging kernel performance.

- Start tracing: echo function > /sys/kernel/debug/tracing/current_tracer
- View trace output: cat /sys/kernel/debug/tracing/trace

2. Using kgdb for Kernel Debugging

kgdb allows you to debug a running kernel using gdb:

1. Compile kernel with debugging symbols: Add CONFIG_KGDB=y to your kernel configuration.
2. Connect debugger: Use a serial or network connection.
3. Launch gdb: gdb vmlinux
4. Connect to kgdb: target remote /dev/ttyS0
5. Set breakpoints and inspect kernel state.

3. Understanding Kernel Crash Dumps with kdump

kdump captures kernel memory contents after a crash:

1. Install kexec-tools: sudo apt-get install kexec-tools
2. Configure crashkernel: Edit /etc/default/grub and add crashkernel=128M
3. Update GRUB: sudo update-grub
4. Test kdump: Trigger a crash with echo c > /proc/sysrq-trigger.

4. Using ftrace for Kernel Tracing

ftrace helps analyze kernel performance:

1. Enable function tracing: echo function > /sys/kernel/debug/tracing/current_tracer
2. View trace output: cat /sys/kernel/debug/tracing/trace
3. Stop tracing: echo > /sys/kernel/debug/tracing/trace
4. Set up tracepoints: echo 'tracepoint_name' > /sys/kernel/debug/tracing/set_ftrace_filter

5. Kernel Security Enhancements

Kernel security features include:

SELinux: Enforces security policies.

- Check status: sestatus
- Modify settings: Edit /etc/selinux/config

AppArmor: Similar to SELinux.

- Check status: sudo aa-status

seccomp: Restricts system calls.

- Set up filters: Use prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT)

6. Configuring SELinux

SELinux provides mandatory access control (MAC):

1. Check status: sestatus
2. Enable/disable SELinux: Edit /etc/selinux/config and set SELINUX=enforcing or SELINUX=permissive.
3. Troubleshoot issues: Use ausearch -m avc and semanage for policy management.

7. Applying Kernel Patches

Kernel patches fix bugs and add features:

1. Download patch: Obtain from kernel.org or a trusted source.
2. Apply patch: patch -p1 < patch_file
3. Rebuild kernel: make -j $(nproc)
4. Install new kernel: sudo make modules_install && sudo make install
5. Update bootloader: sudo update-grub

8. Kernel Live Patching

Live patching applies patches without rebooting:

kpatch: Install and apply patches.

- Install: sudo yum install kpatch
- Apply patch: kpatch load patch_file

kGraft: Another live patching solution.

Canonical livepatch service: For Ubuntu.

- Enable: sudo apt-get install ubuntu-livepatch

9. Understanding Kernel Locking Mechanisms

Kernel locking prevents race conditions:

Spinlocks: Busy-wait locks for interrupt contexts.

- Acquire: spin_lock(&lock)
- Release: spin_unlock(&lock)

Mutexes: Sleep-based locks for process contexts.

- Acquire: mutex_lock(&mutex)
- Release: mutex_unlock(&mutex)

Read-write locks: Allow multiple readers or a single writer.

- Acquire read lock: read_lock(&rwlock)
- Release read lock: read_unlock(&rwlock)
- Acquire write lock: write_lock(&rwlock)
- Release write lock: write_unlock(&rwlock)

10. Managing Kernel Threads

Kernel threads perform background tasks:

1. View kernel threads: ps -eLf
2. Create kernel thread: Use kthread_create in kernel code.
- Example: struct task_struct *task = kthread_create(function, data, 'name');
3. Start kernel thread: wake_up_process(task)
4. Stop kernel thread: Use kthread_stop in kernel code.
- Example: kthread_stop(task);

Questions and Answers

Breakfast Questions

1. Which command is used to view all loaded kernel modules?
- lsmod

2. How do you dynamically load a kernel module?
- sudo modprobe

3. Which file contains information about kernel modules?
- /lib/modules/$(uname -r)/modules.dep

4. How do you unload a kernel module?
- sudo modprobe -r

5. Which command displays detailed information about a module?
- modinfo

Lunch Questions

1. What command shows the current kernel version?
- uname -r

2. Which command updates the GRUB bootloader?
- sudo update-grub

3. How do you check kernel parameters?
- sysctl -a

4. Which file do you edit to make kernel parameter changes persistent?
- /etc/sysctl.conf

5. What command is used to apply changes from /etc/sysctl.conf?
- sudo sysctl -p

Dinner Questions

1. Which tool is used for debugging the Linux kernel?
- Answer: kgdb

2. What is the purpose of kdump?
- Answer: To capture the contents of the kernel's memory after a crash

3. How do you enable function tracing with ftrace?
- Answer: echo function > /sys/kernel/debug/tracing/current_tracer

4. Which command checks the status of SELinux?
- Answer: sestatus

5. How do you apply a kernel patch?
- Answer: patch -p1 < patch_file

6. What is live kernel patching?
- Answer: Applying kernel patches without rebooting the system

7. What is a spinlock?
- Answer: A busy-wait lock used in interrupt contexts

8. How do you view kernel threads?
- Answer: ps -eLf

9. What is the purpose of SELinux?
- Answer: To enforce mandatory access control (MAC) security policies

10. Which utility is used for live kernel patching on Linux?
- Answer: kpatch

Conclusion

In Day 12 Dinner, we covered essential aspects of Linux Kernel Basics, including debugging, security, patching, and live patching. Understanding these concepts is crucial for effective kernel management and troubleshooting. Review the lessons and test your knowledge with the provided questions to solidify your understanding.