]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - tools/bpf/bpftool/map.c
projects / mirror_ubuntu-focal-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'sh-pfc-for-v5.1-tag2' of git://git.kernel.org/pub/scm/linux/kernel/git...
[mirror_ubuntu-focal-kernel.git] / tools / bpf / bpftool / map.c
1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
3
4 #include <assert.h>
5 #include <errno.h>
6 #include <fcntl.h>
7 #include <linux/err.h>
8 #include <linux/kernel.h>
9 #include <net/if.h>
10 #include <stdbool.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <unistd.h>
15 #include <sys/types.h>
16 #include <sys/stat.h>
17
18 #include <bpf.h>
19
20 #include "btf.h"
21 #include "json_writer.h"
22 #include "main.h"
23
24 static const char * const map_type_name[] = {
25 [BPF_MAP_TYPE_UNSPEC] = "unspec",
26 [BPF_MAP_TYPE_HASH] = "hash",
27 [BPF_MAP_TYPE_ARRAY] = "array",
28 [BPF_MAP_TYPE_PROG_ARRAY] = "prog_array",
29 [BPF_MAP_TYPE_PERF_EVENT_ARRAY] = "perf_event_array",
30 [BPF_MAP_TYPE_PERCPU_HASH] = "percpu_hash",
31 [BPF_MAP_TYPE_PERCPU_ARRAY] = "percpu_array",
32 [BPF_MAP_TYPE_STACK_TRACE] = "stack_trace",
33 [BPF_MAP_TYPE_CGROUP_ARRAY] = "cgroup_array",
34 [BPF_MAP_TYPE_LRU_HASH] = "lru_hash",
35 [BPF_MAP_TYPE_LRU_PERCPU_HASH] = "lru_percpu_hash",
36 [BPF_MAP_TYPE_LPM_TRIE] = "lpm_trie",
37 [BPF_MAP_TYPE_ARRAY_OF_MAPS] = "array_of_maps",
38 [BPF_MAP_TYPE_HASH_OF_MAPS] = "hash_of_maps",
39 [BPF_MAP_TYPE_DEVMAP] = "devmap",
40 [BPF_MAP_TYPE_SOCKMAP] = "sockmap",
41 [BPF_MAP_TYPE_CPUMAP] = "cpumap",
42 [BPF_MAP_TYPE_XSKMAP] = "xskmap",
43 [BPF_MAP_TYPE_SOCKHASH] = "sockhash",
44 [BPF_MAP_TYPE_CGROUP_STORAGE] = "cgroup_storage",
45 [BPF_MAP_TYPE_REUSEPORT_SOCKARRAY] = "reuseport_sockarray",
46 [BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE] = "percpu_cgroup_storage",
47 [BPF_MAP_TYPE_QUEUE] = "queue",
48 [BPF_MAP_TYPE_STACK] = "stack",
49 };
50
51 static bool map_is_per_cpu(__u32 type)
52 {
53 return type == BPF_MAP_TYPE_PERCPU_HASH ||
54 type == BPF_MAP_TYPE_PERCPU_ARRAY ||
55 type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
56 type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE;
57 }
58
59 static bool map_is_map_of_maps(__u32 type)
60 {
61 return type == BPF_MAP_TYPE_ARRAY_OF_MAPS ||
62 type == BPF_MAP_TYPE_HASH_OF_MAPS;
63 }
64
65 static bool map_is_map_of_progs(__u32 type)
66 {
67 return type == BPF_MAP_TYPE_PROG_ARRAY;
68 }
69
70 static int map_type_from_str(const char *type)
71 {
72 unsigned int i;
73
74 for (i = 0; i < ARRAY_SIZE(map_type_name); i++)
75 /* Don't allow prefixing in case of possible future shadowing */
76 if (map_type_name[i] && !strcmp(map_type_name[i], type))
77 return i;
78 return -1;
79 }
80
81 static void *alloc_value(struct bpf_map_info *info)
82 {
83 if (map_is_per_cpu(info->type))
84 return malloc(round_up(info->value_size, 8) *
85 get_possible_cpus());
86 else
87 return malloc(info->value_size);
88 }
89
90 int map_parse_fd(int *argc, char ***argv)
91 {
92 int fd;
93
94 if (is_prefix(**argv, "id")) {
95 unsigned int id;
96 char *endptr;
97
98 NEXT_ARGP();
99
100 id = strtoul(**argv, &endptr, 0);
101 if (*endptr) {
102 p_err("can't parse %s as ID", **argv);
103 return -1;
104 }
105 NEXT_ARGP();
106
107 fd = bpf_map_get_fd_by_id(id);
108 if (fd < 0)
109 p_err("get map by id (%u): %s", id, strerror(errno));
110 return fd;
111 } else if (is_prefix(**argv, "pinned")) {
112 char *path;
113
114 NEXT_ARGP();
115
116 path = **argv;
117 NEXT_ARGP();
118
119 return open_obj_pinned_any(path, BPF_OBJ_MAP);
120 }
121
122 p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
123 return -1;
124 }
125
126 int map_parse_fd_and_info(int *argc, char ***argv, void *info, __u32 *info_len)
127 {
128 int err;
129 int fd;
130
131 fd = map_parse_fd(argc, argv);
132 if (fd < 0)
133 return -1;
134
135 err = bpf_obj_get_info_by_fd(fd, info, info_len);
136 if (err) {
137 p_err("can't get map info: %s", strerror(errno));
138 close(fd);
139 return err;
140 }
141
142 return fd;
143 }
144
145 static int do_dump_btf(const struct btf_dumper *d,
146 struct bpf_map_info *map_info, void *key,
147 void *value)
148 {
149 int ret;
150
151 /* start of key-value pair */
152 jsonw_start_object(d->jw);
153
154 jsonw_name(d->jw, "key");
155
156 ret = btf_dumper_type(d, map_info->btf_key_type_id, key);
157 if (ret)
158 goto err_end_obj;
159
160 if (!map_is_per_cpu(map_info->type)) {
161 jsonw_name(d->jw, "value");
162 ret = btf_dumper_type(d, map_info->btf_value_type_id, value);
163 } else {
164 unsigned int i, n, step;
165
166 jsonw_name(d->jw, "values");
167 jsonw_start_array(d->jw);
168 n = get_possible_cpus();
169 step = round_up(map_info->value_size, 8);
170 for (i = 0; i < n; i++) {
171 jsonw_start_object(d->jw);
172 jsonw_int_field(d->jw, "cpu", i);
173 jsonw_name(d->jw, "value");
174 ret = btf_dumper_type(d, map_info->btf_value_type_id,
175 value + i * step);
176 jsonw_end_object(d->jw);
177 if (ret)
178 break;
179 }
180 jsonw_end_array(d->jw);
181 }
182
183 err_end_obj:
184 /* end of key-value pair */
185 jsonw_end_object(d->jw);
186
187 return ret;
188 }
189
190 static json_writer_t *get_btf_writer(void)
191 {
192 json_writer_t *jw = jsonw_new(stdout);
193
194 if (!jw)
195 return NULL;
196 jsonw_pretty(jw, true);
197
198 return jw;
199 }
200
201 static void print_entry_json(struct bpf_map_info *info, unsigned char *key,
202 unsigned char *value, struct btf *btf)
203 {
204 jsonw_start_object(json_wtr);
205
206 if (!map_is_per_cpu(info->type)) {
207 jsonw_name(json_wtr, "key");
208 print_hex_data_json(key, info->key_size);
209 jsonw_name(json_wtr, "value");
210 print_hex_data_json(value, info->value_size);
211 if (btf) {
212 struct btf_dumper d = {
213 .btf = btf,
214 .jw = json_wtr,
215 .is_plain_text = false,
216 };
217
218 jsonw_name(json_wtr, "formatted");
219 do_dump_btf(&d, info, key, value);
220 }
221 } else {
222 unsigned int i, n, step;
223
224 n = get_possible_cpus();
225 step = round_up(info->value_size, 8);
226
227 jsonw_name(json_wtr, "key");
228 print_hex_data_json(key, info->key_size);
229
230 jsonw_name(json_wtr, "values");
231 jsonw_start_array(json_wtr);
232 for (i = 0; i < n; i++) {
233 jsonw_start_object(json_wtr);
234
235 jsonw_int_field(json_wtr, "cpu", i);
236
237 jsonw_name(json_wtr, "value");
238 print_hex_data_json(value + i * step,
239 info->value_size);
240
241 jsonw_end_object(json_wtr);
242 }
243 jsonw_end_array(json_wtr);
244 if (btf) {
245 struct btf_dumper d = {
246 .btf = btf,
247 .jw = json_wtr,
248 .is_plain_text = false,
249 };
250
251 jsonw_name(json_wtr, "formatted");
252 do_dump_btf(&d, info, key, value);
253 }
254 }
255
256 jsonw_end_object(json_wtr);
257 }
258
259 static void print_entry_error(struct bpf_map_info *info, unsigned char *key,
260 const char *value)
261 {
262 int value_size = strlen(value);
263 bool single_line, break_names;
264
265 break_names = info->key_size > 16 || value_size > 16;
266 single_line = info->key_size + value_size <= 24 && !break_names;
267
268 printf("key:%c", break_names ? '\n' : ' ');
269 fprint_hex(stdout, key, info->key_size, " ");
270
271 printf(single_line ? " " : "\n");
272
273 printf("value:%c%s", break_names ? '\n' : ' ', value);
274
275 printf("\n");
276 }
277
278 static void print_entry_plain(struct bpf_map_info *info, unsigned char *key,
279 unsigned char *value)
280 {
281 if (!map_is_per_cpu(info->type)) {
282 bool single_line, break_names;
283
284 break_names = info->key_size > 16 || info->value_size > 16;
285 single_line = info->key_size + info->value_size <= 24 &&
286 !break_names;
287
288 printf("key:%c", break_names ? '\n' : ' ');
289 fprint_hex(stdout, key, info->key_size, " ");
290
291 printf(single_line ? " " : "\n");
292
293 printf("value:%c", break_names ? '\n' : ' ');
294 if (value)
295 fprint_hex(stdout, value, info->value_size, " ");
296 else
297 printf("<no entry>");
298
299 printf("\n");
300 } else {
301 unsigned int i, n, step;
302
303 n = get_possible_cpus();
304 step = round_up(info->value_size, 8);
305
306 printf("key:\n");
307 fprint_hex(stdout, key, info->key_size, " ");
308 printf("\n");
309 for (i = 0; i < n; i++) {
310 printf("value (CPU %02d):%c",
311 i, info->value_size > 16 ? '\n' : ' ');
312 if (value)
313 fprint_hex(stdout, value + i * step,
314 info->value_size, " ");
315 else
316 printf("<no entry>");
317 printf("\n");
318 }
319 }
320 }
321
322 static char **parse_bytes(char **argv, const char *name, unsigned char *val,
323 unsigned int n)
324 {
325 unsigned int i = 0, base = 0;
326 char *endptr;
327
328 if (is_prefix(*argv, "hex")) {
329 base = 16;
330 argv++;
331 }
332
333 while (i < n && argv[i]) {
334 val[i] = strtoul(argv[i], &endptr, base);
335 if (*endptr) {
336 p_err("error parsing byte: %s", argv[i]);
337 return NULL;
338 }
339 i++;
340 }
341
342 if (i != n) {
343 p_err("%s expected %d bytes got %d", name, n, i);
344 return NULL;
345 }
346
347 return argv + i;
348 }
349
350 /* on per cpu maps we must copy the provided value on all value instances */
351 static void fill_per_cpu_value(struct bpf_map_info *info, void *value)
352 {
353 unsigned int i, n, step;
354
355 if (!map_is_per_cpu(info->type))
356 return;
357
358 n = get_possible_cpus();
359 step = round_up(info->value_size, 8);
360 for (i = 1; i < n; i++)
361 memcpy(value + i * step, value, info->value_size);
362 }
363
364 static int parse_elem(char **argv, struct bpf_map_info *info,
365 void *key, void *value, __u32 key_size, __u32 value_size,
366 __u32 *flags, __u32 **value_fd)
367 {
368 if (!*argv) {
369 if (!key && !value)
370 return 0;
371 p_err("did not find %s", key ? "key" : "value");
372 return -1;
373 }
374
375 if (is_prefix(*argv, "key")) {
376 if (!key) {
377 if (key_size)
378 p_err("duplicate key");
379 else
380 p_err("unnecessary key");
381 return -1;
382 }
383
384 argv = parse_bytes(argv + 1, "key", key, key_size);
385 if (!argv)
386 return -1;
387
388 return parse_elem(argv, info, NULL, value, key_size, value_size,
389 flags, value_fd);
390 } else if (is_prefix(*argv, "value")) {
391 int fd;
392
393 if (!value) {
394 if (value_size)
395 p_err("duplicate value");
396 else
397 p_err("unnecessary value");
398 return -1;
399 }
400
401 argv++;
402
403 if (map_is_map_of_maps(info->type)) {
404 int argc = 2;
405
406 if (value_size != 4) {
407 p_err("value smaller than 4B for map in map?");
408 return -1;
409 }
410 if (!argv[0] || !argv[1]) {
411 p_err("not enough value arguments for map in map");
412 return -1;
413 }
414
415 fd = map_parse_fd(&argc, &argv);
416 if (fd < 0)
417 return -1;
418
419 *value_fd = value;
420 **value_fd = fd;
421 } else if (map_is_map_of_progs(info->type)) {
422 int argc = 2;
423
424 if (value_size != 4) {
425 p_err("value smaller than 4B for map of progs?");
426 return -1;
427 }
428 if (!argv[0] || !argv[1]) {
429 p_err("not enough value arguments for map of progs");
430 return -1;
431 }
432
433 fd = prog_parse_fd(&argc, &argv);
434 if (fd < 0)
435 return -1;
436
437 *value_fd = value;
438 **value_fd = fd;
439 } else {
440 argv = parse_bytes(argv, "value", value, value_size);
441 if (!argv)
442 return -1;
443
444 fill_per_cpu_value(info, value);
445 }
446
447 return parse_elem(argv, info, key, NULL, key_size, value_size,
448 flags, NULL);
449 } else if (is_prefix(*argv, "any") || is_prefix(*argv, "noexist") ||
450 is_prefix(*argv, "exist")) {
451 if (!flags) {
452 p_err("flags specified multiple times: %s", *argv);
453 return -1;
454 }
455
456 if (is_prefix(*argv, "any"))
457 *flags = BPF_ANY;
458 else if (is_prefix(*argv, "noexist"))
459 *flags = BPF_NOEXIST;
460 else if (is_prefix(*argv, "exist"))
461 *flags = BPF_EXIST;
462
463 return parse_elem(argv + 1, info, key, value, key_size,
464 value_size, NULL, value_fd);
465 }
466
467 p_err("expected key or value, got: %s", *argv);
468 return -1;
469 }
470
471 static int show_map_close_json(int fd, struct bpf_map_info *info)
472 {
473 char *memlock;
474
475 memlock = get_fdinfo(fd, "memlock");
476
477 jsonw_start_object(json_wtr);
478
479 jsonw_uint_field(json_wtr, "id", info->id);
480 if (info->type < ARRAY_SIZE(map_type_name))
481 jsonw_string_field(json_wtr, "type",
482 map_type_name[info->type]);
483 else
484 jsonw_uint_field(json_wtr, "type", info->type);
485
486 if (*info->name)
487 jsonw_string_field(json_wtr, "name", info->name);
488
489 jsonw_name(json_wtr, "flags");
490 jsonw_printf(json_wtr, "%d", info->map_flags);
491
492 print_dev_json(info->ifindex, info->netns_dev, info->netns_ino);
493
494 jsonw_uint_field(json_wtr, "bytes_key", info->key_size);
495 jsonw_uint_field(json_wtr, "bytes_value", info->value_size);
496 jsonw_uint_field(json_wtr, "max_entries", info->max_entries);
497
498 if (memlock)
499 jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock));
500 free(memlock);
501
502 if (info->type == BPF_MAP_TYPE_PROG_ARRAY) {
503 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type");
504 char *owner_jited = get_fdinfo(fd, "owner_jited");
505
506 if (owner_prog_type) {
507 unsigned int prog_type = atoi(owner_prog_type);
508
509 if (prog_type < ARRAY_SIZE(prog_type_name))
510 jsonw_string_field(json_wtr, "owner_prog_type",
511 prog_type_name[prog_type]);
512 else
513 jsonw_uint_field(json_wtr, "owner_prog_type",
514 prog_type);
515 }
516 if (owner_jited)
517 jsonw_bool_field(json_wtr, "owner_jited",
518 !!atoi(owner_jited));
519
520 free(owner_prog_type);
521 free(owner_jited);
522 }
523 close(fd);
524
525 if (!hash_empty(map_table.table)) {
526 struct pinned_obj *obj;
527
528 jsonw_name(json_wtr, "pinned");
529 jsonw_start_array(json_wtr);
530 hash_for_each_possible(map_table.table, obj, hash, info->id) {
531 if (obj->id == info->id)
532 jsonw_string(json_wtr, obj->path);
533 }
534 jsonw_end_array(json_wtr);
535 }
536
537 jsonw_end_object(json_wtr);
538
539 return 0;
540 }
541
542 static int show_map_close_plain(int fd, struct bpf_map_info *info)
543 {
544 char *memlock;
545
546 memlock = get_fdinfo(fd, "memlock");
547
548 printf("%u: ", info->id);
549 if (info->type < ARRAY_SIZE(map_type_name))
550 printf("%s ", map_type_name[info->type]);
551 else
552 printf("type %u ", info->type);
553
554 if (*info->name)
555 printf("name %s ", info->name);
556
557 printf("flags 0x%x", info->map_flags);
558 print_dev_plain(info->ifindex, info->netns_dev, info->netns_ino);
559 printf("\n");
560 printf("\tkey %uB value %uB max_entries %u",
561 info->key_size, info->value_size, info->max_entries);
562
563 if (memlock)
564 printf(" memlock %sB", memlock);
565 free(memlock);
566
567 if (info->type == BPF_MAP_TYPE_PROG_ARRAY) {
568 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type");
569 char *owner_jited = get_fdinfo(fd, "owner_jited");
570
571 if (owner_prog_type || owner_jited)
572 printf("\n\t");
573 if (owner_prog_type) {
574 unsigned int prog_type = atoi(owner_prog_type);
575
576 if (prog_type < ARRAY_SIZE(prog_type_name))
577 printf("owner_prog_type %s ",
578 prog_type_name[prog_type]);
579 else
580 printf("owner_prog_type %d ", prog_type);
581 }
582 if (owner_jited)
583 printf("owner%s jited",
584 atoi(owner_jited) ? "" : " not");
585
586 free(owner_prog_type);
587 free(owner_jited);
588 }
589 close(fd);
590
591 printf("\n");
592 if (!hash_empty(map_table.table)) {
593 struct pinned_obj *obj;
594
595 hash_for_each_possible(map_table.table, obj, hash, info->id) {
596 if (obj->id == info->id)
597 printf("\tpinned %s\n", obj->path);
598 }
599 }
600 return 0;
601 }
602
603 static int do_show(int argc, char **argv)
604 {
605 struct bpf_map_info info = {};
606 __u32 len = sizeof(info);
607 __u32 id = 0;
608 int err;
609 int fd;
610
611 if (show_pinned)
612 build_pinned_obj_table(&map_table, BPF_OBJ_MAP);
613
614 if (argc == 2) {
615 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
616 if (fd < 0)
617 return -1;
618
619 if (json_output)
620 return show_map_close_json(fd, &info);
621 else
622 return show_map_close_plain(fd, &info);
623 }
624
625 if (argc)
626 return BAD_ARG();
627
628 if (json_output)
629 jsonw_start_array(json_wtr);
630 while (true) {
631 err = bpf_map_get_next_id(id, &id);
632 if (err) {
633 if (errno == ENOENT)
634 break;
635 p_err("can't get next map: %s%s", strerror(errno),
636 errno == EINVAL ? " -- kernel too old?" : "");
637 break;
638 }
639
640 fd = bpf_map_get_fd_by_id(id);
641 if (fd < 0) {
642 if (errno == ENOENT)
643 continue;
644 p_err("can't get map by id (%u): %s",
645 id, strerror(errno));
646 break;
647 }
648
649 err = bpf_obj_get_info_by_fd(fd, &info, &len);
650 if (err) {
651 p_err("can't get map info: %s", strerror(errno));
652 close(fd);
653 break;
654 }
655
656 if (json_output)
657 show_map_close_json(fd, &info);
658 else
659 show_map_close_plain(fd, &info);
660 }
661 if (json_output)
662 jsonw_end_array(json_wtr);
663
664 return errno == ENOENT ? 0 : -1;
665 }
666
667 static int dump_map_elem(int fd, void *key, void *value,
668 struct bpf_map_info *map_info, struct btf *btf,
669 json_writer_t *btf_wtr)
670 {
671 int num_elems = 0;
672 int lookup_errno;
673
674 if (!bpf_map_lookup_elem(fd, key, value)) {
675 if (json_output) {
676 print_entry_json(map_info, key, value, btf);
677 } else {
678 if (btf) {
679 struct btf_dumper d = {
680 .btf = btf,
681 .jw = btf_wtr,
682 .is_plain_text = true,
683 };
684
685 do_dump_btf(&d, map_info, key, value);
686 } else {
687 print_entry_plain(map_info, key, value);
688 }
689 num_elems++;
690 }
691 return num_elems;
692 }
693
694 /* lookup error handling */
695 lookup_errno = errno;
696
697 if (map_is_map_of_maps(map_info->type) ||
698 map_is_map_of_progs(map_info->type))
699 return 0;
700
701 if (json_output) {
702 jsonw_name(json_wtr, "key");
703 print_hex_data_json(key, map_info->key_size);
704 jsonw_name(json_wtr, "value");
705 jsonw_start_object(json_wtr);
706 jsonw_string_field(json_wtr, "error", strerror(lookup_errno));
707 jsonw_end_object(json_wtr);
708 } else {
709 if (errno == ENOENT)
710 print_entry_plain(map_info, key, NULL);
711 else
712 print_entry_error(map_info, key,
713 strerror(lookup_errno));
714 }
715
716 return 0;
717 }
718
719 static int do_dump(int argc, char **argv)
720 {
721 struct bpf_map_info info = {};
722 void *key, *value, *prev_key;
723 unsigned int num_elems = 0;
724 __u32 len = sizeof(info);
725 json_writer_t *btf_wtr;
726 struct btf *btf = NULL;
727 int err;
728 int fd;
729
730 if (argc != 2)
731 usage();
732
733 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
734 if (fd < 0)
735 return -1;
736
737 key = malloc(info.key_size);
738 value = alloc_value(&info);
739 if (!key || !value) {
740 p_err("mem alloc failed");
741 err = -1;
742 goto exit_free;
743 }
744
745 prev_key = NULL;
746
747 err = btf__get_from_id(info.btf_id, &btf);
748 if (err) {
749 p_err("failed to get btf");
750 goto exit_free;
751 }
752
753 if (json_output)
754 jsonw_start_array(json_wtr);
755 else
756 if (btf) {
757 btf_wtr = get_btf_writer();
758 if (!btf_wtr) {
759 p_info("failed to create json writer for btf. falling back to plain output");
760 btf__free(btf);
761 btf = NULL;
762 } else {
763 jsonw_start_array(btf_wtr);
764 }
765 }
766
767 while (true) {
768 err = bpf_map_get_next_key(fd, prev_key, key);
769 if (err) {
770 if (errno == ENOENT)
771 err = 0;
772 break;
773 }
774 num_elems += dump_map_elem(fd, key, value, &info, btf, btf_wtr);
775 prev_key = key;
776 }
777
778 if (json_output)
779 jsonw_end_array(json_wtr);
780 else if (btf) {
781 jsonw_end_array(btf_wtr);
782 jsonw_destroy(&btf_wtr);
783 } else {
784 printf("Found %u element%s\n", num_elems,
785 num_elems != 1 ? "s" : "");
786 }
787
788 exit_free:
789 free(key);
790 free(value);
791 close(fd);
792 btf__free(btf);
793
794 return err;
795 }
796
797 static int do_update(int argc, char **argv)
798 {
799 struct bpf_map_info info = {};
800 __u32 len = sizeof(info);
801 __u32 *value_fd = NULL;
802 __u32 flags = BPF_ANY;
803 void *key, *value;
804 int fd, err;
805
806 if (argc < 2)
807 usage();
808
809 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
810 if (fd < 0)
811 return -1;
812
813 key = malloc(info.key_size);
814 value = alloc_value(&info);
815 if (!key || !value) {
816 p_err("mem alloc failed");
817 err = -1;
818 goto exit_free;
819 }
820
821 err = parse_elem(argv, &info, key, value, info.key_size,
822 info.value_size, &flags, &value_fd);
823 if (err)
824 goto exit_free;
825
826 err = bpf_map_update_elem(fd, key, value, flags);
827 if (err) {
828 p_err("update failed: %s", strerror(errno));
829 goto exit_free;
830 }
831
832 exit_free:
833 if (value_fd)
834 close(*value_fd);
835 free(key);
836 free(value);
837 close(fd);
838
839 if (!err && json_output)
840 jsonw_null(json_wtr);
841 return err;
842 }
843
844 static int do_lookup(int argc, char **argv)
845 {
846 struct bpf_map_info info = {};
847 __u32 len = sizeof(info);
848 json_writer_t *btf_wtr;
849 struct btf *btf = NULL;
850 void *key, *value;
851 int err;
852 int fd;
853
854 if (argc < 2)
855 usage();
856
857 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
858 if (fd < 0)
859 return -1;
860
861 key = malloc(info.key_size);
862 value = alloc_value(&info);
863 if (!key || !value) {
864 p_err("mem alloc failed");
865 err = -1;
866 goto exit_free;
867 }
868
869 err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL);
870 if (err)
871 goto exit_free;
872
873 err = bpf_map_lookup_elem(fd, key, value);
874 if (err) {
875 if (errno == ENOENT) {
876 if (json_output) {
877 jsonw_null(json_wtr);
878 } else {
879 printf("key:\n");
880 fprint_hex(stdout, key, info.key_size, " ");
881 printf("\n\nNot found\n");
882 }
883 } else {
884 p_err("lookup failed: %s", strerror(errno));
885 }
886
887 goto exit_free;
888 }
889
890 /* here means bpf_map_lookup_elem() succeeded */
891 err = btf__get_from_id(info.btf_id, &btf);
892 if (err) {
893 p_err("failed to get btf");
894 goto exit_free;
895 }
896
897 if (json_output) {
898 print_entry_json(&info, key, value, btf);
899 } else if (btf) {
900 /* if here json_wtr wouldn't have been initialised,
901 * so let's create separate writer for btf
902 */
903 btf_wtr = get_btf_writer();
904 if (!btf_wtr) {
905 p_info("failed to create json writer for btf. falling back to plain output");
906 btf__free(btf);
907 btf = NULL;
908 print_entry_plain(&info, key, value);
909 } else {
910 struct btf_dumper d = {
911 .btf = btf,
912 .jw = btf_wtr,
913 .is_plain_text = true,
914 };
915
916 do_dump_btf(&d, &info, key, value);
917 jsonw_destroy(&btf_wtr);
918 }
919 } else {
920 print_entry_plain(&info, key, value);
921 }
922
923 exit_free:
924 free(key);
925 free(value);
926 close(fd);
927 btf__free(btf);
928
929 return err;
930 }
931
932 static int do_getnext(int argc, char **argv)
933 {
934 struct bpf_map_info info = {};
935 __u32 len = sizeof(info);
936 void *key, *nextkey;
937 int err;
938 int fd;
939
940 if (argc < 2)
941 usage();
942
943 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
944 if (fd < 0)
945 return -1;
946
947 key = malloc(info.key_size);
948 nextkey = malloc(info.key_size);
949 if (!key || !nextkey) {
950 p_err("mem alloc failed");
951 err = -1;
952 goto exit_free;
953 }
954
955 if (argc) {
956 err = parse_elem(argv, &info, key, NULL, info.key_size, 0,
957 NULL, NULL);
958 if (err)
959 goto exit_free;
960 } else {
961 free(key);
962 key = NULL;
963 }
964
965 err = bpf_map_get_next_key(fd, key, nextkey);
966 if (err) {
967 p_err("can't get next key: %s", strerror(errno));
968 goto exit_free;
969 }
970
971 if (json_output) {
972 jsonw_start_object(json_wtr);
973 if (key) {
974 jsonw_name(json_wtr, "key");
975 print_hex_data_json(key, info.key_size);
976 } else {
977 jsonw_null_field(json_wtr, "key");
978 }
979 jsonw_name(json_wtr, "next_key");
980 print_hex_data_json(nextkey, info.key_size);
981 jsonw_end_object(json_wtr);
982 } else {
983 if (key) {
984 printf("key:\n");
985 fprint_hex(stdout, key, info.key_size, " ");
986 printf("\n");
987 } else {
988 printf("key: None\n");
989 }
990 printf("next key:\n");
991 fprint_hex(stdout, nextkey, info.key_size, " ");
992 printf("\n");
993 }
994
995 exit_free:
996 free(nextkey);
997 free(key);
998 close(fd);
999
1000 return err;
1001 }
1002
1003 static int do_delete(int argc, char **argv)
1004 {
1005 struct bpf_map_info info = {};
1006 __u32 len = sizeof(info);
1007 void *key;
1008 int err;
1009 int fd;
1010
1011 if (argc < 2)
1012 usage();
1013
1014 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1015 if (fd < 0)
1016 return -1;
1017
1018 key = malloc(info.key_size);
1019 if (!key) {
1020 p_err("mem alloc failed");
1021 err = -1;
1022 goto exit_free;
1023 }
1024
1025 err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL);
1026 if (err)
1027 goto exit_free;
1028
1029 err = bpf_map_delete_elem(fd, key);
1030 if (err)
1031 p_err("delete failed: %s", strerror(errno));
1032
1033 exit_free:
1034 free(key);
1035 close(fd);
1036
1037 if (!err && json_output)
1038 jsonw_null(json_wtr);
1039 return err;
1040 }
1041
1042 static int do_pin(int argc, char **argv)
1043 {
1044 int err;
1045
1046 err = do_pin_any(argc, argv, bpf_map_get_fd_by_id);
1047 if (!err && json_output)
1048 jsonw_null(json_wtr);
1049 return err;
1050 }
1051
1052 static int do_create(int argc, char **argv)
1053 {
1054 struct bpf_create_map_attr attr = { NULL, };
1055 const char *pinfile;
1056 int err, fd;
1057
1058 if (!REQ_ARGS(7))
1059 return -1;
1060 pinfile = GET_ARG();
1061
1062 while (argc) {
1063 if (!REQ_ARGS(2))
1064 return -1;
1065
1066 if (is_prefix(*argv, "type")) {
1067 NEXT_ARG();
1068
1069 if (attr.map_type) {
1070 p_err("map type already specified");
1071 return -1;
1072 }
1073
1074 attr.map_type = map_type_from_str(*argv);
1075 if ((int)attr.map_type < 0) {
1076 p_err("unrecognized map type: %s", *argv);
1077 return -1;
1078 }
1079 NEXT_ARG();
1080 } else if (is_prefix(*argv, "name")) {
1081 NEXT_ARG();
1082 attr.name = GET_ARG();
1083 } else if (is_prefix(*argv, "key")) {
1084 if (parse_u32_arg(&argc, &argv, &attr.key_size,
1085 "key size"))
1086 return -1;
1087 } else if (is_prefix(*argv, "value")) {
1088 if (parse_u32_arg(&argc, &argv, &attr.value_size,
1089 "value size"))
1090 return -1;
1091 } else if (is_prefix(*argv, "entries")) {
1092 if (parse_u32_arg(&argc, &argv, &attr.max_entries,
1093 "max entries"))
1094 return -1;
1095 } else if (is_prefix(*argv, "flags")) {
1096 if (parse_u32_arg(&argc, &argv, &attr.map_flags,
1097 "flags"))
1098 return -1;
1099 } else if (is_prefix(*argv, "dev")) {
1100 NEXT_ARG();
1101
1102 if (attr.map_ifindex) {
1103 p_err("offload device already specified");
1104 return -1;
1105 }
1106
1107 attr.map_ifindex = if_nametoindex(*argv);
1108 if (!attr.map_ifindex) {
1109 p_err("unrecognized netdevice '%s': %s",
1110 *argv, strerror(errno));
1111 return -1;
1112 }
1113 NEXT_ARG();
1114 }
1115 }
1116
1117 if (!attr.name) {
1118 p_err("map name not specified");
1119 return -1;
1120 }
1121
1122 set_max_rlimit();
1123
1124 fd = bpf_create_map_xattr(&attr);
1125 if (fd < 0) {
1126 p_err("map create failed: %s", strerror(errno));
1127 return -1;
1128 }
1129
1130 err = do_pin_fd(fd, pinfile);
1131 close(fd);
1132 if (err)
1133 return err;
1134
1135 if (json_output)
1136 jsonw_null(json_wtr);
1137 return 0;
1138 }
1139
1140 static int do_help(int argc, char **argv)
1141 {
1142 if (json_output) {
1143 jsonw_null(json_wtr);
1144 return 0;
1145 }
1146
1147 fprintf(stderr,
1148 "Usage: %s %s { show | list } [MAP]\n"
1149 " %s %s create FILE type TYPE key KEY_SIZE value VALUE_SIZE \\\n"
1150 " entries MAX_ENTRIES name NAME [flags FLAGS] \\\n"
1151 " [dev NAME]\n"
1152 " %s %s dump MAP\n"
1153 " %s %s update MAP key DATA value VALUE [UPDATE_FLAGS]\n"
1154 " %s %s lookup MAP key DATA\n"
1155 " %s %s getnext MAP [key DATA]\n"
1156 " %s %s delete MAP key DATA\n"
1157 " %s %s pin MAP FILE\n"
1158 " %s %s event_pipe MAP [cpu N index M]\n"
1159 " %s %s help\n"
1160 "\n"
1161 " " HELP_SPEC_MAP "\n"
1162 " DATA := { [hex] BYTES }\n"
1163 " " HELP_SPEC_PROGRAM "\n"
1164 " VALUE := { DATA | MAP | PROG }\n"
1165 " UPDATE_FLAGS := { any | exist | noexist }\n"
1166 " TYPE := { hash | array | prog_array | perf_event_array | percpu_hash |\n"
1167 " percpu_array | stack_trace | cgroup_array | lru_hash |\n"
1168 " lru_percpu_hash | lpm_trie | array_of_maps | hash_of_maps |\n"
1169 " devmap | sockmap | cpumap | xskmap | sockhash |\n"
1170 " cgroup_storage | reuseport_sockarray | percpu_cgroup_storage }\n"
1171 " " HELP_SPEC_OPTIONS "\n"
1172 "",
1173 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1174 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1175 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1176 bin_name, argv[-2]);
1177
1178 return 0;
1179 }
1180
1181 static const struct cmd cmds[] = {
1182 { "show", do_show },
1183 { "list", do_show },
1184 { "help", do_help },
1185 { "dump", do_dump },
1186 { "update", do_update },
1187 { "lookup", do_lookup },
1188 { "getnext", do_getnext },
1189 { "delete", do_delete },
1190 { "pin", do_pin },
1191 { "event_pipe", do_event_pipe },
1192 { "create", do_create },
1193 { 0 }
1194 };
1195
1196 int do_map(int argc, char **argv)
1197 {
1198 return cmd_select(cmds, argc, argv, do_help);
1199 }
Ubuntu Focal Linux kernel mirror