1
linux/tools/perf/util/bpf_skel/kwork_top.bpf.c
Namhyung Kim 066fd84087 perf kwork: Constify control data for BPF
The control knobs set before loading BPF programs should be declared as
'const volatile' so that it can be optimized by the BPF core.

Committer testing:

  root@x1:~# perf kwork report --use-bpf
  Starting trace, Hit <Ctrl+C> to stop and report
  ^C
    Kwork Name                     | Cpu  | Total Runtime | Count     | Max runtime   | Max runtime start   | Max runtime end     |
   --------------------------------------------------------------------------------------------------------------------------------
    (w)intel_atomic_commit_work [  | 0009 |     18.680 ms |         2 |     18.553 ms |     362410.681580 s |     362410.700133 s |
    (w)pm_runtime_work             | 0007 |     13.300 ms |         1 |     13.300 ms |     362410.254996 s |     362410.268295 s |
    (w)intel_atomic_commit_work [  | 0009 |      9.846 ms |         2 |      9.717 ms |     362410.172352 s |     362410.182069 s |
    (w)acpi_ec_event_processor     | 0002 |      8.106 ms |         1 |      8.106 ms |     362410.463187 s |     362410.471293 s |
    (s)SCHED:7                     | 0000 |      1.351 ms |       106 |      0.063 ms |     362410.658017 s |     362410.658080 s |
    i915:157                       | 0008 |      0.994 ms |        13 |      0.361 ms |     362411.222125 s |     362411.222486 s |
    (s)SCHED:7                     | 0001 |      0.703 ms |        98 |      0.047 ms |     362410.245004 s |     362410.245051 s |
    (s)SCHED:7                     | 0005 |      0.674 ms |        42 |      0.074 ms |     362411.483039 s |     362411.483113 s |
    (s)NET_RX:3                    | 0001 |      0.556 ms |        10 |      0.079 ms |     362411.066388 s |     362411.066467 s |
  <SNIP>

  root@x1:~# perf trace -e bpf --max-events 5 perf kwork report --use-bpf
       0.000 ( 0.016 ms): perf/2948007 bpf(cmd: 36, uattr: 0x7ffededa6660, size: 8)          = -1 EOPNOTSUPP (Operation not supported)
       0.026 ( 0.106 ms): perf/2948007 bpf(cmd: PROG_LOAD, uattr: 0x7ffededa6390, size: 148) = 12
       0.152 ( 0.032 ms): perf/2948007 bpf(cmd: PROG_LOAD, uattr: 0x7ffededa6450, size: 148) = 12
      26.247 ( 0.138 ms): perf/2948007 bpf(cmd: PROG_LOAD, uattr: 0x7ffededa6300, size: 148) = 12
      26.396 ( 0.012 ms): perf/2948007 bpf(uattr: 0x7ffededa64b0, size: 80)                  = 12
  Starting trace, Hit <Ctrl+C> to stop and report
  root@x1:~#

Signed-off-by: Namhyung Kim <namhyung@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Song Liu <song@kernel.org>
Cc: Yang Jihong <yangjihong@bytedance.com>
Link: https://lore.kernel.org/r/20240902200515.2103769-4-namhyung@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2024-09-03 11:50:20 -03:00

339 lines
6.2 KiB
C

// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
// Copyright (c) 2022, Huawei
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#include <bpf/bpf_core_read.h>
/*
* This should be in sync with "util/kwork.h"
*/
enum kwork_class_type {
KWORK_CLASS_IRQ,
KWORK_CLASS_SOFTIRQ,
KWORK_CLASS_WORKQUEUE,
KWORK_CLASS_SCHED,
KWORK_CLASS_MAX,
};
#define MAX_ENTRIES 102400
#define MAX_NR_CPUS 2048
#define PF_KTHREAD 0x00200000
#define MAX_COMMAND_LEN 16
struct time_data {
__u64 timestamp;
};
struct work_data {
__u64 runtime;
};
struct task_data {
__u32 tgid;
__u32 is_kthread;
char comm[MAX_COMMAND_LEN];
};
struct work_key {
__u32 type;
__u32 pid;
__u64 task_p;
};
struct task_key {
__u32 pid;
__u32 cpu;
};
struct {
__uint(type, BPF_MAP_TYPE_TASK_STORAGE);
__uint(map_flags, BPF_F_NO_PREALLOC);
__type(key, int);
__type(value, struct time_data);
} kwork_top_task_time SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_PERCPU_HASH);
__uint(key_size, sizeof(struct work_key));
__uint(value_size, sizeof(struct time_data));
__uint(max_entries, MAX_ENTRIES);
} kwork_top_irq_time SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__uint(key_size, sizeof(struct task_key));
__uint(value_size, sizeof(struct task_data));
__uint(max_entries, MAX_ENTRIES);
} kwork_top_tasks SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_PERCPU_HASH);
__uint(key_size, sizeof(struct work_key));
__uint(value_size, sizeof(struct work_data));
__uint(max_entries, MAX_ENTRIES);
} kwork_top_works SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__uint(key_size, sizeof(u32));
__uint(value_size, sizeof(u8));
__uint(max_entries, MAX_NR_CPUS);
} kwork_top_cpu_filter SEC(".maps");
int enabled = 0;
const volatile int has_cpu_filter = 0;
__u64 from_timestamp = 0;
__u64 to_timestamp = 0;
static __always_inline int cpu_is_filtered(__u32 cpu)
{
__u8 *cpu_val;
if (has_cpu_filter) {
cpu_val = bpf_map_lookup_elem(&kwork_top_cpu_filter, &cpu);
if (!cpu_val)
return 1;
}
return 0;
}
static __always_inline void update_task_info(struct task_struct *task, __u32 cpu)
{
struct task_key key = {
.pid = task->pid,
.cpu = cpu,
};
if (!bpf_map_lookup_elem(&kwork_top_tasks, &key)) {
struct task_data data = {
.tgid = task->tgid,
.is_kthread = task->flags & PF_KTHREAD ? 1 : 0,
};
BPF_CORE_READ_STR_INTO(&data.comm, task, comm);
bpf_map_update_elem(&kwork_top_tasks, &key, &data, BPF_ANY);
}
}
static __always_inline void update_work(struct work_key *key, __u64 delta)
{
struct work_data *data;
data = bpf_map_lookup_elem(&kwork_top_works, key);
if (data) {
data->runtime += delta;
} else {
struct work_data new_data = {
.runtime = delta,
};
bpf_map_update_elem(&kwork_top_works, key, &new_data, BPF_ANY);
}
}
static void on_sched_out(struct task_struct *task, __u64 ts, __u32 cpu)
{
__u64 delta;
struct time_data *pelem;
pelem = bpf_task_storage_get(&kwork_top_task_time, task, NULL, 0);
if (pelem)
delta = ts - pelem->timestamp;
else
delta = ts - from_timestamp;
struct work_key key = {
.type = KWORK_CLASS_SCHED,
.pid = task->pid,
.task_p = (__u64)task,
};
update_work(&key, delta);
update_task_info(task, cpu);
}
static void on_sched_in(struct task_struct *task, __u64 ts)
{
struct time_data *pelem;
pelem = bpf_task_storage_get(&kwork_top_task_time, task, NULL,
BPF_LOCAL_STORAGE_GET_F_CREATE);
if (pelem)
pelem->timestamp = ts;
}
SEC("tp_btf/sched_switch")
int on_switch(u64 *ctx)
{
struct task_struct *prev, *next;
prev = (struct task_struct *)ctx[1];
next = (struct task_struct *)ctx[2];
if (!enabled)
return 0;
__u32 cpu = bpf_get_smp_processor_id();
if (cpu_is_filtered(cpu))
return 0;
__u64 ts = bpf_ktime_get_ns();
on_sched_out(prev, ts, cpu);
on_sched_in(next, ts);
return 0;
}
SEC("tp_btf/irq_handler_entry")
int on_irq_handler_entry(u64 *cxt)
{
struct task_struct *task;
if (!enabled)
return 0;
__u32 cpu = bpf_get_smp_processor_id();
if (cpu_is_filtered(cpu))
return 0;
__u64 ts = bpf_ktime_get_ns();
task = (struct task_struct *)bpf_get_current_task();
if (!task)
return 0;
struct work_key key = {
.type = KWORK_CLASS_IRQ,
.pid = BPF_CORE_READ(task, pid),
.task_p = (__u64)task,
};
struct time_data data = {
.timestamp = ts,
};
bpf_map_update_elem(&kwork_top_irq_time, &key, &data, BPF_ANY);
return 0;
}
SEC("tp_btf/irq_handler_exit")
int on_irq_handler_exit(u64 *cxt)
{
__u64 delta;
struct task_struct *task;
struct time_data *pelem;
if (!enabled)
return 0;
__u32 cpu = bpf_get_smp_processor_id();
if (cpu_is_filtered(cpu))
return 0;
__u64 ts = bpf_ktime_get_ns();
task = (struct task_struct *)bpf_get_current_task();
if (!task)
return 0;
struct work_key key = {
.type = KWORK_CLASS_IRQ,
.pid = BPF_CORE_READ(task, pid),
.task_p = (__u64)task,
};
pelem = bpf_map_lookup_elem(&kwork_top_irq_time, &key);
if (pelem && pelem->timestamp != 0)
delta = ts - pelem->timestamp;
else
delta = ts - from_timestamp;
update_work(&key, delta);
return 0;
}
SEC("tp_btf/softirq_entry")
int on_softirq_entry(u64 *cxt)
{
struct task_struct *task;
if (!enabled)
return 0;
__u32 cpu = bpf_get_smp_processor_id();
if (cpu_is_filtered(cpu))
return 0;
__u64 ts = bpf_ktime_get_ns();
task = (struct task_struct *)bpf_get_current_task();
if (!task)
return 0;
struct work_key key = {
.type = KWORK_CLASS_SOFTIRQ,
.pid = BPF_CORE_READ(task, pid),
.task_p = (__u64)task,
};
struct time_data data = {
.timestamp = ts,
};
bpf_map_update_elem(&kwork_top_irq_time, &key, &data, BPF_ANY);
return 0;
}
SEC("tp_btf/softirq_exit")
int on_softirq_exit(u64 *cxt)
{
__u64 delta;
struct task_struct *task;
struct time_data *pelem;
if (!enabled)
return 0;
__u32 cpu = bpf_get_smp_processor_id();
if (cpu_is_filtered(cpu))
return 0;
__u64 ts = bpf_ktime_get_ns();
task = (struct task_struct *)bpf_get_current_task();
if (!task)
return 0;
struct work_key key = {
.type = KWORK_CLASS_SOFTIRQ,
.pid = BPF_CORE_READ(task, pid),
.task_p = (__u64)task,
};
pelem = bpf_map_lookup_elem(&kwork_top_irq_time, &key);
if (pelem)
delta = ts - pelem->timestamp;
else
delta = ts - from_timestamp;
update_work(&key, delta);
return 0;
}
char LICENSE[] SEC("license") = "Dual BSD/GPL";