
- Introduction
- Tracing overview
- Tracing landscape in Linux
- Strace
- Ltrace
- Uprobe introduction
- Uprobe demonstration
- Perf tool introduction
- User level tracing with Perf
- Kprobes
- Perf event tracing
- Perf static tracepoints
- Perf Dynamic tracepoints
- Perf Trace
- Ftrace introduction
- Ftrace controls
- Ftrace tracers
- function and function graph tracer
- irqsoff tracer
- Trace-cmd introduction
- Trace-cmd usage
- KernelShark Introduction
- Kernelshark demonstration
- eBPF overview
- eBPF mechanism
- Related tools
- BCC tools intro
- opensnoop demonstration
- tcpconnect demonstration
- bpftrace introduction
- Demonstrations
- Developing Custom eBPF programs
- LTTng Introduction
- LTTng Architecture and components
- LTTng Core concept
- LTTng Tracepoint
- Tracepoint provider package
- Tracepoint definition
- Tracepoint build mechanism
- LTTng User-space tracing
- LTTng Kernel-space tracing
- LTTng preloaded helper libraries
- Remote tracing with LTTng
- References
- Summary
- Introduction
- Profiling Landscape in Linux
- Histogram
- Flamegraphs
- Massif Introduction
- Massif report
- Massif result analysis
- Massif visualization
- Heaptrack Introduction
- Heaptrack Demonstration
- Memusage introduction
- Memusage example
- Memusage graphical representation
- Execution based profiling introduction
- eBPF profiler
- eBPF profiler demonstration
- Sysprof introduction
- Sysprof example
- Gprof Introduction
- Callgrind Introduction
- Callgrind Demonstration
- Cachegrind Introduction
- Cachegrind usage
- Perf stat introduction
- Perf stat demonstration
- CPU Frequency Scaling
- Tools for CPU frequency observations
- Demonstration
- Summary
- References
- Introduction
- Kconfig introduction
- Vmlinux
- System Map
- Kernel Logging overview
- Printk() and pr_*() family
- dev_* family
- printK format specifiers
- kptr_restrict
- dmesg
- Kernel Dynamic Debugging
- Dynamic debugging through uboot
- Dynamic Debugging Demonstration
- Kernel OOPS messages
- Kernel oops analysis using:
- GDB
- addr2line and nm
- objdump
- Kernel Panic using SysRQ
- Debuggin kernel panic using GDB, addr2line and nm
- Kexec and Kdump
- Crash utility
- Magic SysRQ
- Lockdep Introduction
- Lockdep Demonstration
- KCSAN introduction
- KCSAN demonstration
- Kmemleak introduction
- Kmemleak demonstration
- KASAN Introduction
- KASAN demonstration
- KEFENCE Introduction
- KEFENCE demonstration
- UBSAN introduction
- UBSAN demonstration
- KGDB
- KGDB Kernel Config
- KDB
- KDMX
- Setup and Configuration
- KGDB setup demonstration
- KGDB Demonstration
- Summary
- References
Linux is at the heart of our modern world. From the devices we carry in our pockets to the systems that power industries, Linux, and particularly embedded Linux, plays a pivotal role. It drives the technology behind smart home devices, medical equipment, automotive systems, and so much more. These systems aren't just conveniences—they're critical to how we live, work, and innovate.
The world of software development is changing rapidly. With the rise of AI-assisted coding, many teams are generating large volumes of code quickly and at scale. While this can accelerate development, it often introduces subtle bugs and hard-to-diagnose issues that AI cannot fix. As companies increasingly rely on AI to handle routine coding tasks, there will be a growing need for engineers with advanced debugging expertise who can step in when things go wrong. This course prepares you for that future by giving you the ability to understand and correct issues that go beyond the reach of automated tools.
One of the challenges in learning these advanced skills is that the information is scattered across countless sources, often buried in outdated documentation or fragmented tutorials. Searching the web for answers can be frustrating and extremely time-consuming. This course brings everything together in one structured, practical program so you can focus on learning rather than piecing together random information.
This second part of the Linux Debugging course builds on the foundation provided by Part 1. It takes you into the advanced areas of Linux debugging where you move beyond the basics and begin to explore the powerful techniques used by senior engineers to solve the most difficult and elusive problems in complex Linux systems.
You will learn how to trace both user space and kernel space activity, giving you deep insight into how processes and the kernel interact at runtime. You will gain expertise in advanced profiling techniques for memory, CPU, and hardware performance analysis, as well as approaches for visualizing data to better understand where performance bottlenecks occur.
Finally, you will develop the ability to debug at the kernel level, diagnosing kernel crashes and runtime errors, using interactive kernel debuggers, and working with modern diagnostic tools like KASAN, UBSAN, and KCSAN. These skills will give you the confidence to fix problems that others may find impossible to diagnose.
By the end of our course, you will have acquired a comprehensive set of techniques for tracing, profiling, and debugging at every level of the Linux system. Whether you are working on embedded devices, cloud infrastructure, or mission-critical systems, these skills will allow you to diagnose and solve the toughest problems with confidence.
If you want to become the person others rely on when complex, high-stakes issues arise, this course will give you the expertise and the confidence to take on that role.