xref: /openbmc/linux/tools/bpf/bpftool/main.c (revision e7253313)
1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
3 
4 #include <ctype.h>
5 #include <errno.h>
6 #include <getopt.h>
7 #include <linux/bpf.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 
12 #include <bpf.h>
13 #include <libbpf.h>
14 
15 #include "main.h"
16 
17 #define BATCH_LINE_LEN_MAX 65536
18 #define BATCH_ARG_NB_MAX 4096
19 
20 const char *bin_name;
21 static int last_argc;
22 static char **last_argv;
23 static int (*last_do_help)(int argc, char **argv);
24 json_writer_t *json_wtr;
25 bool pretty_output;
26 bool json_output;
27 bool show_pinned;
28 bool block_mount;
29 bool verifier_logs;
30 bool relaxed_maps;
31 struct pinned_obj_table prog_table;
32 struct pinned_obj_table map_table;
33 
34 static void __noreturn clean_and_exit(int i)
35 {
36 	if (json_output)
37 		jsonw_destroy(&json_wtr);
38 
39 	exit(i);
40 }
41 
42 void usage(void)
43 {
44 	last_do_help(last_argc - 1, last_argv + 1);
45 
46 	clean_and_exit(-1);
47 }
48 
49 static int do_help(int argc, char **argv)
50 {
51 	if (json_output) {
52 		jsonw_null(json_wtr);
53 		return 0;
54 	}
55 
56 	fprintf(stderr,
57 		"Usage: %s [OPTIONS] OBJECT { COMMAND | help }\n"
58 		"       %s batch file FILE\n"
59 		"       %s version\n"
60 		"\n"
61 		"       OBJECT := { prog | map | cgroup | perf | net | feature | btf }\n"
62 		"       " HELP_SPEC_OPTIONS "\n"
63 		"",
64 		bin_name, bin_name, bin_name);
65 
66 	return 0;
67 }
68 
69 static int do_version(int argc, char **argv)
70 {
71 	if (json_output) {
72 		jsonw_start_object(json_wtr);
73 		jsonw_name(json_wtr, "version");
74 		jsonw_printf(json_wtr, "\"%s\"", BPFTOOL_VERSION);
75 		jsonw_end_object(json_wtr);
76 	} else {
77 		printf("%s v%s\n", bin_name, BPFTOOL_VERSION);
78 	}
79 	return 0;
80 }
81 
82 static int __printf(2, 0)
83 print_all_levels(__maybe_unused enum libbpf_print_level level,
84 		 const char *format, va_list args)
85 {
86 	return vfprintf(stderr, format, args);
87 }
88 
89 int cmd_select(const struct cmd *cmds, int argc, char **argv,
90 	       int (*help)(int argc, char **argv))
91 {
92 	unsigned int i;
93 
94 	last_argc = argc;
95 	last_argv = argv;
96 	last_do_help = help;
97 
98 	if (argc < 1 && cmds[0].func)
99 		return cmds[0].func(argc, argv);
100 
101 	for (i = 0; cmds[i].func; i++)
102 		if (is_prefix(*argv, cmds[i].cmd))
103 			return cmds[i].func(argc - 1, argv + 1);
104 
105 	help(argc - 1, argv + 1);
106 
107 	return -1;
108 }
109 
110 bool is_prefix(const char *pfx, const char *str)
111 {
112 	if (!pfx)
113 		return false;
114 	if (strlen(str) < strlen(pfx))
115 		return false;
116 
117 	return !memcmp(str, pfx, strlen(pfx));
118 }
119 
120 /* Last argument MUST be NULL pointer */
121 int detect_common_prefix(const char *arg, ...)
122 {
123 	unsigned int count = 0;
124 	const char *ref;
125 	char msg[256];
126 	va_list ap;
127 
128 	snprintf(msg, sizeof(msg), "ambiguous prefix: '%s' could be '", arg);
129 	va_start(ap, arg);
130 	while ((ref = va_arg(ap, const char *))) {
131 		if (!is_prefix(arg, ref))
132 			continue;
133 		count++;
134 		if (count > 1)
135 			strncat(msg, "' or '", sizeof(msg) - strlen(msg) - 1);
136 		strncat(msg, ref, sizeof(msg) - strlen(msg) - 1);
137 	}
138 	va_end(ap);
139 	strncat(msg, "'", sizeof(msg) - strlen(msg) - 1);
140 
141 	if (count >= 2) {
142 		p_err("%s", msg);
143 		return -1;
144 	}
145 
146 	return 0;
147 }
148 
149 void fprint_hex(FILE *f, void *arg, unsigned int n, const char *sep)
150 {
151 	unsigned char *data = arg;
152 	unsigned int i;
153 
154 	for (i = 0; i < n; i++) {
155 		const char *pfx = "";
156 
157 		if (!i)
158 			/* nothing */;
159 		else if (!(i % 16))
160 			fprintf(f, "\n");
161 		else if (!(i % 8))
162 			fprintf(f, "  ");
163 		else
164 			pfx = sep;
165 
166 		fprintf(f, "%s%02hhx", i ? pfx : "", data[i]);
167 	}
168 }
169 
170 /* Split command line into argument vector. */
171 static int make_args(char *line, char *n_argv[], int maxargs, int cmd_nb)
172 {
173 	static const char ws[] = " \t\r\n";
174 	char *cp = line;
175 	int n_argc = 0;
176 
177 	while (*cp) {
178 		/* Skip leading whitespace. */
179 		cp += strspn(cp, ws);
180 
181 		if (*cp == '\0')
182 			break;
183 
184 		if (n_argc >= (maxargs - 1)) {
185 			p_err("too many arguments to command %d", cmd_nb);
186 			return -1;
187 		}
188 
189 		/* Word begins with quote. */
190 		if (*cp == '\'' || *cp == '"') {
191 			char quote = *cp++;
192 
193 			n_argv[n_argc++] = cp;
194 			/* Find ending quote. */
195 			cp = strchr(cp, quote);
196 			if (!cp) {
197 				p_err("unterminated quoted string in command %d",
198 				      cmd_nb);
199 				return -1;
200 			}
201 		} else {
202 			n_argv[n_argc++] = cp;
203 
204 			/* Find end of word. */
205 			cp += strcspn(cp, ws);
206 			if (*cp == '\0')
207 				break;
208 		}
209 
210 		/* Separate words. */
211 		*cp++ = 0;
212 	}
213 	n_argv[n_argc] = NULL;
214 
215 	return n_argc;
216 }
217 
218 static int do_batch(int argc, char **argv);
219 
220 static const struct cmd cmds[] = {
221 	{ "help",	do_help },
222 	{ "batch",	do_batch },
223 	{ "prog",	do_prog },
224 	{ "map",	do_map },
225 	{ "cgroup",	do_cgroup },
226 	{ "perf",	do_perf },
227 	{ "net",	do_net },
228 	{ "feature",	do_feature },
229 	{ "btf",	do_btf },
230 	{ "version",	do_version },
231 	{ 0 }
232 };
233 
234 static int do_batch(int argc, char **argv)
235 {
236 	char buf[BATCH_LINE_LEN_MAX], contline[BATCH_LINE_LEN_MAX];
237 	char *n_argv[BATCH_ARG_NB_MAX];
238 	unsigned int lines = 0;
239 	int n_argc;
240 	FILE *fp;
241 	char *cp;
242 	int err;
243 	int i;
244 
245 	if (argc < 2) {
246 		p_err("too few parameters for batch");
247 		return -1;
248 	} else if (!is_prefix(*argv, "file")) {
249 		p_err("expected 'file', got: %s", *argv);
250 		return -1;
251 	} else if (argc > 2) {
252 		p_err("too many parameters for batch");
253 		return -1;
254 	}
255 	NEXT_ARG();
256 
257 	if (!strcmp(*argv, "-"))
258 		fp = stdin;
259 	else
260 		fp = fopen(*argv, "r");
261 	if (!fp) {
262 		p_err("Can't open file (%s): %s", *argv, strerror(errno));
263 		return -1;
264 	}
265 
266 	if (json_output)
267 		jsonw_start_array(json_wtr);
268 	while (fgets(buf, sizeof(buf), fp)) {
269 		cp = strchr(buf, '#');
270 		if (cp)
271 			*cp = '\0';
272 
273 		if (strlen(buf) == sizeof(buf) - 1) {
274 			errno = E2BIG;
275 			break;
276 		}
277 
278 		/* Append continuation lines if any (coming after a line ending
279 		 * with '\' in the batch file).
280 		 */
281 		while ((cp = strstr(buf, "\\\n")) != NULL) {
282 			if (!fgets(contline, sizeof(contline), fp) ||
283 			    strlen(contline) == 0) {
284 				p_err("missing continuation line on command %d",
285 				      lines);
286 				err = -1;
287 				goto err_close;
288 			}
289 
290 			cp = strchr(contline, '#');
291 			if (cp)
292 				*cp = '\0';
293 
294 			if (strlen(buf) + strlen(contline) + 1 > sizeof(buf)) {
295 				p_err("command %d is too long", lines);
296 				err = -1;
297 				goto err_close;
298 			}
299 			buf[strlen(buf) - 2] = '\0';
300 			strcat(buf, contline);
301 		}
302 
303 		n_argc = make_args(buf, n_argv, BATCH_ARG_NB_MAX, lines);
304 		if (!n_argc)
305 			continue;
306 		if (n_argc < 0)
307 			goto err_close;
308 
309 		if (json_output) {
310 			jsonw_start_object(json_wtr);
311 			jsonw_name(json_wtr, "command");
312 			jsonw_start_array(json_wtr);
313 			for (i = 0; i < n_argc; i++)
314 				jsonw_string(json_wtr, n_argv[i]);
315 			jsonw_end_array(json_wtr);
316 			jsonw_name(json_wtr, "output");
317 		}
318 
319 		err = cmd_select(cmds, n_argc, n_argv, do_help);
320 
321 		if (json_output)
322 			jsonw_end_object(json_wtr);
323 
324 		if (err)
325 			goto err_close;
326 
327 		lines++;
328 	}
329 
330 	if (errno && errno != ENOENT) {
331 		p_err("reading batch file failed: %s", strerror(errno));
332 		err = -1;
333 	} else {
334 		if (!json_output)
335 			printf("processed %d commands\n", lines);
336 		err = 0;
337 	}
338 err_close:
339 	if (fp != stdin)
340 		fclose(fp);
341 
342 	if (json_output)
343 		jsonw_end_array(json_wtr);
344 
345 	return err;
346 }
347 
348 int main(int argc, char **argv)
349 {
350 	static const struct option options[] = {
351 		{ "json",	no_argument,	NULL,	'j' },
352 		{ "help",	no_argument,	NULL,	'h' },
353 		{ "pretty",	no_argument,	NULL,	'p' },
354 		{ "version",	no_argument,	NULL,	'V' },
355 		{ "bpffs",	no_argument,	NULL,	'f' },
356 		{ "mapcompat",	no_argument,	NULL,	'm' },
357 		{ "nomount",	no_argument,	NULL,	'n' },
358 		{ "debug",	no_argument,	NULL,	'd' },
359 		{ 0 }
360 	};
361 	int opt, ret;
362 
363 	last_do_help = do_help;
364 	pretty_output = false;
365 	json_output = false;
366 	show_pinned = false;
367 	block_mount = false;
368 	bin_name = argv[0];
369 
370 	hash_init(prog_table.table);
371 	hash_init(map_table.table);
372 
373 	opterr = 0;
374 	while ((opt = getopt_long(argc, argv, "Vhpjfmnd",
375 				  options, NULL)) >= 0) {
376 		switch (opt) {
377 		case 'V':
378 			return do_version(argc, argv);
379 		case 'h':
380 			return do_help(argc, argv);
381 		case 'p':
382 			pretty_output = true;
383 			/* fall through */
384 		case 'j':
385 			if (!json_output) {
386 				json_wtr = jsonw_new(stdout);
387 				if (!json_wtr) {
388 					p_err("failed to create JSON writer");
389 					return -1;
390 				}
391 				json_output = true;
392 			}
393 			jsonw_pretty(json_wtr, pretty_output);
394 			break;
395 		case 'f':
396 			show_pinned = true;
397 			break;
398 		case 'm':
399 			relaxed_maps = true;
400 			break;
401 		case 'n':
402 			block_mount = true;
403 			break;
404 		case 'd':
405 			libbpf_set_print(print_all_levels);
406 			verifier_logs = true;
407 			break;
408 		default:
409 			p_err("unrecognized option '%s'", argv[optind - 1]);
410 			if (json_output)
411 				clean_and_exit(-1);
412 			else
413 				usage();
414 		}
415 	}
416 
417 	argc -= optind;
418 	argv += optind;
419 	if (argc < 0)
420 		usage();
421 
422 	ret = cmd_select(cmds, argc, argv, do_help);
423 
424 	if (json_output)
425 		jsonw_destroy(&json_wtr);
426 
427 	if (show_pinned) {
428 		delete_pinned_obj_table(&prog_table);
429 		delete_pinned_obj_table(&map_table);
430 	}
431 
432 	return ret;
433 }
434