mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-15 23:14:31 +08:00
407b36f69e
Add -b/--use-bpf option to use BPF to collect lock contention stats.
For simplicity it now runs system-wide and requires C-c to stop.
Upcoming changes will add the usual filtering.
$ sudo perf lock con -b
^C
contended total wait max wait avg wait type caller
42 192.67 us 13.64 us 4.59 us spinlock queue_work_on+0x20
23 85.54 us 10.28 us 3.72 us spinlock worker_thread+0x14a
6 13.92 us 6.51 us 2.32 us mutex kernfs_iop_permission+0x30
3 11.59 us 10.04 us 3.86 us mutex kernfs_dop_revalidate+0x3c
1 7.52 us 7.52 us 7.52 us spinlock kthread+0x115
1 7.24 us 7.24 us 7.24 us rwlock:W sys_epoll_wait+0x148
2 7.08 us 3.99 us 3.54 us spinlock delayed_work_timer_fn+0x1b
1 6.41 us 6.41 us 6.41 us spinlock idle_balance+0xa06
2 2.50 us 1.83 us 1.25 us mutex kernfs_iop_lookup+0x2f
1 1.71 us 1.71 us 1.71 us mutex kernfs_iop_getattr+0x2c
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
Cc: Blake Jones <blakejones@google.com>
Cc: Boqun Feng <boqun.feng@gmail.com>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Ian Rogers <irogers@google.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Waiman Long <longman@redhat.com>
Cc: Will Deacon <will@kernel.org>
Link: https://lore.kernel.org/r/20220729200756.666106-3-namhyung@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
133 lines
2.6 KiB
C
133 lines
2.6 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include "util/debug.h"
|
|
#include "util/machine.h"
|
|
#include "util/map.h"
|
|
#include "util/symbol.h"
|
|
#include "util/lock-contention.h"
|
|
#include <linux/zalloc.h>
|
|
#include <bpf/bpf.h>
|
|
|
|
#include "bpf_skel/lock_contention.skel.h"
|
|
|
|
static struct lock_contention_bpf *skel;
|
|
|
|
/* should be same as bpf_skel/lock_contention.bpf.c */
|
|
struct lock_contention_key {
|
|
u32 stack_id;
|
|
};
|
|
|
|
struct lock_contention_data {
|
|
u64 total_time;
|
|
u64 min_time;
|
|
u64 max_time;
|
|
u32 count;
|
|
u32 flags;
|
|
};
|
|
|
|
int lock_contention_prepare(void)
|
|
{
|
|
skel = lock_contention_bpf__open();
|
|
if (!skel) {
|
|
pr_err("Failed to open lock-contention BPF skeleton\n");
|
|
return -1;
|
|
}
|
|
|
|
if (lock_contention_bpf__load(skel) < 0) {
|
|
pr_err("Failed to load lock-contention BPF skeleton\n");
|
|
return -1;
|
|
}
|
|
|
|
lock_contention_bpf__attach(skel);
|
|
return 0;
|
|
}
|
|
|
|
int lock_contention_start(void)
|
|
{
|
|
skel->bss->enabled = 1;
|
|
return 0;
|
|
}
|
|
|
|
int lock_contention_stop(void)
|
|
{
|
|
skel->bss->enabled = 0;
|
|
return 0;
|
|
}
|
|
|
|
int lock_contention_read(struct machine *machine, struct hlist_head *head)
|
|
{
|
|
int fd, stack;
|
|
u32 prev_key, key;
|
|
struct lock_contention_data data;
|
|
struct lock_stat *st;
|
|
u64 stack_trace[CONTENTION_STACK_DEPTH];
|
|
|
|
fd = bpf_map__fd(skel->maps.lock_stat);
|
|
stack = bpf_map__fd(skel->maps.stacks);
|
|
|
|
prev_key = 0;
|
|
while (!bpf_map_get_next_key(fd, &prev_key, &key)) {
|
|
struct map *kmap;
|
|
struct symbol *sym;
|
|
int idx;
|
|
|
|
bpf_map_lookup_elem(fd, &key, &data);
|
|
st = zalloc(sizeof(*st));
|
|
if (st == NULL)
|
|
return -1;
|
|
|
|
st->nr_contended = data.count;
|
|
st->wait_time_total = data.total_time;
|
|
st->wait_time_max = data.max_time;
|
|
st->wait_time_min = data.min_time;
|
|
|
|
if (data.count)
|
|
st->avg_wait_time = data.total_time / data.count;
|
|
|
|
st->flags = data.flags;
|
|
|
|
bpf_map_lookup_elem(stack, &key, stack_trace);
|
|
|
|
/* skip BPF + lock internal functions */
|
|
idx = CONTENTION_STACK_SKIP;
|
|
while (is_lock_function(machine, stack_trace[idx]) &&
|
|
idx < CONTENTION_STACK_DEPTH - 1)
|
|
idx++;
|
|
|
|
st->addr = stack_trace[idx];
|
|
sym = machine__find_kernel_symbol(machine, st->addr, &kmap);
|
|
|
|
if (sym) {
|
|
unsigned long offset;
|
|
int ret = 0;
|
|
|
|
offset = kmap->map_ip(kmap, st->addr) - sym->start;
|
|
|
|
if (offset)
|
|
ret = asprintf(&st->name, "%s+%#lx", sym->name, offset);
|
|
else
|
|
st->name = strdup(sym->name);
|
|
|
|
if (ret < 0 || st->name == NULL)
|
|
return -1;
|
|
} else if (asprintf(&st->name, "%#lx", (unsigned long)st->addr) < 0) {
|
|
free(st);
|
|
return -1;
|
|
}
|
|
|
|
hlist_add_head(&st->hash_entry, head);
|
|
prev_key = key;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int lock_contention_finish(void)
|
|
{
|
|
if (skel) {
|
|
skel->bss->enabled = 0;
|
|
lock_contention_bpf__destroy(skel);
|
|
}
|
|
|
|
return 0;
|
|
}
|