What you'll learn

Gain hands-on experience with a wide range of Linux debugging tools and methodologies which covers both userspace and kernel space
Understand techniques to identify and fix memory issues, performance bottleneck and system errors for more robust and efficient software development.
Acquire specialized skills to debug the Linux based application, including analysis of coredumps, using GDB and binutils
Build a strong foundation in debugging real-world issues and advance your career in Linux development, embedded systems, DevOps, or kernel engineering.

Course content

6 sections • 43 lectures • 3h 57m total length

Introduction6:22

Linux OS Architecture3:08
Linux OS fundamental
32-bit User space address4:02
Linux address space on 32-bit architecture
User space addressing in 32-bit architecture
Virtual address mapping
32-bit Kernel space address2:14
Kernel space addressing in 32-bit architecture
Kernel Logical Address
Kernel Virtual address
64-bit User space address5:23
Linux address space on 64-bit architecture
User space addressing in 64-bit architecture
64-bit Kernel space address6:31
Kernel space addressing in 64-bit architecture
Memory Management Unit3:22
Memory Management Unit (MMU)
Page table
Page fault handling2:13
Page fault handling sequence
Virtual address mapping5:45
Virtual address mapping in a process
Sharing memory between processes
Shared memory demonstration
Process and Threads6:26
Process and threads
Demonstration "current" task pointer using kernel module
Process and thread demonstration using example code
ELF file format3:15
Executable file format
Demonstration to dump the ELF header from an executable binary.
Shared Libraries7:34
Shared Libraries
Shared Libraries search path
Demonstration on shared libraries
Scheduling in Linux7:50
Scheduling in Linux
Modifying scheduling parameters
Demonstration to set scheduling policy and other scheduling related parameters.
Context Scheduling
Scheduling Algorithms
System Calls and Exceptions4:30
System Calls in Linux
System call demonstration using strace
Exception in Linux
Interrupts1:42
Interrupts in Linux
Interrupt context
Deferred Interrupt handling4:40
Deferred interrupt handling in Linux
Kernel Threads
Workqueue
SoftIRQs
Tasklets
References1:48
References
Summary

Basic Linux Analysis and Observability Tools Introduction0:41
Pseudo filesystems in Linux9:14
Discussing various pseudo (virtual) file systems and important files associated with these file systems
/proc
/sys
/dev
debugfs
Monitoring tools in Linux2:48
Overview of Linux monitoring tools
Memory representation
Process Monitoring tools7:23
Demonstrating following process monitoring tools
PS command
Top command
Process tree
Memory Monitoring tools7:05
Demonstrating following Memory Monitoring tools
Free
VMstat
Process map
CPU and I/O Monitoring tools11:59
Demonstrating following CPU and Disk monitoring tools
iostat
iotop
mpstat
Network Monitoring tools4:24
Demonstrating following Network monitoring tools
netstat
ethtool
tcpdump
References0:52
Summary
References

Introduction1:11
Binutils10:08
Binutils are a collection of tools that we can use to work with object files, program binaries and libraries. This video covers the following tools along with individual demonstration.
readelf
objdump
nm and addr2line
ldd
GDB introduction6:46
GDB introduction
Debugging file format
Compiler option for debugging
Code optimisation options
Code optimisation demonstration
GDB command line options15:36
GDB basic commands
Breakpoints
Watchpoints
File command
GDB commands cheat-sheet2:15
Collection for various GDB commands
Remote debugging with GDB9:59
Remote Debugging with GDB
Remote debugging demonstration
Remote debugging with VScode
Extending GDB with Python4:56
Python GDB module
Setting breakpoint using python GDB module
Demonstration
Debugging shared libraries5:11
Shared library debugging using GDB
LD_PRELOAD environment variable
Libsegfault library4:07
Libsegfault
Demonstration
Backtrace analysis using nm
Core dumps and analysis with GDB2:14
Coredump introduction
Enabling coredump functionality
Coredump analysis using GDB
Demonstration
References1:37
References
Summary

Memory Management and common memory issues7:11
Memory management
Common memory issues
Segmentation fault and demonstration
Memory leak
Buffer overflow
Memory debugging tools - Static Code Analysis and Valgrind9:40
Memory debugging tools
Static analysis tools
Valgrind introduction
Memcheck tool in Valgrind along with demonstration
Valgrind GDB support along with demonstration
Sanitizer - Address Sanitizer (ASan)13:04
Sanitizer introduction
Address Sanitizer (ASan)
ASan demonstration
Sanitizer - Memory Sanitizer, Thread Sanitizer and Undefined Behavior Sanitizer9:39
Memory Sanitizer (MSan)
Thread Sanitizer (TSan) and demonstration
Undefined Behaviour Sanitizer (UBSan) and demonstration
Libefence8:57
libefence
Demonstration
Best practices for Memory Management3:15
Best practices for Memory management
References
Summary

Requirements

Basic understanding of the Linux operating system and familiarity with the Linux command line are recommended.

Description

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.

But with great complexity comes great challenges. Debugging these systems is an intricate process that requires a deep understanding of tools and techniques. The stakes are high—whether it's ensuring a life-saving device operates flawlessly or guaranteeing the safety of an autonomous vehicle.

Acquiring these debugging skills is no easy feat. It demands not only technical expertise but also hands-on experience with the tools and processes that define the Linux ecosystem. And that's where this course steps in.

This course brings together all the essential material in one place, simplifying the complex and equipping you with the skills you need to excel. You'll master tools like GDB, learn to analyze core dumps, and understand how to debug segmentation faults and shared libraries. Whether you're troubleshooting a single device or an entire system, these skills will set you apart.

By the end of this journey, you'll be prepared to tackle the toughest debugging challenges in the Linux world, contributing to the technologies that shape our lives. Ready to dive in?

Who this course is for:

Linux application developers
Linux Kernel developers
Embedded System engineers
System administrator
DevOps Engineers
Site reliability engineers (SREs)
Students and Enthusiasts

What you'll learn

Explore related topics

Course content

Linux Debug Training (Part-1) Introduction1 lecture • 6min

Linux Operating System Architecture16 lectures • 1hr 10min

Basic Linux Analysis and Observability Tools8 lectures • 44min

Application Debugging11 lectures • 1hr 4min

Memory Issues in Linux Applications6 lectures • 52min

Linux Debug Training (Part-1) Closure1 lecture • 1min

Requirements

Description

Who this course is for: