tools/perf/util/bpf_skel/func_latency.bpf.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 // Copyright (c) 2021 Google
   3 #include "vmlinux.h"
   4 #include <bpf/bpf_helpers.h>
   5 #include <bpf/bpf_tracing.h>
   6
   7 // This should be in sync with "util/ftrace.h"
   8 #define NUM_BUCKET  22
   9
  10 struct {
  11         __uint(type, BPF_MAP_TYPE_HASH);
  12         __uint(key_size, sizeof(__u64));
  13         __uint(value_size, sizeof(__u64));
  14         __uint(max_entries, 10000);
  15 } functime SEC(".maps");
  16
  17 struct {
  18         __uint(type, BPF_MAP_TYPE_HASH);
  19         __uint(key_size, sizeof(__u32));
  20         __uint(value_size, sizeof(__u8));
  21         __uint(max_entries, 1);
  22 } cpu_filter SEC(".maps");
  23
  24 struct {
  25         __uint(type, BPF_MAP_TYPE_HASH);
  26         __uint(key_size, sizeof(__u32));
  27         __uint(value_size, sizeof(__u8));
  28         __uint(max_entries, 1);
  29 } task_filter SEC(".maps");
  30
  31 struct {
  32         __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
  33         __uint(key_size, sizeof(__u32));
  34         __uint(value_size, sizeof(__u64));
  35         __uint(max_entries, NUM_BUCKET);
  36 } latency SEC(".maps");
  37
  38
  39 int enabled = 0;
  40 int has_cpu = 0;
  41 int has_task = 0;
  42 int use_nsec = 0;
  43
  44 SEC("kprobe/func")
  45 int BPF_PROG(func_begin)
  46 {
  47         __u64 key, now;
  48
  49         if (!enabled)
  50                 return 0;
  51
  52         key = bpf_get_current_pid_tgid();
  53
  54         if (has_cpu) {
  55                 __u32 cpu = bpf_get_smp_processor_id();
  56                 __u8 *ok;
  57
  58                 ok = bpf_map_lookup_elem(&cpu_filter, &cpu);
  59                 if (!ok)
  60                         return 0;
  61         }
  62
  63         if (has_task) {
  64                 __u32 pid = key & 0xffffffff;
  65                 __u8 *ok;
  66
  67                 ok = bpf_map_lookup_elem(&task_filter, &pid);
  68                 if (!ok)
  69                         return 0;
  70         }
  71
  72         now = bpf_ktime_get_ns();
  73
  74         // overwrite timestamp for nested functions
  75         bpf_map_update_elem(&functime, &key, &now, BPF_ANY);
  76         return 0;
  77 }
  78
  79 SEC("kretprobe/func")
  80 int BPF_PROG(func_end)
  81 {
  82         __u64 tid;
  83         __u64 *start;
  84         __u64 cmp_base = use_nsec ? 1 : 1000;
  85
  86         if (!enabled)
  87                 return 0;
  88
  89         tid = bpf_get_current_pid_tgid();
  90
  91         start = bpf_map_lookup_elem(&functime, &tid);
  92         if (start) {
  93                 __s64 delta = bpf_ktime_get_ns() - *start;
  94                 __u32 key;
  95                 __u64 *hist;
  96
  97                 bpf_map_delete_elem(&functime, &tid);
  98
  99                 if (delta < 0)
 100                         return 0;
 101
 102                 // calculate index using delta
 103                 for (key = 0; key < (NUM_BUCKET - 1); key++) {
 104                         if (delta < (cmp_base << key))
 105                                 break;
 106                 }
 107
 108                 hist = bpf_map_lookup_elem(&latency, &key);
 109                 if (!hist)
 110                         return 0;
 111
 112                 *hist += 1;
 113         }
 114
 115         return 0;
 116 }