xref: /openbmc/linux/tools/bpf/bpftool/map.c (revision f97769fd)
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/bpf.h>
19 #include <bpf/btf.h>
20 
21 #include "json_writer.h"
22 #include "main.h"
23 
24 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_DEVMAP_HASH]		= "devmap_hash",
41 	[BPF_MAP_TYPE_SOCKMAP]			= "sockmap",
42 	[BPF_MAP_TYPE_CPUMAP]			= "cpumap",
43 	[BPF_MAP_TYPE_XSKMAP]			= "xskmap",
44 	[BPF_MAP_TYPE_SOCKHASH]			= "sockhash",
45 	[BPF_MAP_TYPE_CGROUP_STORAGE]		= "cgroup_storage",
46 	[BPF_MAP_TYPE_REUSEPORT_SOCKARRAY]	= "reuseport_sockarray",
47 	[BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE]	= "percpu_cgroup_storage",
48 	[BPF_MAP_TYPE_QUEUE]			= "queue",
49 	[BPF_MAP_TYPE_STACK]			= "stack",
50 	[BPF_MAP_TYPE_SK_STORAGE]		= "sk_storage",
51 	[BPF_MAP_TYPE_STRUCT_OPS]		= "struct_ops",
52 	[BPF_MAP_TYPE_RINGBUF]			= "ringbuf",
53 };
54 
55 const size_t map_type_name_size = ARRAY_SIZE(map_type_name);
56 
57 static bool map_is_per_cpu(__u32 type)
58 {
59 	return type == BPF_MAP_TYPE_PERCPU_HASH ||
60 	       type == BPF_MAP_TYPE_PERCPU_ARRAY ||
61 	       type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
62 	       type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE;
63 }
64 
65 static bool map_is_map_of_maps(__u32 type)
66 {
67 	return type == BPF_MAP_TYPE_ARRAY_OF_MAPS ||
68 	       type == BPF_MAP_TYPE_HASH_OF_MAPS;
69 }
70 
71 static bool map_is_map_of_progs(__u32 type)
72 {
73 	return type == BPF_MAP_TYPE_PROG_ARRAY;
74 }
75 
76 static int map_type_from_str(const char *type)
77 {
78 	unsigned int i;
79 
80 	for (i = 0; i < ARRAY_SIZE(map_type_name); i++)
81 		/* Don't allow prefixing in case of possible future shadowing */
82 		if (map_type_name[i] && !strcmp(map_type_name[i], type))
83 			return i;
84 	return -1;
85 }
86 
87 static void *alloc_value(struct bpf_map_info *info)
88 {
89 	if (map_is_per_cpu(info->type))
90 		return malloc(round_up(info->value_size, 8) *
91 			      get_possible_cpus());
92 	else
93 		return malloc(info->value_size);
94 }
95 
96 static int do_dump_btf(const struct btf_dumper *d,
97 		       struct bpf_map_info *map_info, void *key,
98 		       void *value)
99 {
100 	__u32 value_id;
101 	int ret;
102 
103 	/* start of key-value pair */
104 	jsonw_start_object(d->jw);
105 
106 	if (map_info->btf_key_type_id) {
107 		jsonw_name(d->jw, "key");
108 
109 		ret = btf_dumper_type(d, map_info->btf_key_type_id, key);
110 		if (ret)
111 			goto err_end_obj;
112 	}
113 
114 	value_id = map_info->btf_vmlinux_value_type_id ?
115 		: map_info->btf_value_type_id;
116 
117 	if (!map_is_per_cpu(map_info->type)) {
118 		jsonw_name(d->jw, "value");
119 		ret = btf_dumper_type(d, value_id, value);
120 	} else {
121 		unsigned int i, n, step;
122 
123 		jsonw_name(d->jw, "values");
124 		jsonw_start_array(d->jw);
125 		n = get_possible_cpus();
126 		step = round_up(map_info->value_size, 8);
127 		for (i = 0; i < n; i++) {
128 			jsonw_start_object(d->jw);
129 			jsonw_int_field(d->jw, "cpu", i);
130 			jsonw_name(d->jw, "value");
131 			ret = btf_dumper_type(d, value_id, value + i * step);
132 			jsonw_end_object(d->jw);
133 			if (ret)
134 				break;
135 		}
136 		jsonw_end_array(d->jw);
137 	}
138 
139 err_end_obj:
140 	/* end of key-value pair */
141 	jsonw_end_object(d->jw);
142 
143 	return ret;
144 }
145 
146 static json_writer_t *get_btf_writer(void)
147 {
148 	json_writer_t *jw = jsonw_new(stdout);
149 
150 	if (!jw)
151 		return NULL;
152 	jsonw_pretty(jw, true);
153 
154 	return jw;
155 }
156 
157 static void print_entry_json(struct bpf_map_info *info, unsigned char *key,
158 			     unsigned char *value, struct btf *btf)
159 {
160 	jsonw_start_object(json_wtr);
161 
162 	if (!map_is_per_cpu(info->type)) {
163 		jsonw_name(json_wtr, "key");
164 		print_hex_data_json(key, info->key_size);
165 		jsonw_name(json_wtr, "value");
166 		print_hex_data_json(value, info->value_size);
167 		if (btf) {
168 			struct btf_dumper d = {
169 				.btf = btf,
170 				.jw = json_wtr,
171 				.is_plain_text = false,
172 			};
173 
174 			jsonw_name(json_wtr, "formatted");
175 			do_dump_btf(&d, info, key, value);
176 		}
177 	} else {
178 		unsigned int i, n, step;
179 
180 		n = get_possible_cpus();
181 		step = round_up(info->value_size, 8);
182 
183 		jsonw_name(json_wtr, "key");
184 		print_hex_data_json(key, info->key_size);
185 
186 		jsonw_name(json_wtr, "values");
187 		jsonw_start_array(json_wtr);
188 		for (i = 0; i < n; i++) {
189 			jsonw_start_object(json_wtr);
190 
191 			jsonw_int_field(json_wtr, "cpu", i);
192 
193 			jsonw_name(json_wtr, "value");
194 			print_hex_data_json(value + i * step,
195 					    info->value_size);
196 
197 			jsonw_end_object(json_wtr);
198 		}
199 		jsonw_end_array(json_wtr);
200 		if (btf) {
201 			struct btf_dumper d = {
202 				.btf = btf,
203 				.jw = json_wtr,
204 				.is_plain_text = false,
205 			};
206 
207 			jsonw_name(json_wtr, "formatted");
208 			do_dump_btf(&d, info, key, value);
209 		}
210 	}
211 
212 	jsonw_end_object(json_wtr);
213 }
214 
215 static void print_entry_error(struct bpf_map_info *info, unsigned char *key,
216 			      const char *error_msg)
217 {
218 	int msg_size = strlen(error_msg);
219 	bool single_line, break_names;
220 
221 	break_names = info->key_size > 16 || msg_size > 16;
222 	single_line = info->key_size + msg_size <= 24 && !break_names;
223 
224 	printf("key:%c", break_names ? '\n' : ' ');
225 	fprint_hex(stdout, key, info->key_size, " ");
226 
227 	printf(single_line ? "  " : "\n");
228 
229 	printf("value:%c%s", break_names ? '\n' : ' ', error_msg);
230 
231 	printf("\n");
232 }
233 
234 static void print_entry_plain(struct bpf_map_info *info, unsigned char *key,
235 			      unsigned char *value)
236 {
237 	if (!map_is_per_cpu(info->type)) {
238 		bool single_line, break_names;
239 
240 		break_names = info->key_size > 16 || info->value_size > 16;
241 		single_line = info->key_size + info->value_size <= 24 &&
242 			!break_names;
243 
244 		if (info->key_size) {
245 			printf("key:%c", break_names ? '\n' : ' ');
246 			fprint_hex(stdout, key, info->key_size, " ");
247 
248 			printf(single_line ? "  " : "\n");
249 		}
250 
251 		if (info->value_size) {
252 			printf("value:%c", break_names ? '\n' : ' ');
253 			fprint_hex(stdout, value, info->value_size, " ");
254 		}
255 
256 		printf("\n");
257 	} else {
258 		unsigned int i, n, step;
259 
260 		n = get_possible_cpus();
261 		step = round_up(info->value_size, 8);
262 
263 		if (info->key_size) {
264 			printf("key:\n");
265 			fprint_hex(stdout, key, info->key_size, " ");
266 			printf("\n");
267 		}
268 		if (info->value_size) {
269 			for (i = 0; i < n; i++) {
270 				printf("value (CPU %02d):%c",
271 				       i, info->value_size > 16 ? '\n' : ' ');
272 				fprint_hex(stdout, value + i * step,
273 					   info->value_size, " ");
274 				printf("\n");
275 			}
276 		}
277 	}
278 }
279 
280 static char **parse_bytes(char **argv, const char *name, unsigned char *val,
281 			  unsigned int n)
282 {
283 	unsigned int i = 0, base = 0;
284 	char *endptr;
285 
286 	if (is_prefix(*argv, "hex")) {
287 		base = 16;
288 		argv++;
289 	}
290 
291 	while (i < n && argv[i]) {
292 		val[i] = strtoul(argv[i], &endptr, base);
293 		if (*endptr) {
294 			p_err("error parsing byte: %s", argv[i]);
295 			return NULL;
296 		}
297 		i++;
298 	}
299 
300 	if (i != n) {
301 		p_err("%s expected %d bytes got %d", name, n, i);
302 		return NULL;
303 	}
304 
305 	return argv + i;
306 }
307 
308 /* on per cpu maps we must copy the provided value on all value instances */
309 static void fill_per_cpu_value(struct bpf_map_info *info, void *value)
310 {
311 	unsigned int i, n, step;
312 
313 	if (!map_is_per_cpu(info->type))
314 		return;
315 
316 	n = get_possible_cpus();
317 	step = round_up(info->value_size, 8);
318 	for (i = 1; i < n; i++)
319 		memcpy(value + i * step, value, info->value_size);
320 }
321 
322 static int parse_elem(char **argv, struct bpf_map_info *info,
323 		      void *key, void *value, __u32 key_size, __u32 value_size,
324 		      __u32 *flags, __u32 **value_fd)
325 {
326 	if (!*argv) {
327 		if (!key && !value)
328 			return 0;
329 		p_err("did not find %s", key ? "key" : "value");
330 		return -1;
331 	}
332 
333 	if (is_prefix(*argv, "key")) {
334 		if (!key) {
335 			if (key_size)
336 				p_err("duplicate key");
337 			else
338 				p_err("unnecessary key");
339 			return -1;
340 		}
341 
342 		argv = parse_bytes(argv + 1, "key", key, key_size);
343 		if (!argv)
344 			return -1;
345 
346 		return parse_elem(argv, info, NULL, value, key_size, value_size,
347 				  flags, value_fd);
348 	} else if (is_prefix(*argv, "value")) {
349 		int fd;
350 
351 		if (!value) {
352 			if (value_size)
353 				p_err("duplicate value");
354 			else
355 				p_err("unnecessary value");
356 			return -1;
357 		}
358 
359 		argv++;
360 
361 		if (map_is_map_of_maps(info->type)) {
362 			int argc = 2;
363 
364 			if (value_size != 4) {
365 				p_err("value smaller than 4B for map in map?");
366 				return -1;
367 			}
368 			if (!argv[0] || !argv[1]) {
369 				p_err("not enough value arguments for map in map");
370 				return -1;
371 			}
372 
373 			fd = map_parse_fd(&argc, &argv);
374 			if (fd < 0)
375 				return -1;
376 
377 			*value_fd = value;
378 			**value_fd = fd;
379 		} else if (map_is_map_of_progs(info->type)) {
380 			int argc = 2;
381 
382 			if (value_size != 4) {
383 				p_err("value smaller than 4B for map of progs?");
384 				return -1;
385 			}
386 			if (!argv[0] || !argv[1]) {
387 				p_err("not enough value arguments for map of progs");
388 				return -1;
389 			}
390 			if (is_prefix(*argv, "id"))
391 				p_info("Warning: updating program array via MAP_ID, make sure this map is kept open\n"
392 				       "         by some process or pinned otherwise update will be lost");
393 
394 			fd = prog_parse_fd(&argc, &argv);
395 			if (fd < 0)
396 				return -1;
397 
398 			*value_fd = value;
399 			**value_fd = fd;
400 		} else {
401 			argv = parse_bytes(argv, "value", value, value_size);
402 			if (!argv)
403 				return -1;
404 
405 			fill_per_cpu_value(info, value);
406 		}
407 
408 		return parse_elem(argv, info, key, NULL, key_size, value_size,
409 				  flags, NULL);
410 	} else if (is_prefix(*argv, "any") || is_prefix(*argv, "noexist") ||
411 		   is_prefix(*argv, "exist")) {
412 		if (!flags) {
413 			p_err("flags specified multiple times: %s", *argv);
414 			return -1;
415 		}
416 
417 		if (is_prefix(*argv, "any"))
418 			*flags = BPF_ANY;
419 		else if (is_prefix(*argv, "noexist"))
420 			*flags = BPF_NOEXIST;
421 		else if (is_prefix(*argv, "exist"))
422 			*flags = BPF_EXIST;
423 
424 		return parse_elem(argv + 1, info, key, value, key_size,
425 				  value_size, NULL, value_fd);
426 	}
427 
428 	p_err("expected key or value, got: %s", *argv);
429 	return -1;
430 }
431 
432 static void show_map_header_json(struct bpf_map_info *info, json_writer_t *wtr)
433 {
434 	jsonw_uint_field(wtr, "id", info->id);
435 	if (info->type < ARRAY_SIZE(map_type_name))
436 		jsonw_string_field(wtr, "type", map_type_name[info->type]);
437 	else
438 		jsonw_uint_field(wtr, "type", info->type);
439 
440 	if (*info->name)
441 		jsonw_string_field(wtr, "name", info->name);
442 
443 	jsonw_name(wtr, "flags");
444 	jsonw_printf(wtr, "%d", info->map_flags);
445 }
446 
447 static int show_map_close_json(int fd, struct bpf_map_info *info)
448 {
449 	char *memlock, *frozen_str;
450 	int frozen = 0;
451 
452 	memlock = get_fdinfo(fd, "memlock");
453 	frozen_str = get_fdinfo(fd, "frozen");
454 
455 	jsonw_start_object(json_wtr);
456 
457 	show_map_header_json(info, json_wtr);
458 
459 	print_dev_json(info->ifindex, info->netns_dev, info->netns_ino);
460 
461 	jsonw_uint_field(json_wtr, "bytes_key", info->key_size);
462 	jsonw_uint_field(json_wtr, "bytes_value", info->value_size);
463 	jsonw_uint_field(json_wtr, "max_entries", info->max_entries);
464 
465 	if (memlock)
466 		jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock));
467 	free(memlock);
468 
469 	if (info->type == BPF_MAP_TYPE_PROG_ARRAY) {
470 		char *owner_prog_type = get_fdinfo(fd, "owner_prog_type");
471 		char *owner_jited = get_fdinfo(fd, "owner_jited");
472 
473 		if (owner_prog_type) {
474 			unsigned int prog_type = atoi(owner_prog_type);
475 
476 			if (prog_type < prog_type_name_size)
477 				jsonw_string_field(json_wtr, "owner_prog_type",
478 						   prog_type_name[prog_type]);
479 			else
480 				jsonw_uint_field(json_wtr, "owner_prog_type",
481 						 prog_type);
482 		}
483 		if (owner_jited)
484 			jsonw_bool_field(json_wtr, "owner_jited",
485 					 !!atoi(owner_jited));
486 
487 		free(owner_prog_type);
488 		free(owner_jited);
489 	}
490 	close(fd);
491 
492 	if (frozen_str) {
493 		frozen = atoi(frozen_str);
494 		free(frozen_str);
495 	}
496 	jsonw_int_field(json_wtr, "frozen", frozen);
497 
498 	if (info->btf_id)
499 		jsonw_int_field(json_wtr, "btf_id", info->btf_id);
500 
501 	if (!hash_empty(map_table.table)) {
502 		struct pinned_obj *obj;
503 
504 		jsonw_name(json_wtr, "pinned");
505 		jsonw_start_array(json_wtr);
506 		hash_for_each_possible(map_table.table, obj, hash, info->id) {
507 			if (obj->id == info->id)
508 				jsonw_string(json_wtr, obj->path);
509 		}
510 		jsonw_end_array(json_wtr);
511 	}
512 
513 	emit_obj_refs_json(&refs_table, info->id, json_wtr);
514 
515 	jsonw_end_object(json_wtr);
516 
517 	return 0;
518 }
519 
520 static void show_map_header_plain(struct bpf_map_info *info)
521 {
522 	printf("%u: ", info->id);
523 	if (info->type < ARRAY_SIZE(map_type_name))
524 		printf("%s  ", map_type_name[info->type]);
525 	else
526 		printf("type %u  ", info->type);
527 
528 	if (*info->name)
529 		printf("name %s  ", info->name);
530 
531 	printf("flags 0x%x", info->map_flags);
532 	print_dev_plain(info->ifindex, info->netns_dev, info->netns_ino);
533 	printf("\n");
534 }
535 
536 static int show_map_close_plain(int fd, struct bpf_map_info *info)
537 {
538 	char *memlock, *frozen_str;
539 	int frozen = 0;
540 
541 	memlock = get_fdinfo(fd, "memlock");
542 	frozen_str = get_fdinfo(fd, "frozen");
543 
544 	show_map_header_plain(info);
545 	printf("\tkey %uB  value %uB  max_entries %u",
546 	       info->key_size, info->value_size, info->max_entries);
547 
548 	if (memlock)
549 		printf("  memlock %sB", memlock);
550 	free(memlock);
551 
552 	if (info->type == BPF_MAP_TYPE_PROG_ARRAY) {
553 		char *owner_prog_type = get_fdinfo(fd, "owner_prog_type");
554 		char *owner_jited = get_fdinfo(fd, "owner_jited");
555 
556 		if (owner_prog_type || owner_jited)
557 			printf("\n\t");
558 		if (owner_prog_type) {
559 			unsigned int prog_type = atoi(owner_prog_type);
560 
561 			if (prog_type < prog_type_name_size)
562 				printf("owner_prog_type %s  ",
563 				       prog_type_name[prog_type]);
564 			else
565 				printf("owner_prog_type %d  ", prog_type);
566 		}
567 		if (owner_jited)
568 			printf("owner%s jited",
569 			       atoi(owner_jited) ? "" : " not");
570 
571 		free(owner_prog_type);
572 		free(owner_jited);
573 	}
574 	close(fd);
575 
576 	if (!hash_empty(map_table.table)) {
577 		struct pinned_obj *obj;
578 
579 		hash_for_each_possible(map_table.table, obj, hash, info->id) {
580 			if (obj->id == info->id)
581 				printf("\n\tpinned %s", obj->path);
582 		}
583 	}
584 	printf("\n");
585 
586 	if (frozen_str) {
587 		frozen = atoi(frozen_str);
588 		free(frozen_str);
589 	}
590 
591 	if (!info->btf_id && !frozen)
592 		return 0;
593 
594 	printf("\t");
595 
596 	if (info->btf_id)
597 		printf("btf_id %d", info->btf_id);
598 
599 	if (frozen)
600 		printf("%sfrozen", info->btf_id ? "  " : "");
601 
602 	emit_obj_refs_plain(&refs_table, info->id, "\n\tpids ");
603 
604 	printf("\n");
605 	return 0;
606 }
607 
608 static int do_show_subset(int argc, char **argv)
609 {
610 	struct bpf_map_info info = {};
611 	__u32 len = sizeof(info);
612 	int *fds = NULL;
613 	int nb_fds, i;
614 	int err = -1;
615 
616 	fds = malloc(sizeof(int));
617 	if (!fds) {
618 		p_err("mem alloc failed");
619 		return -1;
620 	}
621 	nb_fds = map_parse_fds(&argc, &argv, &fds);
622 	if (nb_fds < 1)
623 		goto exit_free;
624 
625 	if (json_output && nb_fds > 1)
626 		jsonw_start_array(json_wtr);	/* root array */
627 	for (i = 0; i < nb_fds; i++) {
628 		err = bpf_obj_get_info_by_fd(fds[i], &info, &len);
629 		if (err) {
630 			p_err("can't get map info: %s",
631 			      strerror(errno));
632 			for (; i < nb_fds; i++)
633 				close(fds[i]);
634 			break;
635 		}
636 
637 		if (json_output)
638 			show_map_close_json(fds[i], &info);
639 		else
640 			show_map_close_plain(fds[i], &info);
641 
642 		close(fds[i]);
643 	}
644 	if (json_output && nb_fds > 1)
645 		jsonw_end_array(json_wtr);	/* root array */
646 
647 exit_free:
648 	free(fds);
649 	return err;
650 }
651 
652 static int do_show(int argc, char **argv)
653 {
654 	struct bpf_map_info info = {};
655 	__u32 len = sizeof(info);
656 	__u32 id = 0;
657 	int err;
658 	int fd;
659 
660 	if (show_pinned)
661 		build_pinned_obj_table(&map_table, BPF_OBJ_MAP);
662 	build_obj_refs_table(&refs_table, BPF_OBJ_MAP);
663 
664 	if (argc == 2)
665 		return do_show_subset(argc, argv);
666 
667 	if (argc)
668 		return BAD_ARG();
669 
670 	if (json_output)
671 		jsonw_start_array(json_wtr);
672 	while (true) {
673 		err = bpf_map_get_next_id(id, &id);
674 		if (err) {
675 			if (errno == ENOENT)
676 				break;
677 			p_err("can't get next map: %s%s", strerror(errno),
678 			      errno == EINVAL ? " -- kernel too old?" : "");
679 			break;
680 		}
681 
682 		fd = bpf_map_get_fd_by_id(id);
683 		if (fd < 0) {
684 			if (errno == ENOENT)
685 				continue;
686 			p_err("can't get map by id (%u): %s",
687 			      id, strerror(errno));
688 			break;
689 		}
690 
691 		err = bpf_obj_get_info_by_fd(fd, &info, &len);
692 		if (err) {
693 			p_err("can't get map info: %s", strerror(errno));
694 			close(fd);
695 			break;
696 		}
697 
698 		if (json_output)
699 			show_map_close_json(fd, &info);
700 		else
701 			show_map_close_plain(fd, &info);
702 	}
703 	if (json_output)
704 		jsonw_end_array(json_wtr);
705 
706 	delete_obj_refs_table(&refs_table);
707 
708 	return errno == ENOENT ? 0 : -1;
709 }
710 
711 static int dump_map_elem(int fd, void *key, void *value,
712 			 struct bpf_map_info *map_info, struct btf *btf,
713 			 json_writer_t *btf_wtr)
714 {
715 	int num_elems = 0;
716 	int lookup_errno;
717 
718 	if (!bpf_map_lookup_elem(fd, key, value)) {
719 		if (json_output) {
720 			print_entry_json(map_info, key, value, btf);
721 		} else {
722 			if (btf) {
723 				struct btf_dumper d = {
724 					.btf = btf,
725 					.jw = btf_wtr,
726 					.is_plain_text = true,
727 				};
728 
729 				do_dump_btf(&d, map_info, key, value);
730 			} else {
731 				print_entry_plain(map_info, key, value);
732 			}
733 			num_elems++;
734 		}
735 		return num_elems;
736 	}
737 
738 	/* lookup error handling */
739 	lookup_errno = errno;
740 
741 	if (map_is_map_of_maps(map_info->type) ||
742 	    map_is_map_of_progs(map_info->type))
743 		return 0;
744 
745 	if (json_output) {
746 		jsonw_start_object(json_wtr);
747 		jsonw_name(json_wtr, "key");
748 		print_hex_data_json(key, map_info->key_size);
749 		jsonw_name(json_wtr, "value");
750 		jsonw_start_object(json_wtr);
751 		jsonw_string_field(json_wtr, "error", strerror(lookup_errno));
752 		jsonw_end_object(json_wtr);
753 		jsonw_end_object(json_wtr);
754 	} else {
755 		const char *msg = NULL;
756 
757 		if (lookup_errno == ENOENT)
758 			msg = "<no entry>";
759 		else if (lookup_errno == ENOSPC &&
760 			 map_info->type == BPF_MAP_TYPE_REUSEPORT_SOCKARRAY)
761 			msg = "<cannot read>";
762 
763 		print_entry_error(map_info, key,
764 				  msg ? : strerror(lookup_errno));
765 	}
766 
767 	return 0;
768 }
769 
770 static int maps_have_btf(int *fds, int nb_fds)
771 {
772 	struct bpf_map_info info = {};
773 	__u32 len = sizeof(info);
774 	int err, i;
775 
776 	for (i = 0; i < nb_fds; i++) {
777 		err = bpf_obj_get_info_by_fd(fds[i], &info, &len);
778 		if (err) {
779 			p_err("can't get map info: %s", strerror(errno));
780 			return -1;
781 		}
782 
783 		if (!info.btf_id)
784 			return 0;
785 	}
786 
787 	return 1;
788 }
789 
790 static struct btf *btf_vmlinux;
791 
792 static struct btf *get_map_kv_btf(const struct bpf_map_info *info)
793 {
794 	struct btf *btf = NULL;
795 
796 	if (info->btf_vmlinux_value_type_id) {
797 		if (!btf_vmlinux) {
798 			btf_vmlinux = libbpf_find_kernel_btf();
799 			if (IS_ERR(btf_vmlinux))
800 				p_err("failed to get kernel btf");
801 		}
802 		return btf_vmlinux;
803 	} else if (info->btf_value_type_id) {
804 		int err;
805 
806 		err = btf__get_from_id(info->btf_id, &btf);
807 		if (err || !btf) {
808 			p_err("failed to get btf");
809 			btf = err ? ERR_PTR(err) : ERR_PTR(-ESRCH);
810 		}
811 	}
812 
813 	return btf;
814 }
815 
816 static void free_map_kv_btf(struct btf *btf)
817 {
818 	if (!IS_ERR(btf) && btf != btf_vmlinux)
819 		btf__free(btf);
820 }
821 
822 static void free_btf_vmlinux(void)
823 {
824 	if (!IS_ERR(btf_vmlinux))
825 		btf__free(btf_vmlinux);
826 }
827 
828 static int
829 map_dump(int fd, struct bpf_map_info *info, json_writer_t *wtr,
830 	 bool show_header)
831 {
832 	void *key, *value, *prev_key;
833 	unsigned int num_elems = 0;
834 	struct btf *btf = NULL;
835 	int err;
836 
837 	key = malloc(info->key_size);
838 	value = alloc_value(info);
839 	if (!key || !value) {
840 		p_err("mem alloc failed");
841 		err = -1;
842 		goto exit_free;
843 	}
844 
845 	prev_key = NULL;
846 
847 	if (wtr) {
848 		btf = get_map_kv_btf(info);
849 		if (IS_ERR(btf)) {
850 			err = PTR_ERR(btf);
851 			goto exit_free;
852 		}
853 
854 		if (show_header) {
855 			jsonw_start_object(wtr);	/* map object */
856 			show_map_header_json(info, wtr);
857 			jsonw_name(wtr, "elements");
858 		}
859 		jsonw_start_array(wtr);		/* elements */
860 	} else if (show_header) {
861 		show_map_header_plain(info);
862 	}
863 
864 	if (info->type == BPF_MAP_TYPE_REUSEPORT_SOCKARRAY &&
865 	    info->value_size != 8)
866 		p_info("Warning: cannot read values from %s map with value_size != 8",
867 		       map_type_name[info->type]);
868 	while (true) {
869 		err = bpf_map_get_next_key(fd, prev_key, key);
870 		if (err) {
871 			if (errno == ENOENT)
872 				err = 0;
873 			break;
874 		}
875 		num_elems += dump_map_elem(fd, key, value, info, btf, wtr);
876 		prev_key = key;
877 	}
878 
879 	if (wtr) {
880 		jsonw_end_array(wtr);	/* elements */
881 		if (show_header)
882 			jsonw_end_object(wtr);	/* map object */
883 	} else {
884 		printf("Found %u element%s\n", num_elems,
885 		       num_elems != 1 ? "s" : "");
886 	}
887 
888 exit_free:
889 	free(key);
890 	free(value);
891 	close(fd);
892 	free_map_kv_btf(btf);
893 
894 	return err;
895 }
896 
897 static int do_dump(int argc, char **argv)
898 {
899 	json_writer_t *wtr = NULL, *btf_wtr = NULL;
900 	struct bpf_map_info info = {};
901 	int nb_fds, i = 0;
902 	__u32 len = sizeof(info);
903 	int *fds = NULL;
904 	int err = -1;
905 
906 	if (argc != 2)
907 		usage();
908 
909 	fds = malloc(sizeof(int));
910 	if (!fds) {
911 		p_err("mem alloc failed");
912 		return -1;
913 	}
914 	nb_fds = map_parse_fds(&argc, &argv, &fds);
915 	if (nb_fds < 1)
916 		goto exit_free;
917 
918 	if (json_output) {
919 		wtr = json_wtr;
920 	} else {
921 		int do_plain_btf;
922 
923 		do_plain_btf = maps_have_btf(fds, nb_fds);
924 		if (do_plain_btf < 0)
925 			goto exit_close;
926 
927 		if (do_plain_btf) {
928 			btf_wtr = get_btf_writer();
929 			wtr = btf_wtr;
930 			if (!btf_wtr)
931 				p_info("failed to create json writer for btf. falling back to plain output");
932 		}
933 	}
934 
935 	if (wtr && nb_fds > 1)
936 		jsonw_start_array(wtr);	/* root array */
937 	for (i = 0; i < nb_fds; i++) {
938 		if (bpf_obj_get_info_by_fd(fds[i], &info, &len)) {
939 			p_err("can't get map info: %s", strerror(errno));
940 			break;
941 		}
942 		err = map_dump(fds[i], &info, wtr, nb_fds > 1);
943 		if (!wtr && i != nb_fds - 1)
944 			printf("\n");
945 
946 		if (err)
947 			break;
948 		close(fds[i]);
949 	}
950 	if (wtr && nb_fds > 1)
951 		jsonw_end_array(wtr);	/* root array */
952 
953 	if (btf_wtr)
954 		jsonw_destroy(&btf_wtr);
955 exit_close:
956 	for (; i < nb_fds; i++)
957 		close(fds[i]);
958 exit_free:
959 	free(fds);
960 	free_btf_vmlinux();
961 	return err;
962 }
963 
964 static int alloc_key_value(struct bpf_map_info *info, void **key, void **value)
965 {
966 	*key = NULL;
967 	*value = NULL;
968 
969 	if (info->key_size) {
970 		*key = malloc(info->key_size);
971 		if (!*key) {
972 			p_err("key mem alloc failed");
973 			return -1;
974 		}
975 	}
976 
977 	if (info->value_size) {
978 		*value = alloc_value(info);
979 		if (!*value) {
980 			p_err("value mem alloc failed");
981 			free(*key);
982 			*key = NULL;
983 			return -1;
984 		}
985 	}
986 
987 	return 0;
988 }
989 
990 static int do_update(int argc, char **argv)
991 {
992 	struct bpf_map_info info = {};
993 	__u32 len = sizeof(info);
994 	__u32 *value_fd = NULL;
995 	__u32 flags = BPF_ANY;
996 	void *key, *value;
997 	int fd, err;
998 
999 	if (argc < 2)
1000 		usage();
1001 
1002 	fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1003 	if (fd < 0)
1004 		return -1;
1005 
1006 	err = alloc_key_value(&info, &key, &value);
1007 	if (err)
1008 		goto exit_free;
1009 
1010 	err = parse_elem(argv, &info, key, value, info.key_size,
1011 			 info.value_size, &flags, &value_fd);
1012 	if (err)
1013 		goto exit_free;
1014 
1015 	err = bpf_map_update_elem(fd, key, value, flags);
1016 	if (err) {
1017 		p_err("update failed: %s", strerror(errno));
1018 		goto exit_free;
1019 	}
1020 
1021 exit_free:
1022 	if (value_fd)
1023 		close(*value_fd);
1024 	free(key);
1025 	free(value);
1026 	close(fd);
1027 
1028 	if (!err && json_output)
1029 		jsonw_null(json_wtr);
1030 	return err;
1031 }
1032 
1033 static void print_key_value(struct bpf_map_info *info, void *key,
1034 			    void *value)
1035 {
1036 	json_writer_t *btf_wtr;
1037 	struct btf *btf = NULL;
1038 	int err;
1039 
1040 	err = btf__get_from_id(info->btf_id, &btf);
1041 	if (err) {
1042 		p_err("failed to get btf");
1043 		return;
1044 	}
1045 
1046 	if (json_output) {
1047 		print_entry_json(info, key, value, btf);
1048 	} else if (btf) {
1049 		/* if here json_wtr wouldn't have been initialised,
1050 		 * so let's create separate writer for btf
1051 		 */
1052 		btf_wtr = get_btf_writer();
1053 		if (!btf_wtr) {
1054 			p_info("failed to create json writer for btf. falling back to plain output");
1055 			btf__free(btf);
1056 			btf = NULL;
1057 			print_entry_plain(info, key, value);
1058 		} else {
1059 			struct btf_dumper d = {
1060 				.btf = btf,
1061 				.jw = btf_wtr,
1062 				.is_plain_text = true,
1063 			};
1064 
1065 			do_dump_btf(&d, info, key, value);
1066 			jsonw_destroy(&btf_wtr);
1067 		}
1068 	} else {
1069 		print_entry_plain(info, key, value);
1070 	}
1071 	btf__free(btf);
1072 }
1073 
1074 static int do_lookup(int argc, char **argv)
1075 {
1076 	struct bpf_map_info info = {};
1077 	__u32 len = sizeof(info);
1078 	void *key, *value;
1079 	int err;
1080 	int fd;
1081 
1082 	if (argc < 2)
1083 		usage();
1084 
1085 	fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1086 	if (fd < 0)
1087 		return -1;
1088 
1089 	err = alloc_key_value(&info, &key, &value);
1090 	if (err)
1091 		goto exit_free;
1092 
1093 	err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL);
1094 	if (err)
1095 		goto exit_free;
1096 
1097 	err = bpf_map_lookup_elem(fd, key, value);
1098 	if (err) {
1099 		if (errno == ENOENT) {
1100 			if (json_output) {
1101 				jsonw_null(json_wtr);
1102 			} else {
1103 				printf("key:\n");
1104 				fprint_hex(stdout, key, info.key_size, " ");
1105 				printf("\n\nNot found\n");
1106 			}
1107 		} else {
1108 			p_err("lookup failed: %s", strerror(errno));
1109 		}
1110 
1111 		goto exit_free;
1112 	}
1113 
1114 	/* here means bpf_map_lookup_elem() succeeded */
1115 	print_key_value(&info, key, value);
1116 
1117 exit_free:
1118 	free(key);
1119 	free(value);
1120 	close(fd);
1121 
1122 	return err;
1123 }
1124 
1125 static int do_getnext(int argc, char **argv)
1126 {
1127 	struct bpf_map_info info = {};
1128 	__u32 len = sizeof(info);
1129 	void *key, *nextkey;
1130 	int err;
1131 	int fd;
1132 
1133 	if (argc < 2)
1134 		usage();
1135 
1136 	fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1137 	if (fd < 0)
1138 		return -1;
1139 
1140 	key = malloc(info.key_size);
1141 	nextkey = malloc(info.key_size);
1142 	if (!key || !nextkey) {
1143 		p_err("mem alloc failed");
1144 		err = -1;
1145 		goto exit_free;
1146 	}
1147 
1148 	if (argc) {
1149 		err = parse_elem(argv, &info, key, NULL, info.key_size, 0,
1150 				 NULL, NULL);
1151 		if (err)
1152 			goto exit_free;
1153 	} else {
1154 		free(key);
1155 		key = NULL;
1156 	}
1157 
1158 	err = bpf_map_get_next_key(fd, key, nextkey);
1159 	if (err) {
1160 		p_err("can't get next key: %s", strerror(errno));
1161 		goto exit_free;
1162 	}
1163 
1164 	if (json_output) {
1165 		jsonw_start_object(json_wtr);
1166 		if (key) {
1167 			jsonw_name(json_wtr, "key");
1168 			print_hex_data_json(key, info.key_size);
1169 		} else {
1170 			jsonw_null_field(json_wtr, "key");
1171 		}
1172 		jsonw_name(json_wtr, "next_key");
1173 		print_hex_data_json(nextkey, info.key_size);
1174 		jsonw_end_object(json_wtr);
1175 	} else {
1176 		if (key) {
1177 			printf("key:\n");
1178 			fprint_hex(stdout, key, info.key_size, " ");
1179 			printf("\n");
1180 		} else {
1181 			printf("key: None\n");
1182 		}
1183 		printf("next key:\n");
1184 		fprint_hex(stdout, nextkey, info.key_size, " ");
1185 		printf("\n");
1186 	}
1187 
1188 exit_free:
1189 	free(nextkey);
1190 	free(key);
1191 	close(fd);
1192 
1193 	return err;
1194 }
1195 
1196 static int do_delete(int argc, char **argv)
1197 {
1198 	struct bpf_map_info info = {};
1199 	__u32 len = sizeof(info);
1200 	void *key;
1201 	int err;
1202 	int fd;
1203 
1204 	if (argc < 2)
1205 		usage();
1206 
1207 	fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1208 	if (fd < 0)
1209 		return -1;
1210 
1211 	key = malloc(info.key_size);
1212 	if (!key) {
1213 		p_err("mem alloc failed");
1214 		err = -1;
1215 		goto exit_free;
1216 	}
1217 
1218 	err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL);
1219 	if (err)
1220 		goto exit_free;
1221 
1222 	err = bpf_map_delete_elem(fd, key);
1223 	if (err)
1224 		p_err("delete failed: %s", strerror(errno));
1225 
1226 exit_free:
1227 	free(key);
1228 	close(fd);
1229 
1230 	if (!err && json_output)
1231 		jsonw_null(json_wtr);
1232 	return err;
1233 }
1234 
1235 static int do_pin(int argc, char **argv)
1236 {
1237 	int err;
1238 
1239 	err = do_pin_any(argc, argv, map_parse_fd);
1240 	if (!err && json_output)
1241 		jsonw_null(json_wtr);
1242 	return err;
1243 }
1244 
1245 static int do_create(int argc, char **argv)
1246 {
1247 	struct bpf_create_map_attr attr = { NULL, };
1248 	const char *pinfile;
1249 	int err, fd;
1250 
1251 	if (!REQ_ARGS(7))
1252 		return -1;
1253 	pinfile = GET_ARG();
1254 
1255 	while (argc) {
1256 		if (!REQ_ARGS(2))
1257 			return -1;
1258 
1259 		if (is_prefix(*argv, "type")) {
1260 			NEXT_ARG();
1261 
1262 			if (attr.map_type) {
1263 				p_err("map type already specified");
1264 				return -1;
1265 			}
1266 
1267 			attr.map_type = map_type_from_str(*argv);
1268 			if ((int)attr.map_type < 0) {
1269 				p_err("unrecognized map type: %s", *argv);
1270 				return -1;
1271 			}
1272 			NEXT_ARG();
1273 		} else if (is_prefix(*argv, "name")) {
1274 			NEXT_ARG();
1275 			attr.name = GET_ARG();
1276 		} else if (is_prefix(*argv, "key")) {
1277 			if (parse_u32_arg(&argc, &argv, &attr.key_size,
1278 					  "key size"))
1279 				return -1;
1280 		} else if (is_prefix(*argv, "value")) {
1281 			if (parse_u32_arg(&argc, &argv, &attr.value_size,
1282 					  "value size"))
1283 				return -1;
1284 		} else if (is_prefix(*argv, "entries")) {
1285 			if (parse_u32_arg(&argc, &argv, &attr.max_entries,
1286 					  "max entries"))
1287 				return -1;
1288 		} else if (is_prefix(*argv, "flags")) {
1289 			if (parse_u32_arg(&argc, &argv, &attr.map_flags,
1290 					  "flags"))
1291 				return -1;
1292 		} else if (is_prefix(*argv, "dev")) {
1293 			NEXT_ARG();
1294 
1295 			if (attr.map_ifindex) {
1296 				p_err("offload device already specified");
1297 				return -1;
1298 			}
1299 
1300 			attr.map_ifindex = if_nametoindex(*argv);
1301 			if (!attr.map_ifindex) {
1302 				p_err("unrecognized netdevice '%s': %s",
1303 				      *argv, strerror(errno));
1304 				return -1;
1305 			}
1306 			NEXT_ARG();
1307 		} else {
1308 			p_err("unknown arg %s", *argv);
1309 			return -1;
1310 		}
1311 	}
1312 
1313 	if (!attr.name) {
1314 		p_err("map name not specified");
1315 		return -1;
1316 	}
1317 
1318 	set_max_rlimit();
1319 
1320 	fd = bpf_create_map_xattr(&attr);
1321 	if (fd < 0) {
1322 		p_err("map create failed: %s", strerror(errno));
1323 		return -1;
1324 	}
1325 
1326 	err = do_pin_fd(fd, pinfile);
1327 	close(fd);
1328 	if (err)
1329 		return err;
1330 
1331 	if (json_output)
1332 		jsonw_null(json_wtr);
1333 	return 0;
1334 }
1335 
1336 static int do_pop_dequeue(int argc, char **argv)
1337 {
1338 	struct bpf_map_info info = {};
1339 	__u32 len = sizeof(info);
1340 	void *key, *value;
1341 	int err;
1342 	int fd;
1343 
1344 	if (argc < 2)
1345 		usage();
1346 
1347 	fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1348 	if (fd < 0)
1349 		return -1;
1350 
1351 	err = alloc_key_value(&info, &key, &value);
1352 	if (err)
1353 		goto exit_free;
1354 
1355 	err = bpf_map_lookup_and_delete_elem(fd, key, value);
1356 	if (err) {
1357 		if (errno == ENOENT) {
1358 			if (json_output)
1359 				jsonw_null(json_wtr);
1360 			else
1361 				printf("Error: empty map\n");
1362 		} else {
1363 			p_err("pop failed: %s", strerror(errno));
1364 		}
1365 
1366 		goto exit_free;
1367 	}
1368 
1369 	print_key_value(&info, key, value);
1370 
1371 exit_free:
1372 	free(key);
1373 	free(value);
1374 	close(fd);
1375 
1376 	return err;
1377 }
1378 
1379 static int do_freeze(int argc, char **argv)
1380 {
1381 	int err, fd;
1382 
1383 	if (!REQ_ARGS(2))
1384 		return -1;
1385 
1386 	fd = map_parse_fd(&argc, &argv);
1387 	if (fd < 0)
1388 		return -1;
1389 
1390 	if (argc) {
1391 		close(fd);
1392 		return BAD_ARG();
1393 	}
1394 
1395 	err = bpf_map_freeze(fd);
1396 	close(fd);
1397 	if (err) {
1398 		p_err("failed to freeze map: %s", strerror(errno));
1399 		return err;
1400 	}
1401 
1402 	if (json_output)
1403 		jsonw_null(json_wtr);
1404 
1405 	return 0;
1406 }
1407 
1408 static int do_help(int argc, char **argv)
1409 {
1410 	if (json_output) {
1411 		jsonw_null(json_wtr);
1412 		return 0;
1413 	}
1414 
1415 	fprintf(stderr,
1416 		"Usage: %1$s %2$s { show | list }   [MAP]\n"
1417 		"       %1$s %2$s create     FILE type TYPE key KEY_SIZE value VALUE_SIZE \\\n"
1418 		"                                  entries MAX_ENTRIES name NAME [flags FLAGS] \\\n"
1419 		"                                  [dev NAME]\n"
1420 		"       %1$s %2$s dump       MAP\n"
1421 		"       %1$s %2$s update     MAP [key DATA] [value VALUE] [UPDATE_FLAGS]\n"
1422 		"       %1$s %2$s lookup     MAP [key DATA]\n"
1423 		"       %1$s %2$s getnext    MAP [key DATA]\n"
1424 		"       %1$s %2$s delete     MAP  key DATA\n"
1425 		"       %1$s %2$s pin        MAP  FILE\n"
1426 		"       %1$s %2$s event_pipe MAP [cpu N index M]\n"
1427 		"       %1$s %2$s peek       MAP\n"
1428 		"       %1$s %2$s push       MAP value VALUE\n"
1429 		"       %1$s %2$s pop        MAP\n"
1430 		"       %1$s %2$s enqueue    MAP value VALUE\n"
1431 		"       %1$s %2$s dequeue    MAP\n"
1432 		"       %1$s %2$s freeze     MAP\n"
1433 		"       %1$s %2$s help\n"
1434 		"\n"
1435 		"       " HELP_SPEC_MAP "\n"
1436 		"       DATA := { [hex] BYTES }\n"
1437 		"       " HELP_SPEC_PROGRAM "\n"
1438 		"       VALUE := { DATA | MAP | PROG }\n"
1439 		"       UPDATE_FLAGS := { any | exist | noexist }\n"
1440 		"       TYPE := { hash | array | prog_array | perf_event_array | percpu_hash |\n"
1441 		"                 percpu_array | stack_trace | cgroup_array | lru_hash |\n"
1442 		"                 lru_percpu_hash | lpm_trie | array_of_maps | hash_of_maps |\n"
1443 		"                 devmap | devmap_hash | sockmap | cpumap | xskmap | sockhash |\n"
1444 		"                 cgroup_storage | reuseport_sockarray | percpu_cgroup_storage |\n"
1445 		"                 queue | stack | sk_storage | struct_ops | ringbuf }\n"
1446 		"       " HELP_SPEC_OPTIONS "\n"
1447 		"",
1448 		bin_name, argv[-2]);
1449 
1450 	return 0;
1451 }
1452 
1453 static const struct cmd cmds[] = {
1454 	{ "show",	do_show },
1455 	{ "list",	do_show },
1456 	{ "help",	do_help },
1457 	{ "dump",	do_dump },
1458 	{ "update",	do_update },
1459 	{ "lookup",	do_lookup },
1460 	{ "getnext",	do_getnext },
1461 	{ "delete",	do_delete },
1462 	{ "pin",	do_pin },
1463 	{ "event_pipe",	do_event_pipe },
1464 	{ "create",	do_create },
1465 	{ "peek",	do_lookup },
1466 	{ "push",	do_update },
1467 	{ "enqueue",	do_update },
1468 	{ "pop",	do_pop_dequeue },
1469 	{ "dequeue",	do_pop_dequeue },
1470 	{ "freeze",	do_freeze },
1471 	{ 0 }
1472 };
1473 
1474 int do_map(int argc, char **argv)
1475 {
1476 	return cmd_select(cmds, argc, argv, do_help);
1477 }
1478