perf lock: Tracing contention lock owner call stack
Subsystems (2)
cover perf lock: Tracing contention lock owner call stack
For perf lock contention, the current owner tracking (-o option) only works with per-thread mode (-t option). Enabling call stack mode for owner can be useful for diagnosing why a system running slow in lock contention.
Example output:
$ sudo ~/linux/tools/perf/perf lock con -abvo -Y mutex-spin -E16 perf bench sched pipe ... contended total wait max wait avg wait type caller
171 1.55 ms 20.26 us 9.06 us mutex pipe_read+0x57
0xffffffffac6318e7 pipe_read+0x57
0xffffffffac623862 vfs_read+0x332
0xffffffffac62434b ksys_read+0xbb
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76
36 193.71 us 15.27 us 5.38 us mutex pipe_write+0x50
0xffffffffac631ee0 pipe_write+0x50
0xffffffffac6241db vfs_write+0x3bb
0xffffffffac6244ab ksys_write+0xbb
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76
4 51.22 us 16.47 us 12.80 us mutex do_epoll_wait+0x24d
0xffffffffac691f0d do_epoll_wait+0x24d
0xffffffffac69249b do_epoll_pwait.part.0+0xb
0xffffffffac693ba5 __x64_sys_epoll_pwait+0x95
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76
2 20.88 us 11.95 us 10.44 us mutex do_epoll_wait+0x24d
0xffffffffac691f0d do_epoll_wait+0x24d
0xffffffffac693943 __x64_sys_epoll_wait+0x73
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76
1 7.33 us 7.33 us 7.33 us mutex do_epoll_ctl+0x6c1
0xffffffffac692e01 do_epoll_ctl+0x6c1
0xffffffffac6937e0 __x64_sys_epoll_ctl+0x70
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76
1 6.64 us 6.64 us 6.64 us mutex do_epoll_ctl+0x3d4
0xffffffffac692b14 do_epoll_ctl+0x3d4
0xffffffffac6937e0 __x64_sys_epoll_ctl+0x70
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76=== owner stack trace ===
3 31.24 us 15.27 us 10.41 us mutex pipe_read+0x348
0xffffffffac631bd8 pipe_read+0x348
0xffffffffac623862 vfs_read+0x332
0xffffffffac62434b ksys_read+0xbb
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76...
Chun-Tse Shao (4):
perf lock: Add bpf maps for owner stack tracing perf lock: Retrieve owner callstack in bpf program perf lock: Make rb_tree helper functions generic perf lock: Report owner stack in usermode
tools/perf/builtin-lock.c | 55 +++-- tools/perf/util/bpf_lock_contention.c | 58 +++++- .../perf/util/bpf_skel/lock_contention.bpf.c | 189 +++++++++++++++++- tools/perf/util/bpf_skel/lock_data.h | 6 + tools/perf/util/lock-contention.h | 2 + 5 files changed, 290 insertions(+), 20 deletions(-)
--
2.47.1.688.g23fc6f90ad-goog
PATCH 1/4 perf lock: Add bpf maps for owner stack tracing
Add few bpf maps in order to tracing owner stack.
--- tools/perf/util/bpf_lock_contention.c | 17 ++++++-- .../perf/util/bpf_skel/lock_contention.bpf.c | 40 +++++++++++++++++-- tools/perf/util/bpf_skel/lock_data.h | 6 +++ 3 files changed, 56 insertions(+), 7 deletions(-)
tools/perf/util/bpf_lock_contention.c +14 -3
@@ -41,9 +41,20 @@ int lock_contention_prepare(struct lock_contention *con)else bpf_map__set_max_entries (skel->maps.task_data,1 ); -if (con->save_callstack) -bpf_map__set_max_entries (skel->maps.stacks, con->map_nr_entries); -else +if (con->save_callstack) { +bpf_map__set_max_entries (skel->maps.stacks, + con->map_nr_entries); +if (con->owner) { +bpf_map__set_value_size (skel->maps.owner_stacks_entries, + con->max_stack *sizeof (u64)); +bpf_map__set_value_size ( + skel->maps.contention_owner_stacks, + con->max_stack *sizeof (u64)); +bpf_map__set_key_size (skel->maps.owner_lock_stat, + con->max_stack *sizeof (u64)); + skel->rodata->max_stack = con->max_stack; + } + }else bpf_map__set_max_entries (skel->maps.stacks,1 );if (target__has_cpu (target)) {
tools/perf/util/bpf_skel/lock_contention.bpf.c +36 -4
@@ -19,13 +19,37 @@#define LCB_F_PERCPU (1U << 4)#define LCB_F_MUTEX (1U << 5) -/* callstack storage */ +/* tmp buffer for owner callstack */ struct { - __uint(type, BPF_MAP_TYPE_STACK_TRACE); + __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY); __uint(key_size, sizeof(__u32)); __uint(value_size, sizeof(__u64)); + __uint(max_entries, 1); +} owner_stacks_entries SEC(".maps"); + +/* a map for tracing lock address to owner data */ +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(key_size, sizeof(__u64)); // lock address + __uint(value_size, sizeof(cotd)); __uint(max_entries, MAX_ENTRIES); -} stacks SEC(".maps"); +} contention_owner_tracing SEC(".maps"); + +/* a map for tracing lock address to owner stacktrace */ +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(key_size, sizeof(__u64)); // lock address + __uint(value_size, sizeof(__u64)); // straktrace + __uint(max_entries, MAX_ENTRIES); +} contention_owner_stacks SEC(".maps"); + +/* owner callstack to contention data storage */ +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(key_size, sizeof(__u64)); + __uint(value_size, sizeof(struct contention_data)); + __uint(max_entries, MAX_ENTRIES); +} owner_lock_stat SEC(".maps");/* maintain timestamp at the beginning of contention */ struct {
@@ -43,6 +67,14 @@ struct {__uint (max_entries,1 ); } tstamp_cpu SEC(".maps"); +/* callstack storage */ +struct { + __uint(type, BPF_MAP_TYPE_STACK_TRACE); + __uint(key_size, sizeof(__u32)); + __uint(value_size, sizeof(__u64)); + __uint(max_entries, MAX_ENTRIES); +} stacks SEC(".maps"); +/* actual lock contention statistics */ struct { __uint(type, BPF_MAP_TYPE_HASH);
@@ -126,6 +158,7 @@ const volatile int needs_callstack;const volatile int stack_skip;const volatile int lock_owner;const volatile int use_cgroup_v2; +const volatile int max_stack;/* determine the key of lock stat */ const volatile int aggr_mode;
@@ -436,7 +469,6 @@ int contention_end(u64 *ctx)return 0 ; need_delete = true; } - duration =bpf_ktime_get_ns () - pelem->timestamp;if ((__s64 )duration <0 ) {__sync_fetch_and_add (&time_fail,1 );
tools/perf/util/bpf_skel/lock_data.h +6 -0
@@ -3,6 +3,12 @@ #ifndef UTIL_BPF_SKEL_LOCK_DATA_H #define UTIL_BPF_SKEL_LOCK_DATA_H +typedef struct contention_owner_tracing_data { + u32 pid; // Who has the lock. + u64 timestamp; // The time while the owner acquires lock and contention is going on. + u32 count; // How many waiters for this lock. +} cotd; + struct tstamp_data { u64 timestamp; u64 lock;
Signature · 1 line
2.47.1.688.g23fc6f90ad-goog
PATCH 2/4 perf lock: Retrieve owner callstack in bpf program
In reply to Chun-Tse ShaoTracing owner callstack in contention_begin() and contention_end(), and storing in owner_lock_stat bpf map.
--- .../perf/util/bpf_skel/lock_contention.bpf.c | 149 +++++++++++++++++- 1 file changed, 148 insertions(+), 1 deletion(-)
tools/perf/util/bpf_skel/lock_contention.bpf.c +148 -1
@@ -7,6 +7,7 @@#include <asm-generic/errno-base.h> #include "lock_data.h" +#include <time.h> /* for collect_lock_syms(). 4096 was rejected by the verifier */ #define MAX_CPUS 1024
@@ -178,6 +179,9 @@ int data_fail;int task_map_full;int data_map_full; +struct task_struct *bpf_task_from_pid (s32 pid) __ksym; +void bpf_task_release(struct task_struct *p) __ksym; +static inline __u64 get_current_cgroup_id (void ) {struct task_struct *task;
@@ -407,6 +411,60 @@ int contention_begin(u64 *ctx) pelem->flags = (__u32 )ctx[1 ];if (needs_callstack) { +u32 i =0 ; +int owner_pid; +unsigned long *entries; +struct task_struct *task; +cotd *data; + +if (!lock_owner) + goto contention_begin_skip_owner_callstack; + + task =get_lock_owner (pelem->lock, pelem->flags); +if (!task) + goto contention_begin_skip_owner_callstack; + + owner_pid =BPF_CORE_READ (task, pid); + + entries =bpf_map_lookup_elem (&owner_stacks_entries, &i); +if (!entries) + goto contention_begin_skip_owner_callstack; +for (i =0 ; i < max_stack; i++) + entries[i] =0x0 ; + + task =bpf_task_from_pid (owner_pid); +if (task) { +bpf_get_task_stack (task, entries, + max_stack *sizeof (unsigned long ), +0 ); +bpf_task_release (task); + } + + data =bpf_map_lookup_elem (&contention_owner_tracing, + &(pelem->lock)); + +// Contention just happens, or corner case `lock` is owned by +// process not `owner_pid`. +if (!data || data->pid != owner_pid) { +cotd first = { + .pid = owner_pid, + .timestamp = pelem->timestamp, + .count =1 , + }; +bpf_map_update_elem (&contention_owner_tracing, + &(pelem->lock), &first,BPF_ANY ); +bpf_map_update_elem (&contention_owner_stacks, + &(pelem->lock), entries,BPF_ANY ); + } +// Contention is going on and new waiter joins. +else { +__sync_fetch_and_add (&data->count,1 ); +// TODO: Since for owner the callstack would change at +// different time, We should check and report if the +// callstack is different with the recorded one in +// `contention_owner_stacks`. + } +contention_begin_skip_owner_callstack: pelem->stack_id =bpf_get_stackid (ctx, &stacks,BPF_F_FAST_STACK_CMP | stack_skip);if (pelem->stack_id <0 )
@@ -443,6 +501,7 @@ int contention_end(u64 *ctx)struct tstamp_data *pelem;struct contention_key key = {};struct contention_data *data; +__u64 timestamp;__u64 duration;bool need_delete = false;
@@ -469,12 +528,100 @@ int contention_end(u64 *ctx)return 0 ; need_delete = true; } - duration =bpf_ktime_get_ns () - pelem->timestamp; + timestamp =bpf_ktime_get_ns (); + duration = timestamp - pelem->timestamp;if ((__s64 )duration <0 ) {__sync_fetch_and_add (&time_fail,1 ); goto out; } +if (needs_callstack && lock_owner) { +u64 owner_contention_time; +unsigned long *owner_stack; +struct contention_data *cdata; +cotd *otdata; + + otdata =bpf_map_lookup_elem (&contention_owner_tracing, + &(pelem->lock)); + owner_stack =bpf_map_lookup_elem (&contention_owner_stacks, + &(pelem->lock)); +if (!otdata || !owner_stack) + goto contention_end_skip_owner_callstack; + + owner_contention_time = timestamp - otdata->timestamp; + +// Update `owner_lock_stat` if `owner_stack` is +// available. +if (owner_stack[0 ] !=0x0 ) { + cdata =bpf_map_lookup_elem (&owner_lock_stat, + owner_stack); +if (!cdata) { +struct contention_data first = { + .total_time = owner_contention_time, + .max_time = owner_contention_time, + .min_time = owner_contention_time, + .count =1 , + .flags = pelem->flags, + }; +bpf_map_update_elem (&owner_lock_stat, + owner_stack, &first, +BPF_ANY ); + }else { +__sync_fetch_and_add (&cdata->total_time, + owner_contention_time); +__sync_fetch_and_add (&cdata->count,1 ); + +/* FIXME: need atomic operations */ +if (cdata->max_time < owner_contention_time) + cdata->max_time = owner_contention_time; +if (cdata->min_time > owner_contention_time) + cdata->min_time = owner_contention_time; + } + } + +// `pid` in `otdata` is not lock owner anymore, delete +// this entry. +bpf_map_delete_elem (&contention_owner_stacks, &(otdata->pid)); + +// No contention is going on, delete `lock` in +// `contention_owner_tracing` and +// `contention_owner_stacks` +if (otdata->count <=1 ) { +bpf_map_delete_elem (&contention_owner_tracing, + &(pelem->lock)); +bpf_map_delete_elem (&contention_owner_stacks, + &(pelem->lock)); + } +// Contention is still going on, with a new owner +// (current task). `otdata` should be updated accordingly. +// If ctx[1] is not 0, the current task terminate lock waiting +// without acquiring it. +else if (ctx[1 ] ==0 ) { +unsigned long *entries; +u32 i =0 ; + + otdata->pid = pid; + otdata->timestamp = timestamp; + (otdata->count)--; +bpf_map_update_elem (&contention_owner_tracing, + &(pelem->lock), otdata,BPF_ANY ); + + entries = +bpf_map_lookup_elem (&owner_stacks_entries, &i); +if (!entries) + goto contention_end_skip_owner_callstack; +for (i =0 ; i < (u32 )max_stack; i++) + entries[i] =0x0 ; + +bpf_get_task_stack (bpf_get_current_task_btf (), entries, + max_stack *sizeof (unsigned long ), +0 ); +bpf_map_update_elem (&contention_owner_stacks, + &(pelem->lock), entries,BPF_ANY ); + } + } +contention_end_skip_owner_callstack: +switch (aggr_mode) {case LOCK_AGGR_CALLER : key.stack_id = pelem->stack_id;
Signature · 1 line
2.47.1.688.g23fc6f90ad-goog
Re: [PATCH v1 2/4] perf lock: Retrieve owner callstack in bpf program
Quoted 149 lines · Chun-Tse Shao
Tracing owner callstack in
contention_begin()andcontention_end(), and storing inowner_lock_statbpf map.Signed-off-by Chun-Tse Shao <[email protected]>--- .../perf/util/bpf_skel/lock_contention.bpf.c | 149 +++++++++++++++++- 1 file changed, 148 insertions(+), 1 deletion(-)tools/perf/util/bpf_skel/lock_contention.bpf.c +98
-1@@ -7,6 +7,7 @@#include <asm-generic/errno-base.h> #include "lock_data.h" +#include <time.h> /* for collect_lock_syms(). 4096 was rejected by the verifier */ #define MAX_CPUS 1024@@ -178,6 +179,9 @@ int data_fail;int task_map_full;int data_map_full; +struct task_struct *bpf_task_from_pid (s32 pid) __ksym; +void bpf_task_release(struct task_struct *p) __ksym; +static inline __u64 get_current_cgroup_id (void ) {struct task_struct *task;@@ -407,6 +411,60 @@ int contention_begin(u64 *ctx) pelem->flags = (__u32 )ctx[1 ];if (needs_callstack) { +u32 i =0 ; +int owner_pid; +unsigned long *entries; +struct task_struct *task; +cotd *data; + +if (!lock_owner) + goto contention_begin_skip_owner_callstack; + + task =get_lock_owner (pelem->lock, pelem->flags); +if (!task) + goto contention_begin_skip_owner_callstack; + + owner_pid =BPF_CORE_READ (task, pid); + + entries =bpf_map_lookup_elem (&owner_stacks_entries, &i); +if (!entries) + goto contention_begin_skip_owner_callstack; +for (i =0 ; i < max_stack; i++) + entries[i] =0x0 ; + + task =bpf_task_from_pid (owner_pid); +if (task) { +bpf_get_task_stack (task, entries, + max_stack *sizeof (unsigned long ), +0 ); +bpf_task_release (task); + } + + data =bpf_map_lookup_elem (&contention_owner_tracing, + &(pelem->lock)); + +// Contention just happens, or corner case `lock` is owned by +// process not `owner_pid`. +if (!data || data->pid != owner_pid) { +cotd first = { + .pid = owner_pid, + .timestamp = pelem->timestamp, + .count =1 , + }; +bpf_map_update_elem (&contention_owner_tracing, + &(pelem->lock), &first,BPF_ANY ); +bpf_map_update_elem (&contention_owner_stacks, + &(pelem->lock), entries,BPF_ANY ); + } +// Contention is going on and new waiter joins. +else { +__sync_fetch_and_add (&data->count,1 ); +// TODO: Since for owner the callstack would change at +// different time, We should check and report if the +// callstack is different with the recorded one in +// `contention_owner_stacks`. + } +contention_begin_skip_owner_callstack: pelem->stack_id =bpf_get_stackid (ctx, &stacks,BPF_F_FAST_STACK_CMP | stack_skip);if (pelem->stack_id <0 )@@ -443,6 +501,7 @@ int contention_end(u64 *ctx)struct tstamp_data *pelem;struct contention_key key = {};struct contention_data *data; +__u64 timestamp;__u64 duration;bool need_delete = false;@@ -469,12 +528,100 @@ int contention_end(u64 *ctx)return 0 ; need_delete = true; } - duration =bpf_ktime_get_ns () - pelem->timestamp; + timestamp =bpf_ktime_get_ns (); + duration = timestamp - pelem->timestamp;if ((__s64 )duration <0 ) {__sync_fetch_and_add (&time_fail,1 ); goto out; } +if (needs_callstack && lock_owner) { +u64 owner_contention_time; +unsigned long *owner_stack; +struct contention_data *cdata; +cotd *otdata; + + otdata =bpf_map_lookup_elem (&contention_owner_tracing, + &(pelem->lock)); + owner_stack =bpf_map_lookup_elem (&contention_owner_stacks, + &(pelem->lock)); +if (!otdata || !owner_stack) + goto contention_end_skip_owner_callstack; + + owner_contention_time = timestamp - otdata->timestamp; + +// Update `owner_lock_stat` if `owner_stack` is +// available. +if (owner_stack[0 ] !=0x0 ) { + cdata =bpf_map_lookup_elem (&owner_lock_stat, + owner_stack); +if (!cdata) { +struct contention_data first = { + .total_time = owner_contention_time, + .max_time = owner_contention_time, + .min_time = owner_contention_time, + .count =1 , + .flags = pelem->flags, + }; +bpf_map_update_elem (&owner_lock_stat, + owner_stack, &first, +BPF_ANY ); + }else { +__sync_fetch_and_add (&cdata->total_time, + owner_contention_time); +__sync_fetch_and_add (&cdata->count,1 ); + +/* FIXME: need atomic operations */
tools/perf/util/bpf_skel/lock_contention.bpf.c int contention_end(u64 *ctx) · line 584
Quoted 10 lines
tools/perf/util/bpf_skel/lock_contention.bpf.c +10
-0+if (cdata->max_time < owner_contention_time) + cdata->max_time = owner_contention_time; +if (cdata->min_time > owner_contention_time) + cdata->min_time = owner_contention_time; + } + } + +// `pid` in `otdata` is not lock owner anymore, delete +// this entry. +bpf_map_delete_elem (&contention_owner_stacks, &(otdata->pid));
I just realized the above three lines are unnecessary and should be deleted, please ignore them and I will fix them in my next patch.
Quoted 27 lines
tools/perf/util/bpf_skel/lock_contention.bpf.c +27
-0+ +// No contention is going on, delete `lock` in +// `contention_owner_tracing` and +// `contention_owner_stacks` +if (otdata->count <=1 ) { +bpf_map_delete_elem (&contention_owner_tracing, + &(pelem->lock)); +bpf_map_delete_elem (&contention_owner_stacks, + &(pelem->lock)); + } +// Contention is still going on, with a new owner +// (current task). `otdata` should be updated accordingly. +// If ctx[1] is not 0, the current task terminate lock waiting +// without acquiring it. +else if (ctx[1 ] ==0 ) { +unsigned long *entries; +u32 i =0 ; + + otdata->pid = pid; + otdata->timestamp = timestamp; + (otdata->count)--; +bpf_map_update_elem (&contention_owner_tracing, + &(pelem->lock), otdata,BPF_ANY ); + + entries = +bpf_map_lookup_elem (&owner_stacks_entries, &i); +if (!entries)
tools/perf/util/bpf_skel/lock_contention.bpf.c int contention_end(u64 *ctx) · line 621
Quoted 10 lines
tools/perf/util/bpf_skel/lock_contention.bpf.c +10
-0+ goto contention_end_skip_owner_callstack; +for (i =0 ; i < (u32 )max_stack; i++) + entries[i] =0x0 ; + +bpf_get_task_stack (bpf_get_current_task_btf (), entries, + max_stack *sizeof (unsigned long ), +0 ); +bpf_map_update_elem (&contention_owner_stacks, + &(pelem->lock), entries,BPF_ANY ); + }
The logic above is a bit flawed. It should be:
// Contention is still going on, with a new owner
// (current task). `otdata` should be updated accordingly.
else {
(otdata->count)--;
// If ctx[1] is not 0, the current task
terminates lock waiting
// without acquiring it. Owner is not changed.
if (ctx[1] == 0) {
u32 i = 0;
otdata->pid = pid;
otdata->timestamp = timestamp;
entries =bpf_map_lookup_elem(&owner_stacks_entries, &i);
if (!entries) {bpf_map_update_elem(&contention_owner_tracing,
&(pelem->lock), otdata, BPF_ANY);
goto
contention_end_skip_owner_callstack;
}
for (i = 0; i < (u32)max_stack; i++)
entries[i] = 0x0;bpf_get_task_stack(bpf_get_current_task_btf(), entries,
max_stack *
sizeof(unsigned long),
0);
bpf_map_update_elem(&contention_owner_stacks,
&(pelem->lock),
entries, BPF_ANY);
}
bpf_map_update_elem(&contention_owner_tracing,
&(pelem->lock), otdata, BPF_ANY);
}I will update this in my next patch.
Quoted 9 lines
tools/perf/util/bpf_skel/lock_contention.bpf.c +3
-1+ } +contention_end_skip_owner_callstack: +switch (aggr_mode) {case LOCK_AGGR_CALLER : key.stack_id = pelem->stack_id; --2.47.1.688.g23fc6f90ad-goog
PATCH 3/4 perf lock: Make rb_tree helper functions generic
In reply to Chun-Tse ShaoThe rb_tree helper functions can be reused for parsing owner_lock_stat into rb tree for sorting.
--- tools/perf/builtin-lock.c | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-)
tools/perf/builtin-lock.c +23 -11
@@ -438,16 +438,13 @@ static void combine_lock_stats(struct lock_stat *st)rb_insert_color (&st->rb, &sorted); } -static void insert_to_result (struct lock_stat *st, -int (*bigger)(struct lock_stat *,struct lock_stat *)) +static void insert_to (struct rb_root *rr,struct lock_stat *st, +int (*bigger)(struct lock_stat *,struct lock_stat *)) { -struct rb_node **rb = &result.rb_node; +struct rb_node **rb = &rr->rb_node;struct rb_node *parent =NULL ;struct lock_stat *p; -if (combine_locks && st->combined) -return ; -while (*rb) { p = container_of(*rb, struct lock_stat, rb); parent = *rb;
@@ -459,13 +456,21 @@ static void insert_to_result(struct lock_stat *st, }rb_link_node (&st->rb, parent, rb); -rb_insert_color (&st->rb, &result); +rb_insert_color (&st->rb, rr); } -/* returns left most element of result, and erase it */ -static struct lock_stat *pop_from_result (void ) +static inline void insert_to_result (struct lock_stat *st, +int (*bigger)(struct lock_stat *, +struct lock_stat *)) +{ +if (combine_locks && st->combined) +return ; +insert_to (&result, st, bigger); +} + +static inline struct lock_stat *pop_from (struct rb_root *rr) { -struct rb_node *node = result.rb_node; +struct rb_node *node = rr->rb_node;if (!node)return NULL ;
@@ -473,8 +478,15 @@ static struct lock_stat *pop_from_result(void)while (node->rb_left) node = node->rb_left; -rb_erase (node, &result); +rb_erase (node, rr); return container_of(node, struct lock_stat, rb); + +} + +/* returns left most element of result, and erase it */ +static struct lock_stat *pop_from_result (void ) +{ +return pop_from (&result); }struct lock_stat *lock_stat_find (u64 addr)
Signature · 1 line
2.47.1.688.g23fc6f90ad-goog
PATCH 4/4 perf lock: Report owner stack in usermode
In reply to Chun-Tse ShaoParse owner_lock_stat into a rb tree, and report owner lock stats with stack trace in order.
Example output:
$ sudo ~/linux/tools/perf/perf lock con -abvo -Y mutex-spin -E3 perf bench sched pipe ... contended total wait max wait avg wait type caller
171 1.55 ms 20.26 us 9.06 us mutex pipe_read+0x57
0xffffffffac6318e7 pipe_read+0x57
0xffffffffac623862 vfs_read+0x332
0xffffffffac62434b ksys_read+0xbb
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76
36 193.71 us 15.27 us 5.38 us mutex pipe_write+0x50
0xffffffffac631ee0 pipe_write+0x50
0xffffffffac6241db vfs_write+0x3bb
0xffffffffac6244ab ksys_write+0xbb
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76
4 51.22 us 16.47 us 12.80 us mutex do_epoll_wait+0x24d
0xffffffffac691f0d do_epoll_wait+0x24d
0xffffffffac69249b do_epoll_pwait.part.0+0xb
0xffffffffac693ba5 __x64_sys_epoll_pwait+0x95
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76=== owner stack trace ===
3 31.24 us 15.27 us 10.41 us mutex pipe_read+0x348
0xffffffffac631bd8 pipe_read+0x348
0xffffffffac623862 vfs_read+0x332
0xffffffffac62434b ksys_read+0xbb
0xfffffffface604b2 do_syscall_64+0x82
0xffffffffad00012f entry_SYSCALL_64_after_hwframe+0x76...
--- tools/perf/builtin-lock.c | 21 +++++++++++++- tools/perf/util/bpf_lock_contention.c | 41 +++++++++++++++++++++++++++ tools/perf/util/lock-contention.h | 2 ++ 3 files changed, 63 insertions(+), 1 deletion(-)
tools/perf/builtin-lock.c +20 -1
@@ -42,6 +42,7 @@#include <linux/zalloc.h> #include <linux/err.h> #include <linux/stringify.h> +#include <linux/rbtree.h> static struct perf_session *session;static struct target target;
@@ -1926,6 +1927,24 @@ static void print_contention_result(struct lock_contention *con)break ; } +if (con->owner && con->save_callstack) { +struct rb_root root =RB_ROOT ; + + +if (symbol_conf.field_sep) +fprintf (lock_output,"# owner stack trace:\n" ); +else +fprintf (lock_output,"\n=== owner stack trace ===\n\n" ); +while ((st =pop_owner_stack_trace (con))) { +insert_to (&root, st, compare); + } + +while ((st =pop_from (&root))) { +print_lock_stat (con, st); +zfree (st); + } + } +if (print_nr_entries) {/* update the total/bad stats */ while ((st =pop_from_result ())) {
@@ -2071,7 +2090,7 @@ static int check_lock_contention_options(const struct option *options, } } -if (show_lock_owner) +if (show_lock_owner && !verbose) show_thread_stats = true;return 0 ;
tools/perf/util/bpf_lock_contention.c +41 -0
47 lines not on this page · raw message
tools/perf/util/lock-contention.h +2 -0
@@ -156,6 +156,8 @@ int lock_contention_stop(void);int lock_contention_read (struct lock_contention *con);int lock_contention_finish (struct lock_contention *con); +struct lock_stat *pop_owner_stack_trace (struct lock_contention *con); +#else /* !HAVE_BPF_SKEL */ static inline int lock_contention_prepare (struct lock_contention *con__maybe_unused )
Signature · 1 line
2.47.1.688.g23fc6f90ad-goog