Loading...
1// SPDX-License-Identifier: GPL-2.0
2#include <stdio.h>
3#include <unistd.h>
4#include <stdlib.h>
5#include <signal.h>
6#include <linux/bpf.h>
7#include <string.h>
8#include <sys/resource.h>
9
10#include <bpf/bpf.h>
11#include "bpf_load.h"
12#include "bpf_util.h"
13
14#define MAX_INDEX 64
15#define MAX_STARS 38
16
17static void stars(char *str, long val, long max, int width)
18{
19 int i;
20
21 for (i = 0; i < (width * val / max) - 1 && i < width - 1; i++)
22 str[i] = '*';
23 if (val > max)
24 str[i - 1] = '+';
25 str[i] = '\0';
26}
27
28struct task {
29 char comm[16];
30 __u64 pid_tgid;
31 __u64 uid_gid;
32};
33
34struct hist_key {
35 struct task t;
36 __u32 index;
37};
38
39#define SIZE sizeof(struct task)
40
41static void print_hist_for_pid(int fd, void *task)
42{
43 unsigned int nr_cpus = bpf_num_possible_cpus();
44 struct hist_key key = {}, next_key;
45 long values[nr_cpus];
46 char starstr[MAX_STARS];
47 long value;
48 long data[MAX_INDEX] = {};
49 int max_ind = -1;
50 long max_value = 0;
51 int i, ind;
52
53 while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
54 if (memcmp(&next_key, task, SIZE)) {
55 key = next_key;
56 continue;
57 }
58 bpf_map_lookup_elem(fd, &next_key, values);
59 value = 0;
60 for (i = 0; i < nr_cpus; i++)
61 value += values[i];
62 ind = next_key.index;
63 data[ind] = value;
64 if (value && ind > max_ind)
65 max_ind = ind;
66 if (value > max_value)
67 max_value = value;
68 key = next_key;
69 }
70
71 printf(" syscall write() stats\n");
72 printf(" byte_size : count distribution\n");
73 for (i = 1; i <= max_ind + 1; i++) {
74 stars(starstr, data[i - 1], max_value, MAX_STARS);
75 printf("%8ld -> %-8ld : %-8ld |%-*s|\n",
76 (1l << i) >> 1, (1l << i) - 1, data[i - 1],
77 MAX_STARS, starstr);
78 }
79}
80
81static void print_hist(int fd)
82{
83 struct hist_key key = {}, next_key;
84 static struct task tasks[1024];
85 int task_cnt = 0;
86 int i;
87
88 while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
89 int found = 0;
90
91 for (i = 0; i < task_cnt; i++)
92 if (memcmp(&tasks[i], &next_key, SIZE) == 0)
93 found = 1;
94 if (!found)
95 memcpy(&tasks[task_cnt++], &next_key, SIZE);
96 key = next_key;
97 }
98
99 for (i = 0; i < task_cnt; i++) {
100 printf("\npid %d cmd %s uid %d\n",
101 (__u32) tasks[i].pid_tgid,
102 tasks[i].comm,
103 (__u32) tasks[i].uid_gid);
104 print_hist_for_pid(fd, &tasks[i]);
105 }
106
107}
108
109static void int_exit(int sig)
110{
111 print_hist(map_fd[1]);
112 exit(0);
113}
114
115int main(int ac, char **argv)
116{
117 struct rlimit r = {1024*1024, RLIM_INFINITY};
118 char filename[256];
119 long key, next_key, value;
120 FILE *f;
121 int i;
122
123 snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
124
125 if (setrlimit(RLIMIT_MEMLOCK, &r)) {
126 perror("setrlimit(RLIMIT_MEMLOCK)");
127 return 1;
128 }
129
130 signal(SIGINT, int_exit);
131 signal(SIGTERM, int_exit);
132
133 /* start 'ping' in the background to have some kfree_skb events */
134 f = popen("ping -4 -c5 localhost", "r");
135 (void) f;
136
137 /* start 'dd' in the background to have plenty of 'write' syscalls */
138 f = popen("dd if=/dev/zero of=/dev/null count=5000000", "r");
139 (void) f;
140
141 if (load_bpf_file(filename)) {
142 printf("%s", bpf_log_buf);
143 return 1;
144 }
145
146 for (i = 0; i < 5; i++) {
147 key = 0;
148 while (bpf_map_get_next_key(map_fd[0], &key, &next_key) == 0) {
149 bpf_map_lookup_elem(map_fd[0], &next_key, &value);
150 printf("location 0x%lx count %ld\n", next_key, value);
151 key = next_key;
152 }
153 if (key)
154 printf("\n");
155 sleep(1);
156 }
157 print_hist(map_fd[1]);
158
159 return 0;
160}
1#include <stdio.h>
2#include <unistd.h>
3#include <stdlib.h>
4#include <signal.h>
5#include <linux/bpf.h>
6#include <string.h>
7
8#include "libbpf.h"
9#include "bpf_load.h"
10#include "bpf_util.h"
11
12#define MAX_INDEX 64
13#define MAX_STARS 38
14
15static void stars(char *str, long val, long max, int width)
16{
17 int i;
18
19 for (i = 0; i < (width * val / max) - 1 && i < width - 1; i++)
20 str[i] = '*';
21 if (val > max)
22 str[i - 1] = '+';
23 str[i] = '\0';
24}
25
26struct task {
27 char comm[16];
28 __u64 pid_tgid;
29 __u64 uid_gid;
30};
31
32struct hist_key {
33 struct task t;
34 __u32 index;
35};
36
37#define SIZE sizeof(struct task)
38
39static void print_hist_for_pid(int fd, void *task)
40{
41 unsigned int nr_cpus = bpf_num_possible_cpus();
42 struct hist_key key = {}, next_key;
43 long values[nr_cpus];
44 char starstr[MAX_STARS];
45 long value;
46 long data[MAX_INDEX] = {};
47 int max_ind = -1;
48 long max_value = 0;
49 int i, ind;
50
51 while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
52 if (memcmp(&next_key, task, SIZE)) {
53 key = next_key;
54 continue;
55 }
56 bpf_map_lookup_elem(fd, &next_key, values);
57 value = 0;
58 for (i = 0; i < nr_cpus; i++)
59 value += values[i];
60 ind = next_key.index;
61 data[ind] = value;
62 if (value && ind > max_ind)
63 max_ind = ind;
64 if (value > max_value)
65 max_value = value;
66 key = next_key;
67 }
68
69 printf(" syscall write() stats\n");
70 printf(" byte_size : count distribution\n");
71 for (i = 1; i <= max_ind + 1; i++) {
72 stars(starstr, data[i - 1], max_value, MAX_STARS);
73 printf("%8ld -> %-8ld : %-8ld |%-*s|\n",
74 (1l << i) >> 1, (1l << i) - 1, data[i - 1],
75 MAX_STARS, starstr);
76 }
77}
78
79static void print_hist(int fd)
80{
81 struct hist_key key = {}, next_key;
82 static struct task tasks[1024];
83 int task_cnt = 0;
84 int i;
85
86 while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
87 int found = 0;
88
89 for (i = 0; i < task_cnt; i++)
90 if (memcmp(&tasks[i], &next_key, SIZE) == 0)
91 found = 1;
92 if (!found)
93 memcpy(&tasks[task_cnt++], &next_key, SIZE);
94 key = next_key;
95 }
96
97 for (i = 0; i < task_cnt; i++) {
98 printf("\npid %d cmd %s uid %d\n",
99 (__u32) tasks[i].pid_tgid,
100 tasks[i].comm,
101 (__u32) tasks[i].uid_gid);
102 print_hist_for_pid(fd, &tasks[i]);
103 }
104
105}
106
107static void int_exit(int sig)
108{
109 print_hist(map_fd[1]);
110 exit(0);
111}
112
113int main(int ac, char **argv)
114{
115 char filename[256];
116 long key, next_key, value;
117 FILE *f;
118 int i;
119
120 snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
121
122 signal(SIGINT, int_exit);
123
124 /* start 'ping' in the background to have some kfree_skb events */
125 f = popen("ping -c5 localhost", "r");
126 (void) f;
127
128 /* start 'dd' in the background to have plenty of 'write' syscalls */
129 f = popen("dd if=/dev/zero of=/dev/null count=5000000", "r");
130 (void) f;
131
132 if (load_bpf_file(filename)) {
133 printf("%s", bpf_log_buf);
134 return 1;
135 }
136
137 for (i = 0; i < 5; i++) {
138 key = 0;
139 while (bpf_map_get_next_key(map_fd[0], &key, &next_key) == 0) {
140 bpf_map_lookup_elem(map_fd[0], &next_key, &value);
141 printf("location 0x%lx count %ld\n", next_key, value);
142 key = next_key;
143 }
144 if (key)
145 printf("\n");
146 sleep(1);
147 }
148 print_hist(map_fd[1]);
149
150 return 0;
151}