Udemy Business

Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Debugging Linux Kernel in Deep - Part 1

Name: Debugging Linux Kernel in Deep - Part 1
Rating: 4.3 (292 reviews)

Linux Kernel Debugging Techniques

Created byLinux Trainer

Last updated 11/2020

English

What you'll learn

Linux Kernel Debugging Techniques

Course content

6 sections • 70 lectures • 6h 18m total length

Introduction to Tracing2:09
Introduction to ftrace2:14
Check Whether ftrace is enabled in kernel5:44
Important files in tracefs3:44
Enabling a different tracer5:09
Function Graph Tracer5:34
Filtering functions11:28
Filter functions to simplify search in kernel tracing, using include and exclude lists, wildcards, and field filters to trace specific functions and measure latency with the function graph tracer.
Wildcard Characters in filters2:54
Question and Answer1:04
ftrace on simple kernel module11:15
Enabling and Disabling tracing2:52
trace vs trace_pipe3:45
Find out what calls made by a kernel function5:52
Tracing a specific process6:32
Trace a specific process by enabling tracing in the shell to capture all system calls, then disable tracing and verify the observed calls with filters.
Tracing functions of specific module3:38
trace_printk6:32
Tracing kernel functions with a particular duration2:49
Finding out how user space code gets into kernel2:29

irqs-off2:26
need-resched4:42
The lecture explains preemption, time slices, and the need_resched flag, showing how the interrupt handler decides to preempt the running task and reallocate the cpu.
Hardirq, softirq or process context3:56
preempt-depth4:23
Start/Stop tracing on a particular function8:01
trace_options file7:14
options directory2:27
Disabling interrupt information from function_graph2:34
Who is calling a particular kernel function4:48
trace_marker2:21
Use trace_marker to allow a userspace process to write into the kernel trace buffer and synchronize tracing between userspace and kernel events.
trace_marker from userspace2:59
Kernel function profiling3:33
Find maximum time interrupt are disabled6:15
Example of irqsoff tracer3:30
Use the irqsoff tracer to disable interrupts on the current processor, run a ten-second busy loop, and observe max latency and the function responsible for it.
Finding latencies at boot5:49
Finding deepest kernel stack4:53
ftrace dump on oops2:10
snapshot2:35

Introduction to Tracepoints4:17
Introduction to Tracing Events11:36
Format file6:46
Filter File14:29
More examples of setting filter10:20
Explore advanced filter techniques in Linux kernel debugging, using common and event-specific fields to enable or ignore signal subsystem events and observe signal generated and delivered flows.
Subsystem Filters6:15
Event Triggers12:26
Histograms12:19
set_event interface5:21
Event PID Filtering1:46
Explore event pid filtering to trace only kernel events from selected processes, learn how to enable events, view which events are enabled, and observe how removing filters broadens tracing.
Example of set_event_pid4:06
Tracing Events at boot1:05

mkdir6:46
Can i Change format of event0:50
explain why you cannot change the event format in this linux kernel debugging context due to read permissions and the lack of available functionality.
USB Events3:04
Scheduling Events6:25
Exception Events5:44
Explore exception events and page faults in the Linux kernel, distinguishing kernel and user faults, tracing fault entries, and observing major and minor faults.
module events5:38
ext4 events9:47
Explore ext4 events and tracing in Linux kernel debugging; learn how i-nodes, journaling, the superblock, and file operations like create, write, copy, move, and delete are reflected in trace events.
fs events4:30
irq events16:25
explain how linux kernel irq events are traced, showing irq entry and exit, softirq handling, and how to filter and identify which hardware or software triggers interrupts.
net events4:30
Beaglebone events9:26

Introduction2:45
trace-cmd list8:48
trace-cmd stat3:37
trace-cmd start and trace-cmd stop11:06
trace-cmd show3:54
trace-cmd reset3:22
Reset tracing with trace-cmd to reset the function graph and subsystem events, verify which events are enabled, observe how tracing affects performance and file access.
trace-cmd Function Filtering3:22
trace-cmd Pid Filtering3:29
Use trace-cmd to filter by pid and by function, exploring function filtering, event tracing, and selective system-call tracing to observe subsystem activity during execution.
trace-cmd record and trace-cmd report10:43
trace-cmd extract3:07

Requirements

Should have knowledge in Linux Kernel

Description

A traditional debugger allows you to inspect the system state once the system is halted

i.e., after an error has been detected, but doesn’t reveal the events leading to the error.

To understand why an event took place, the relevant context has to be restored. This requires tracing

Tracing is the process of collecting information on the activity in a working system

With tracing, program execution is recorded during run-time, allowing for later analysis of the trace

Tracing provides developers with information useful for debugging.

In this course, we will be learning ftrace, which is the official tracer of Linux Kernel in deep

What can we do using ftrace?

-----------------------------

Debugging Linux Kernel

Analyzing Latencies in Linux Kernel

Learn and observe the flow of Linux Kernel

Trace context switches

Length of the time the interrupts are disabled

And many more

Who this course is for:

Kernel developers interested to learn various debugging techniques

Debugging Linux Kernel in Deep - Part 1

What you'll learn

Explore related topics

Course content

Introduction to ftrace18 lectures • 1hr 26min

ftrace continued18 lectures • 1hr 15min

Tracing Events12 lectures • 1hr 31min

Interesting Trace Events11 lectures • 1hr 13min

trace-cmd10 lectures • 54min

Notes1 lecture • 1min

Requirements

Description

Who this course is for: