// 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>
#define KWORK_COUNT 100
#define MAX_KWORKNAME 128
/*
* This should be in sync with "util/kwork.h"
*/
enum kwork_class_type {
KWORK_CLASS_IRQ,
KWORK_CLASS_SOFTIRQ,
KWORK_CLASS_WORKQUEUE,
KWORK_CLASS_MAX,
};
struct work_key {
__u32 type;
__u32 cpu;
__u64 id;
};
struct report_data {
__u64 nr;
__u64 total_time;
__u64 max_time;
__u64 max_time_start;
__u64 max_time_end;
};
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__uint(key_size, sizeof(struct work_key));
__uint(value_size, MAX_KWORKNAME);
__uint(max_entries, KWORK_COUNT);
} perf_kwork_names SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__uint(key_size, sizeof(struct work_key));
__uint(value_size, sizeof(__u64));
__uint(max_entries, KWORK_COUNT);
} perf_kwork_time SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__uint(key_size, sizeof(struct work_key));
__uint(value_size, sizeof(struct report_data));
__uint(max_entries, KWORK_COUNT);
} perf_kwork_report SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__uint(key_size, sizeof(__u32));
__uint(value_size, sizeof(__u8));
__uint(max_entries, 1);
} perf_kwork_cpu_filter SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_ARRAY);
__uint(key_size, sizeof(__u32));
__uint(value_size, MAX_KWORKNAME);
__uint(max_entries, 1);
} perf_kwork_name_filter SEC(".maps");
int enabled = 0;
const volatile int has_cpu_filter = 0;
const volatile int has_name_filter = 0;
static __always_inline int local_strncmp(const char *s1,
unsigned int sz, const char *s2)
{
int ret = 0;
unsigned int i;
for (i = 0; i < sz; i++) {
ret = (unsigned char)s1[i] - (unsigned char)s2[i];
if (ret || !s1[i] || !s2[i])
break;
}
return ret;
}
static __always_inline int trace_event_match(struct work_key *key, char *name)
{
__u8 *cpu_val;
char *name_val;
__u32 zero = 0;
__u32 cpu = bpf_get_smp_processor_id();
if (!enabled)
return 0;
if (has_cpu_filter) {
cpu_val = bpf_map_lookup_elem(&perf_kwork_cpu_filter, &cpu);
if (!cpu_val)
return 0;
}
if (has_name_filter && (name != NULL)) {
name_val = bpf_map_lookup_elem(&perf_kwork_name_filter, &zero);
if (name_val &&
(local_strncmp(name_val, MAX_KWORKNAME, name) != 0)) {
return 0;
}
}
return 1;
}
static __always_inline void do_update_time(void *map, struct work_key *key,
__u64 time_start, __u64 time_end)
{
struct report_data zero, *data;
__s64 delta = time_end - time_start;
if (delta < 0)
return;
data = bpf_map_lookup_elem(map, key);
if (!data) {
__builtin_memset(&zero, 0, sizeof(zero));
bpf_map_update_elem(map, key, &zero, BPF_NOEXIST);
data = bpf_map_lookup_elem(map, key);
if (!data)
return;
}
if ((delta > data->max_time) ||
(data->max_time == 0)) {
data->max_time = delta;
data->max_time_start = time_start;
data->max_time_end = time_end;
}
data->total_time += delta;
data->nr++;
}
static __always_inline void do_update_timestart(void *map, struct work_key *key)
{
__u64 ts = bpf_ktime_get_ns();
bpf_map_update_elem(map, key, &ts, BPF_ANY);
}
static __always_inline void do_update_timeend(void *report_map, void *time_map,
struct work_key *key)
{
__u64 *time = bpf_map_lookup_elem(time_map, key);
if (time) {
bpf_map_delete_elem(time_map, key);
do_update_time(report_map, key, *time, bpf_ktime_get_ns());
}
}
static __always_inline void do_update_name(void *map,
struct work_key *key, char *name)
{
if (!bpf_map_lookup_elem(map, key))
bpf_map_update_elem(map, key, name, BPF_ANY);
}
static __always_inline int update_timestart(void *map, struct work_key *key)
{
if (!trace_event_match(key, NULL))
return 0;
do_update_timestart(map, key);
return 0;
}
static __always_inline int update_timestart_and_name(void *time_map,
void *names_map,
struct work_key *key,
char *name)
{
if (!trace_event_match(key, name))
return 0;
do_update_timestart(time_map, key);
do_update_name(names_map, key, name);
return 0;
}
static __always_inline int update_timeend(void *report_map,
void *time_map, struct work_key *key)
{
if (!trace_event_match(key, NULL))
return 0;
do_update_timeend(report_map, time_map, key);
return 0;
}
static __always_inline int update_timeend_and_name(void *report_map,
void *time_map,
void *names_map,
struct work_key *key,
char *name)
{
if (!trace_event_match(key, name))
return 0;
do_update_timeend(report_map, time_map, key);
do_update_name(names_map, key, name);
return 0;
}
SEC("tracepoint/irq/irq_handler_entry")
int report_irq_handler_entry(struct trace_event_raw_irq_handler_entry *ctx)
{
char name[MAX_KWORKNAME];
struct work_key key = {
.type = KWORK_CLASS_IRQ,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)ctx->irq,
};
void *name_addr = (void *)ctx + (ctx->__data_loc_name & 0xffff);
bpf_probe_read_kernel_str(name, sizeof(name), name_addr);
return update_timestart_and_name(&perf_kwork_time,
&perf_kwork_names, &key, name);
}
SEC("tracepoint/irq/irq_handler_exit")
int report_irq_handler_exit(struct trace_event_raw_irq_handler_exit *ctx)
{
struct work_key key = {
.type = KWORK_CLASS_IRQ,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)ctx->irq,
};
return update_timeend(&perf_kwork_report, &perf_kwork_time, &key);
}
static char softirq_name_list[NR_SOFTIRQS][MAX_KWORKNAME] = {
{ "HI" },
{ "TIMER" },
{ "NET_TX" },
{ "NET_RX" },
{ "BLOCK" },
{ "IRQ_POLL" },
{ "TASKLET" },
{ "SCHED" },
{ "HRTIMER" },
{ "RCU" },
};
SEC("tracepoint/irq/softirq_entry")
int report_softirq_entry(struct trace_event_raw_softirq *ctx)
{
unsigned int vec = ctx->vec;
struct work_key key = {
.type = KWORK_CLASS_SOFTIRQ,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)vec,
};
if (vec < NR_SOFTIRQS) {
return update_timestart_and_name(&perf_kwork_time,
&perf_kwork_names, &key,
softirq_name_list[vec]);
}
return 0;
}
SEC("tracepoint/irq/softirq_exit")
int report_softirq_exit(struct trace_event_raw_softirq *ctx)
{
struct work_key key = {
.type = KWORK_CLASS_SOFTIRQ,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)ctx->vec,
};
return update_timeend(&perf_kwork_report, &perf_kwork_time, &key);
}
SEC("tracepoint/irq/softirq_raise")
int latency_softirq_raise(struct trace_event_raw_softirq *ctx)
{
unsigned int vec = ctx->vec;
struct work_key key = {
.type = KWORK_CLASS_SOFTIRQ,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)vec,
};
if (vec < NR_SOFTIRQS) {
return update_timestart_and_name(&perf_kwork_time,
&perf_kwork_names, &key,
softirq_name_list[vec]);
}
return 0;
}
SEC("tracepoint/irq/softirq_entry")
int latency_softirq_entry(struct trace_event_raw_softirq *ctx)
{
struct work_key key = {
.type = KWORK_CLASS_SOFTIRQ,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)ctx->vec,
};
return update_timeend(&perf_kwork_report, &perf_kwork_time, &key);
}
SEC("tracepoint/workqueue/workqueue_execute_start")
int report_workqueue_execute_start(struct trace_event_raw_workqueue_execute_start *ctx)
{
struct work_key key = {
.type = KWORK_CLASS_WORKQUEUE,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)ctx->work,
};
return update_timestart(&perf_kwork_time, &key);
}
SEC("tracepoint/workqueue/workqueue_execute_end")
int report_workqueue_execute_end(struct trace_event_raw_workqueue_execute_end *ctx)
{
char name[MAX_KWORKNAME];
struct work_key key = {
.type = KWORK_CLASS_WORKQUEUE,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)ctx->work,
};
unsigned long long func_addr = (unsigned long long)ctx->function;
__builtin_memset(name, 0, sizeof(name));
bpf_snprintf(name, sizeof(name), "%ps", &func_addr, sizeof(func_addr));
return update_timeend_and_name(&perf_kwork_report, &perf_kwork_time,
&perf_kwork_names, &key, name);
}
SEC("tracepoint/workqueue/workqueue_activate_work")
int latency_workqueue_activate_work(struct trace_event_raw_workqueue_activate_work *ctx)
{
struct work_key key = {
.type = KWORK_CLASS_WORKQUEUE,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)ctx->work,
};
return update_timestart(&perf_kwork_time, &key);
}
SEC("tracepoint/workqueue/workqueue_execute_start")
int latency_workqueue_execute_start(struct trace_event_raw_workqueue_execute_start *ctx)
{
char name[MAX_KWORKNAME];
struct work_key key = {
.type = KWORK_CLASS_WORKQUEUE,
.cpu = bpf_get_smp_processor_id(),
.id = (__u64)ctx->work,
};
unsigned long long func_addr = (unsigned long long)ctx->function;
__builtin_memset(name, 0, sizeof(name));
bpf_snprintf(name, sizeof(name), "%ps", &func_addr, sizeof(func_addr));
return update_timeend_and_name(&perf_kwork_report, &perf_kwork_time,
&perf_kwork_names, &key, name);
}
char LICENSE[] SEC("license") = "Dual BSD/GPL";