blob: 0eae675e3817770249d17786593815d404699f99 [file] [log] [blame]
Martin KaFai Lauf89cb402017-10-19 23:52:54 -07001#include <time.h>
2#include <stdio.h>
3#include <errno.h>
4#include <string.h>
5#include <stdlib.h>
6#include <stdio.h>
7#include <stdint.h>
8#include <unistd.h>
9#include <ctype.h>
10#include <sysexits.h>
11
12#include "libbpf.h"
13
nikolay.samofatovc5308e92017-12-28 19:01:31 +030014// TODO: Remove this when CentOS 6 support is not needed anymore
15#ifndef CLOCK_BOOTTIME
16#define CLOCK_BOOTTIME 7
17#endif
18
Martin KaFai Lauf89cb402017-10-19 23:52:54 -070019static const char * const prog_type_strings[] = {
20 [BPF_PROG_TYPE_UNSPEC] = "unspec",
21 [BPF_PROG_TYPE_SOCKET_FILTER] = "socket filter",
22 [BPF_PROG_TYPE_KPROBE] = "kprobe",
23 [BPF_PROG_TYPE_SCHED_CLS] = "sched cls",
24 [BPF_PROG_TYPE_SCHED_ACT] = "sched act",
25 [BPF_PROG_TYPE_TRACEPOINT] = "tracepoint",
26 [BPF_PROG_TYPE_XDP] = "xdp",
27 [BPF_PROG_TYPE_PERF_EVENT] = "perf event",
28 [BPF_PROG_TYPE_CGROUP_SKB] = "cgroup skb",
29 [BPF_PROG_TYPE_CGROUP_SOCK] = "cgroup sock",
30 [BPF_PROG_TYPE_LWT_IN] = "lwt in",
31 [BPF_PROG_TYPE_LWT_OUT] = "lwt out",
32 [BPF_PROG_TYPE_LWT_XMIT] = "lwt xmit",
33 [BPF_PROG_TYPE_SOCK_OPS] = "sock ops",
34 [BPF_PROG_TYPE_SK_SKB] = "sk skb",
Yonghong Song6f3c8252018-06-10 18:04:11 -070035 [BPF_PROG_TYPE_CGROUP_DEVICE] = "cgroup_device",
36 [BPF_PROG_TYPE_SK_MSG] = "sk_msg",
37 [BPF_PROG_TYPE_RAW_TRACEPOINT] = "raw_tracepoint",
38 [BPF_PROG_TYPE_CGROUP_SOCK_ADDR] = "cgroup_sock_addr",
39 [BPF_PROG_TYPE_LIRC_MODE2] = "lirc_mode2",
yonghong-song3835b2d2018-08-16 18:49:06 -070040 [BPF_PROG_TYPE_SK_REUSEPORT] = "sk_reuseport",
yonghong-songd4b23872018-10-10 16:48:15 -070041 [BPF_PROG_TYPE_FLOW_DISSECTOR] = "flow_dissector",
Yonghong Song912d3572019-04-29 11:43:22 -070042 [BPF_PROG_TYPE_CGROUP_SYSCTL] = "cgroup_sysctl",
Yonghong Song3bdeff32019-05-17 10:26:44 -070043 [BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE] = "raw_tracepoint_writable",
Yonghong Song06e30cc2019-07-09 22:54:31 -070044 [BPF_PROG_TYPE_CGROUP_SOCKOPT] = "cgroup_sockopt",
yonghong-song992e4822019-11-13 13:37:58 -080045 [BPF_PROG_TYPE_TRACING] = "tracing",
Yonghong Song071eef62020-01-10 12:52:44 -080046 [BPF_PROG_TYPE_STRUCT_OPS] = "struct_ops",
Yonghong Song83b67c22020-01-27 14:35:21 -080047 [BPF_PROG_TYPE_EXT] = "ext",
Yonghong Songdf3e7d62020-04-20 09:25:57 -070048 [BPF_PROG_TYPE_LSM] = "lsm",
Yonghong Song8a164f92020-07-30 11:32:49 -070049 [BPF_PROG_TYPE_SK_LOOKUP] = "sk_lookup",
Martin KaFai Lauf89cb402017-10-19 23:52:54 -070050};
51
52static const char * const map_type_strings[] = {
53 [BPF_MAP_TYPE_UNSPEC] = "unspec",
54 [BPF_MAP_TYPE_HASH] = "hash",
55 [BPF_MAP_TYPE_ARRAY] = "array",
56 [BPF_MAP_TYPE_PROG_ARRAY] = "prog array",
57 [BPF_MAP_TYPE_PERF_EVENT_ARRAY] = "perf-ev array",
58 [BPF_MAP_TYPE_PERCPU_HASH] = "percpu hash",
59 [BPF_MAP_TYPE_PERCPU_ARRAY] = "percpu array",
60 [BPF_MAP_TYPE_STACK_TRACE] = "stack trace",
61 [BPF_MAP_TYPE_CGROUP_ARRAY] = "cgroup array",
62 [BPF_MAP_TYPE_LRU_HASH] = "lru hash",
63 [BPF_MAP_TYPE_LRU_PERCPU_HASH] = "lru percpu hash",
64 [BPF_MAP_TYPE_LPM_TRIE] = "lpm trie",
65 [BPF_MAP_TYPE_ARRAY_OF_MAPS] = "array of maps",
66 [BPF_MAP_TYPE_HASH_OF_MAPS] = "hash of maps",
67 [BPF_MAP_TYPE_DEVMAP] = "devmap",
68 [BPF_MAP_TYPE_SOCKMAP] = "sockmap",
Yonghong Song6f3c8252018-06-10 18:04:11 -070069 [BPF_MAP_TYPE_CPUMAP] = "cpumap",
70 [BPF_MAP_TYPE_SOCKHASH] = "sockhash",
yonghong-song3835b2d2018-08-16 18:49:06 -070071 [BPF_MAP_TYPE_CGROUP_STORAGE] = "cgroup_storage",
72 [BPF_MAP_TYPE_REUSEPORT_SOCKARRAY] = "reuseport_sockarray",
Yonghong Song2a68bd82018-10-27 23:14:52 -070073 [BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE] = "precpu_cgroup_storage",
74 [BPF_MAP_TYPE_QUEUE] = "queue",
75 [BPF_MAP_TYPE_STACK] = "stack",
Yonghong Song3bdeff32019-05-17 10:26:44 -070076 [BPF_MAP_TYPE_SK_STORAGE] = "sk_storage",
yonghong-songeb018cf2019-10-02 16:34:38 -070077 [BPF_MAP_TYPE_DEVMAP_HASH] = "devmap_hash",
Yonghong Song071eef62020-01-10 12:52:44 -080078 [BPF_MAP_TYPE_STRUCT_OPS] = "struct_ops",
Yonghong Song99fa3122020-06-16 00:03:11 -070079 [BPF_MAP_TYPE_RINGBUF] = "ringbuf",
Yonghong Songd0e1c932020-10-01 17:32:16 -070080 [BPF_MAP_TYPE_INODE_STORAGE] = "inode_storage",
Yonghong Song1f4b9072021-01-04 20:11:54 -080081 [BPF_MAP_TYPE_TASK_STORAGE] = "task_storage",
Martin KaFai Lauf89cb402017-10-19 23:52:54 -070082};
83
84#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
85#define LAST_KNOWN_PROG_TYPE (ARRAY_SIZE(prog_type_strings) - 1)
86#define LAST_KNOWN_MAP_TYPE (ARRAY_SIZE(map_type_strings) - 1)
87#define min(x, y) ((x) < (y) ? (x) : (y))
88
89static inline uint64_t ptr_to_u64(const void *ptr)
90{
91 return (uint64_t) (unsigned long) ptr;
92}
93
94static inline void * u64_to_ptr(uint64_t ptr)
95{
96 return (void *) (unsigned long ) ptr;
97}
98
99static int handle_get_next_errno(int eno)
100{
101 switch (eno) {
102 case ENOENT:
103 return 0;
104 case EINVAL:
105 fprintf(stderr, "Kernel does not support BPF introspection\n");
106 return EX_UNAVAILABLE;
107 case EPERM:
108 fprintf(stderr,
109 "Require CAP_SYS_ADMIN capability. Please retry as root\n");
110 return EX_NOPERM;
111 default:
112 fprintf(stderr, "%s\n", strerror(errno));
113 return 1;
114 }
115}
116
117static void print_prog_hdr(void)
118{
119 printf("%9s %-15s %8s %6s %-12s %-15s\n",
120 "BID", "TYPE", "UID", "#MAPS", "LoadTime", "NAME");
121}
122
123static void print_prog_info(const struct bpf_prog_info *prog_info)
124{
125 struct timespec real_time_ts, boot_time_ts;
126 time_t wallclock_load_time = 0;
127 char unknown_prog_type[16];
128 const char *prog_type;
129 char load_time[16];
130 struct tm load_tm;
131
132 if (prog_info->type > LAST_KNOWN_PROG_TYPE) {
133 snprintf(unknown_prog_type, sizeof(unknown_prog_type), "<%u>",
134 prog_info->type);
135 unknown_prog_type[sizeof(unknown_prog_type) - 1] = '\0';
136 prog_type = unknown_prog_type;
137 } else {
138 prog_type = prog_type_strings[prog_info->type];
139 }
140
141 if (!clock_gettime(CLOCK_REALTIME, &real_time_ts) &&
142 !clock_gettime(CLOCK_BOOTTIME, &boot_time_ts) &&
143 real_time_ts.tv_sec >= boot_time_ts.tv_sec)
144 wallclock_load_time =
145 (real_time_ts.tv_sec - boot_time_ts.tv_sec) +
146 prog_info->load_time / 1000000000;
147
148 if (wallclock_load_time && localtime_r(&wallclock_load_time, &load_tm))
149 strftime(load_time, sizeof(load_time), "%b%d/%H:%M", &load_tm);
150 else
151 snprintf(load_time, sizeof(load_time), "<%llu>",
152 prog_info->load_time / 1000000000);
153 load_time[sizeof(load_time) - 1] = '\0';
154
155 if (prog_info->jited_prog_len)
156 printf("%9u %-15s %8u %6u %-12s %-15s\n",
157 prog_info->id, prog_type, prog_info->created_by_uid,
158 prog_info->nr_map_ids, load_time, prog_info->name);
159 else
160 printf("%8u- %-15s %8u %6u %-12s %-15s\n",
161 prog_info->id, prog_type, prog_info->created_by_uid,
162 prog_info->nr_map_ids, load_time, prog_info->name);
163}
164
165static void print_map_hdr(void)
166{
167 printf("%8s %-15s %-10s %8s %8s %8s %-15s\n",
168 "MID", "TYPE", "FLAGS", "KeySz", "ValueSz", "MaxEnts",
169 "NAME");
170}
171
172static void print_map_info(const struct bpf_map_info *map_info)
173{
174 char unknown_map_type[16];
175 const char *map_type;
176
177 if (map_info->type > LAST_KNOWN_MAP_TYPE) {
178 snprintf(unknown_map_type, sizeof(unknown_map_type),
179 "<%u>", map_info->type);
180 unknown_map_type[sizeof(unknown_map_type) - 1] = '\0';
181 map_type = unknown_map_type;
182 } else {
183 map_type = map_type_strings[map_info->type];
184 }
185
186 printf("%8u %-15s 0x%-8x %8u %8u %8u %-15s\n",
187 map_info->id, map_type, map_info->map_flags, map_info->key_size,
188 map_info->value_size, map_info->max_entries,
189 map_info->name);
190}
191
192static int print_one_prog(uint32_t prog_id)
193{
194 const uint32_t usual_nr_map_ids = 64;
195 uint32_t nr_map_ids = usual_nr_map_ids;
196 struct bpf_prog_info prog_info;
197 uint32_t *map_ids = NULL;
198 uint32_t info_len;
199 int ret = 0;
200 int prog_fd;
201 uint32_t i;
202
203 prog_fd = bpf_prog_get_fd_by_id(prog_id);
204 if (prog_fd == -1) {
205 if (errno == ENOENT) {
206 fprintf(stderr, "BID:%u not found\n", prog_id);
207 return EX_DATAERR;
208 } else {
209 return handle_get_next_errno(errno);
210 }
211 }
212
213 /* Retry at most one time for larger map_ids array */
214 for (i = 0; i < 2; i++) {
215 bzero(&prog_info, sizeof(prog_info));
216 prog_info.map_ids = ptr_to_u64(realloc(map_ids,
217 nr_map_ids * sizeof(*map_ids)));
218 if (!prog_info.map_ids) {
219 fprintf(stderr,
220 "Cannot allocate memory for %u map_ids for BID:%u\n",
221 nr_map_ids, prog_id);
222 close(prog_fd);
223 free(map_ids);
224 return 1;
225 }
226
227 map_ids = u64_to_ptr(prog_info.map_ids);
228 prog_info.nr_map_ids = nr_map_ids;
229 info_len = sizeof(prog_info);
230 ret = bpf_obj_get_info(prog_fd, &prog_info, &info_len);
231 if (ret) {
232 fprintf(stderr, "Cannot get info for BID:%u. %s(%d)\n",
233 prog_id, strerror(errno), errno);
234 close(prog_fd);
235 free(map_ids);
236 return ret;
237 }
238
239 if (prog_info.nr_map_ids <= nr_map_ids)
240 break;
241
242 nr_map_ids = prog_info.nr_map_ids;
243 }
244 close(prog_fd);
245
246 print_prog_hdr();
247 print_prog_info(&prog_info);
248 printf("\n");
249
250 /* Print all map_info used by the prog */
251 print_map_hdr();
252 nr_map_ids = min(prog_info.nr_map_ids, nr_map_ids);
253 for (i = 0; i < nr_map_ids; i++) {
254 struct bpf_map_info map_info = {};
Teng Qind77a41b2017-10-31 12:05:17 -0700255 info_len = sizeof(map_info);
Martin KaFai Lauf89cb402017-10-19 23:52:54 -0700256 int map_fd;
257
258 map_fd = bpf_map_get_fd_by_id(map_ids[i]);
259 if (map_fd == -1) {
260 if (errno == -ENOENT)
261 continue;
262
263 fprintf(stderr,
264 "Cannot get fd for map:%u. %s(%d)\n",
265 map_ids[i], strerror(errno), errno);
266 ret = map_fd;
267 break;
268 }
269
270 ret = bpf_obj_get_info(map_fd, &map_info, &info_len);
271 close(map_fd);
272 if (ret) {
273 fprintf(stderr, "Cannot get info for map:%u. %s(%d)\n",
274 map_ids[i], strerror(errno), errno);
275 break;
276 }
277
278 print_map_info(&map_info);
279 }
280
281 free(map_ids);
282 return ret;
283}
284
285int print_all_progs(void)
286{
287 uint32_t next_id = 0;
288
289 print_prog_hdr();
290
291 while (!bpf_prog_get_next_id(next_id, &next_id)) {
292 struct bpf_prog_info prog_info = {};
293 uint32_t prog_info_len = sizeof(prog_info);
294 int prog_fd;
295 int ret;
296
297 prog_fd = bpf_prog_get_fd_by_id(next_id);
298 if (prog_fd < 0) {
299 if (errno == ENOENT)
300 continue;
301 fprintf(stderr,
302 "Cannot get fd for BID:%u. %s(%d)\n",
303 next_id, strerror(errno), errno);
304 return 1;
305 }
306
307 ret = bpf_obj_get_info(prog_fd, &prog_info, &prog_info_len);
308 close(prog_fd);
309 if (ret) {
310 fprintf(stderr,
311 "Cannot get bpf_prog_info for BID:%u. %s(%d)\n",
312 next_id, strerror(errno), errno);
313 return ret;
314 }
315
316 print_prog_info(&prog_info);
317 }
318
319 return handle_get_next_errno(errno);
320}
321
322void usage(void)
323{
324 printf("BPF Program Snapshot (bps):\n"
325 "List of all BPF programs loaded into the system.\n\n");
326 printf("Usage: bps [bpf-prog-id]\n");
327 printf(" [bpf-prog-id] If specified, it shows the details info of the bpf-prog\n");
328 printf("\n");
329}
330
331int main(int argc, char **argv)
332{
333 if (argc > 1) {
334 if (!isdigit(*argv[1])) {
335 usage();
336 return EX_USAGE;
337 }
338 return print_one_prog((uint32_t)atoi(argv[1]));
339 }
340
341 return print_all_progs();
342}