1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 // Copyright (c) 2020 Facebook 3 #include <vmlinux.h> 4 #include <bpf/bpf_helpers.h> 5 #include <bpf/bpf_tracing.h> 6 7 struct bpf_perf_event_value___local { 8 __u64 counter; 9 __u64 enabled; 10 __u64 running; 11 } __attribute__((preserve_access_index)); 12 13 /* map of perf event fds, num_cpu * num_metric entries */ 14 struct { 15 __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); 16 __uint(key_size, sizeof(u32)); 17 __uint(value_size, sizeof(int)); 18 } events SEC(".maps"); 19 20 /* readings at fentry */ 21 struct { 22 __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY); 23 __uint(key_size, sizeof(u32)); 24 __uint(value_size, sizeof(struct bpf_perf_event_value___local)); 25 } fentry_readings SEC(".maps"); 26 27 /* accumulated readings */ 28 struct { 29 __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY); 30 __uint(key_size, sizeof(u32)); 31 __uint(value_size, sizeof(struct bpf_perf_event_value___local)); 32 } accum_readings SEC(".maps"); 33 34 /* sample counts, one per cpu */ 35 struct { 36 __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY); 37 __uint(key_size, sizeof(u32)); 38 __uint(value_size, sizeof(u64)); 39 } counts SEC(".maps"); 40 41 const volatile __u32 num_cpu = 1; 42 const volatile __u32 num_metric = 1; 43 #define MAX_NUM_METRICS 4 44 45 SEC("fentry/XXX") 46 int BPF_PROG(fentry_XXX) 47 { 48 struct bpf_perf_event_value___local *ptrs[MAX_NUM_METRICS]; 49 u32 key = bpf_get_smp_processor_id(); 50 u32 i; 51 52 /* look up before reading, to reduce error */ 53 for (i = 0; i < num_metric && i < MAX_NUM_METRICS; i++) { 54 u32 flag = i; 55 56 ptrs[i] = bpf_map_lookup_elem(&fentry_readings, &flag); 57 if (!ptrs[i]) 58 return 0; 59 } 60 61 for (i = 0; i < num_metric && i < MAX_NUM_METRICS; i++) { 62 struct bpf_perf_event_value___local reading; 63 int err; 64 65 err = bpf_perf_event_read_value(&events, key, (void *)&reading, 66 sizeof(reading)); 67 if (err) 68 return 0; 69 *(ptrs[i]) = reading; 70 key += num_cpu; 71 } 72 73 return 0; 74 } 75 76 static inline void 77 fexit_update_maps(u32 id, struct bpf_perf_event_value___local *after) 78 { 79 struct bpf_perf_event_value___local *before, diff; 80 81 before = bpf_map_lookup_elem(&fentry_readings, &id); 82 /* only account samples with a valid fentry_reading */ 83 if (before && before->counter) { 84 struct bpf_perf_event_value___local *accum; 85 86 diff.counter = after->counter - before->counter; 87 diff.enabled = after->enabled - before->enabled; 88 diff.running = after->running - before->running; 89 90 accum = bpf_map_lookup_elem(&accum_readings, &id); 91 if (accum) { 92 accum->counter += diff.counter; 93 accum->enabled += diff.enabled; 94 accum->running += diff.running; 95 } 96 } 97 } 98 99 SEC("fexit/XXX") 100 int BPF_PROG(fexit_XXX) 101 { 102 struct bpf_perf_event_value___local readings[MAX_NUM_METRICS]; 103 u32 cpu = bpf_get_smp_processor_id(); 104 u32 i, zero = 0; 105 int err; 106 u64 *count; 107 108 /* read all events before updating the maps, to reduce error */ 109 for (i = 0; i < num_metric && i < MAX_NUM_METRICS; i++) { 110 err = bpf_perf_event_read_value(&events, cpu + i * num_cpu, 111 (void *)(readings + i), 112 sizeof(*readings)); 113 if (err) 114 return 0; 115 } 116 count = bpf_map_lookup_elem(&counts, &zero); 117 if (count) { 118 *count += 1; 119 for (i = 0; i < num_metric && i < MAX_NUM_METRICS; i++) 120 fexit_update_maps(i, &readings[i]); 121 } 122 return 0; 123 } 124 125 char LICENSE[] SEC("license") = "Dual BSD/GPL"; 126