[linux-block.git] / tools / bpf / bpftool / main.c

/*
 * Copyright (C) 2017 Netronome Systems, Inc.
 *
 * This software is dual licensed under the GNU General License Version 2,
 * June 1991 as shown in the file COPYING in the top-level directory of this
 * source tree or the BSD 2-Clause License provided below.  You have the
 * option to license this software under the complete terms of either license.
 *
 * The BSD 2-Clause License:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      1. Redistributions of source code must retain the above
 *         copyright notice, this list of conditions and the following
 *         disclaimer.
 *
 *      2. Redistributions in binary form must reproduce the above
 *         copyright notice, this list of conditions and the following
 *         disclaimer in the documentation and/or other materials
 *         provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/* Author: Jakub Kicinski <kubakici@wp.pl> */

#include <bfd.h>
#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <linux/bpf.h>
#include <linux/version.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <bpf.h>

#include "main.h"

const char *bin_name;
static int last_argc;
static char **last_argv;
static int (*last_do_help)(int argc, char **argv);
json_writer_t *json_wtr;
bool pretty_output;
bool json_output;
bool show_pinned;
struct pinned_obj_table prog_table;
struct pinned_obj_table map_table;

static void __noreturn clean_and_exit(int i)
{
	if (json_output)
		jsonw_destroy(&json_wtr);

	exit(i);
}

void usage(void)
{
	last_do_help(last_argc - 1, last_argv + 1);

	clean_and_exit(-1);
}

static int do_help(int argc, char **argv)
{
	if (json_output) {
		jsonw_null(json_wtr);
		return 0;
	}

	fprintf(stderr,
		"Usage: %s [OPTIONS] OBJECT { COMMAND | help }\n"
		"       %s batch file FILE\n"
		"       %s version\n"
		"\n"
		"       OBJECT := { prog | map }\n"
		"       " HELP_SPEC_OPTIONS "\n"
		"",
		bin_name, bin_name, bin_name);

	return 0;
}

static int do_version(int argc, char **argv)
{
	unsigned int version[3];

	version[0] = LINUX_VERSION_CODE >> 16;
	version[1] = LINUX_VERSION_CODE >> 8 & 0xf;
	version[2] = LINUX_VERSION_CODE & 0xf;

	if (json_output) {
		jsonw_start_object(json_wtr);
		jsonw_name(json_wtr, "version");
		jsonw_printf(json_wtr, "\"%u.%u.%u\"",
			     version[0], version[1], version[2]);
		jsonw_end_object(json_wtr);
	} else {
		printf("%s v%u.%u.%u\n", bin_name,
		       version[0], version[1], version[2]);
	}
	return 0;
}

int cmd_select(const struct cmd *cmds, int argc, char **argv,
	       int (*help)(int argc, char **argv))
{
	unsigned int i;

	last_argc = argc;
	last_argv = argv;
	last_do_help = help;

	if (argc < 1 && cmds[0].func)
		return cmds[0].func(argc, argv);

	for (i = 0; cmds[i].func; i++)
		if (is_prefix(*argv, cmds[i].cmd))
			return cmds[i].func(argc - 1, argv + 1);

	help(argc - 1, argv + 1);

	return -1;
}

bool is_prefix(const char *pfx, const char *str)
{
	if (!pfx)
		return false;
	if (strlen(str) < strlen(pfx))
		return false;

	return !memcmp(str, pfx, strlen(pfx));
}

void fprint_hex(FILE *f, void *arg, unsigned int n, const char *sep)
{
	unsigned char *data = arg;
	unsigned int i;

	for (i = 0; i < n; i++) {
		const char *pfx = "";

		if (!i)
			/* nothing */;
		else if (!(i % 16))
			fprintf(f, "\n");
		else if (!(i % 8))
			fprintf(f, "  ");
		else
			pfx = sep;

		fprintf(f, "%s%02hhx", i ? pfx : "", data[i]);
	}
}

static int do_batch(int argc, char **argv);

static const struct cmd cmds[] = {
	{ "help",	do_help },
	{ "batch",	do_batch },
	{ "prog",	do_prog },
	{ "map",	do_map },
	{ "version",	do_version },
	{ 0 }
};

static int do_batch(int argc, char **argv)
{
	unsigned int lines = 0;
	char *n_argv[4096];
	char buf[65536];
	int n_argc;
	FILE *fp;
	int err;
	int i;

	if (argc < 2) {
		p_err("too few parameters for batch");
		return -1;
	} else if (!is_prefix(*argv, "file")) {
		p_err("expected 'file', got: %s", *argv);
		return -1;
	} else if (argc > 2) {
		p_err("too many parameters for batch");
		return -1;
	}
	NEXT_ARG();

	fp = fopen(*argv, "r");
	if (!fp) {
		p_err("Can't open file (%s): %s", *argv, strerror(errno));
		return -1;
	}

	if (json_output)
		jsonw_start_array(json_wtr);
	while (fgets(buf, sizeof(buf), fp)) {
		if (strlen(buf) == sizeof(buf) - 1) {
			errno = E2BIG;
			break;
		}

		n_argc = 0;
		n_argv[n_argc] = strtok(buf, " \t\n");

		while (n_argv[n_argc]) {
			n_argc++;
			if (n_argc == ARRAY_SIZE(n_argv)) {
				p_err("line %d has too many arguments, skip",
				      lines);
				n_argc = 0;
				break;
			}
			n_argv[n_argc] = strtok(NULL, " \t\n");
		}

		if (!n_argc)
			continue;

		if (json_output) {
			jsonw_start_object(json_wtr);
			jsonw_name(json_wtr, "command");
			jsonw_start_array(json_wtr);
			for (i = 0; i < n_argc; i++)
				jsonw_string(json_wtr, n_argv[i]);
			jsonw_end_array(json_wtr);
			jsonw_name(json_wtr, "output");
		}

		err = cmd_select(cmds, n_argc, n_argv, do_help);

		if (json_output)
			jsonw_end_object(json_wtr);

		if (err)
			goto err_close;

		lines++;
	}

	if (errno && errno != ENOENT) {
		perror("reading batch file failed");
		err = -1;
	} else {
		p_info("processed %d lines", lines);
		err = 0;
	}
err_close:
	fclose(fp);

	if (json_output)
		jsonw_end_array(json_wtr);

	return err;
}

int main(int argc, char **argv)
{
	static const struct option options[] = {
		{ "json",	no_argument,	NULL,	'j' },
		{ "help",	no_argument,	NULL,	'h' },
		{ "pretty",	no_argument,	NULL,	'p' },
		{ "version",	no_argument,	NULL,	'V' },
		{ "bpffs",	no_argument,	NULL,	'f' },
		{ 0 }
	};
	int opt, ret;

	last_do_help = do_help;
	pretty_output = false;
	json_output = false;
	show_pinned = false;
	bin_name = argv[0];

	hash_init(prog_table.table);
	hash_init(map_table.table);

	opterr = 0;
	while ((opt = getopt_long(argc, argv, "Vhpjf",
				  options, NULL)) >= 0) {
		switch (opt) {
		case 'V':
			return do_version(argc, argv);
		case 'h':
			return do_help(argc, argv);
		case 'p':
			pretty_output = true;
			/* fall through */
		case 'j':
			if (!json_output) {
				json_wtr = jsonw_new(stdout);
				if (!json_wtr) {
					p_err("failed to create JSON writer");
					return -1;
				}
				json_output = true;
			}
			jsonw_pretty(json_wtr, pretty_output);
			break;
		case 'f':
			show_pinned = true;
			break;
		default:
			p_err("unrecognized option '%s'", argv[optind - 1]);
			if (json_output)
				clean_and_exit(-1);
			else
				usage();
		}
	}

	argc -= optind;
	argv += optind;
	if (argc < 0)
		usage();

	bfd_init();

	ret = cmd_select(cmds, argc, argv, do_help);

	if (json_output)
		jsonw_destroy(&json_wtr);

	if (show_pinned) {
		delete_pinned_obj_table(&prog_table);
		delete_pinned_obj_table(&map_table);
	}

	return ret;
}
Commit	Line	Data
71bb428f JK	1	/*
	2	* Copyright (C) 2017 Netronome Systems, Inc.
	3	*
	4	* This software is dual licensed under the GNU General License Version 2,
	5	* June 1991 as shown in the file COPYING in the top-level directory of this
	6	* source tree or the BSD 2-Clause License provided below. You have the
	7	* option to license this software under the complete terms of either license.
	8	*
	9	* The BSD 2-Clause License:
	10	*
	11	* Redistribution and use in source and binary forms, with or
	12	* without modification, are permitted provided that the following
	13	* conditions are met:
	14	*
	15	* 1. Redistributions of source code must retain the above
	16	* copyright notice, this list of conditions and the following
	17	* disclaimer.
	18	*
	19	* 2. Redistributions in binary form must reproduce the above
	20	* copyright notice, this list of conditions and the following
	21	* disclaimer in the documentation and/or other materials
	22	* provided with the distribution.
	23	*
	24	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	25	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	26	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	27	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	28	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	29	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	30	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	31	* SOFTWARE.
	32	*/
	33
	34	/* Author: Jakub Kicinski <kubakici@wp.pl> */
	35
	36	#include <bfd.h>
	37	#include <ctype.h>
	38	#include <errno.h>
a2bc2e5c	39	#include <getopt.h>
71bb428f	40	#include <linux/bpf.h>
821cfbb0	41	#include <linux/version.h>
71bb428f JK	42	#include <stdio.h>
	43	#include <stdlib.h>
	44	#include <string.h>
	45
	46	#include <bpf.h>
	47
	48	#include "main.h"
	49
	50	const char *bin_name;
	51	static int last_argc;
	52	static char **last_argv;
	53	static int (last_do_help)(int argc, char *argv);
d35efba9 QM	54	json_writer_t *json_wtr;
	55	bool pretty_output;
	56	bool json_output;
c541b734	57	bool show_pinned;
4990f1f4 PB	58	struct pinned_obj_table prog_table;
4990f1f4 PB	59	struct pinned_obj_table map_table;
71bb428f	60
7868620a QM	61	static void __noreturn clean_and_exit(int i)
	62	{
	63	if (json_output)
	64	jsonw_destroy(&json_wtr);
	65
	66	exit(i);
	67	}
	68
71bb428f JK	69	void usage(void)
	70	{
	71	last_do_help(last_argc - 1, last_argv + 1);
	72
7868620a	73	clean_and_exit(-1);
71bb428f JK	74	}
	75
	76	static int do_help(int argc, char **argv)
	77	{
004b45c0 QM	78	if (json_output) {
	79	jsonw_null(json_wtr);
	80	return 0;
	81	}
	82
71bb428f	83	fprintf(stderr,
0641c3c8	84	"Usage: %s [OPTIONS] OBJECT { COMMAND \| help }\n"
71bb428f	85	" %s batch file FILE\n"
821cfbb0	86	" %s version\n"
71bb428f	87	"\n"
0641c3c8 QM	88	" OBJECT := { prog \| map }\n"
	89	" " HELP_SPEC_OPTIONS "\n"
	90	"",
821cfbb0	91	bin_name, bin_name, bin_name);
71bb428f JK	92
	93	return 0;
	94	}
	95
821cfbb0 QM	96	static int do_version(int argc, char **argv)
821cfbb0 QM	97	{
004b45c0 QM	98	unsigned int version[3];
	99
	100	version[0] = LINUX_VERSION_CODE >> 16;
	101	version[1] = LINUX_VERSION_CODE >> 8 & 0xf;
	102	version[2] = LINUX_VERSION_CODE & 0xf;
	103
	104	if (json_output) {
	105	jsonw_start_object(json_wtr);
	106	jsonw_name(json_wtr, "version");
	107	jsonw_printf(json_wtr, "\"%u.%u.%u\"",
	108	version[0], version[1], version[2]);
	109	jsonw_end_object(json_wtr);
	110	} else {
	111	printf("%s v%u.%u.%u\n", bin_name,
	112	version[0], version[1], version[2]);
	113	}
821cfbb0 QM	114	return 0;
	115	}
	116
71bb428f JK	117	int cmd_select(const struct cmd cmds, int argc, char *argv,
	118	int (help)(int argc, char *argv))
	119	{
	120	unsigned int i;
	121
	122	last_argc = argc;
	123	last_argv = argv;
	124	last_do_help = help;
	125
	126	if (argc < 1 && cmds[0].func)
	127	return cmds[0].func(argc, argv);
	128
	129	for (i = 0; cmds[i].func; i++)
	130	if (is_prefix(*argv, cmds[i].cmd))
	131	return cmds[i].func(argc - 1, argv + 1);
	132
	133	help(argc - 1, argv + 1);
	134
	135	return -1;
	136	}
	137
	138	bool is_prefix(const char pfx, const char str)
	139	{
	140	if (!pfx)
	141	return false;
	142	if (strlen(str) < strlen(pfx))
	143	return false;
	144
	145	return !memcmp(str, pfx, strlen(pfx));
	146	}
	147
9cbe1f58	148	void fprint_hex(FILE f, void arg, unsigned int n, const char *sep)
71bb428f JK	149	{
	150	unsigned char *data = arg;
	151	unsigned int i;
	152
	153	for (i = 0; i < n; i++) {
	154	const char *pfx = "";
	155
	156	if (!i)
	157	/* nothing */;
	158	else if (!(i % 16))
9cbe1f58	159	fprintf(f, "\n");
71bb428f	160	else if (!(i % 8))
9cbe1f58	161	fprintf(f, " ");
71bb428f JK	162	else
	163	pfx = sep;
	164
9cbe1f58	165	fprintf(f, "%s%02hhx", i ? pfx : "", data[i]);
71bb428f JK	166	}
	167	}
	168
	169	static int do_batch(int argc, char **argv);
	170
	171	static const struct cmd cmds[] = {
	172	{ "help", do_help },
	173	{ "batch", do_batch },
	174	{ "prog", do_prog },
	175	{ "map", do_map },
821cfbb0	176	{ "version", do_version },
71bb428f JK	177	{ 0 }
	178	};
	179
	180	static int do_batch(int argc, char **argv)
	181	{
	182	unsigned int lines = 0;
	183	char *n_argv[4096];
	184	char buf[65536];
	185	int n_argc;
	186	FILE *fp;
	187	int err;
3aaca6bf	188	int i;
71bb428f JK	189
71bb428f JK	190	if (argc < 2) {
9a5ab8bf	191	p_err("too few parameters for batch");
71bb428f JK	192	return -1;
71bb428f JK	193	} else if (!is_prefix(*argv, "file")) {
9a5ab8bf	194	p_err("expected 'file', got: %s", *argv);
71bb428f JK	195	return -1;
71bb428f JK	196	} else if (argc > 2) {
9a5ab8bf	197	p_err("too many parameters for batch");
71bb428f JK	198	return -1;
	199	}
	200	NEXT_ARG();
	201
	202	fp = fopen(*argv, "r");
	203	if (!fp) {
9a5ab8bf	204	p_err("Can't open file (%s): %s", *argv, strerror(errno));
71bb428f JK	205	return -1;
	206	}
	207
3aaca6bf QM	208	if (json_output)
3aaca6bf QM	209	jsonw_start_array(json_wtr);
71bb428f JK	210	while (fgets(buf, sizeof(buf), fp)) {
	211	if (strlen(buf) == sizeof(buf) - 1) {
	212	errno = E2BIG;
	213	break;
	214	}
	215
	216	n_argc = 0;
	217	n_argv[n_argc] = strtok(buf, " \t\n");
	218
	219	while (n_argv[n_argc]) {
	220	n_argc++;
	221	if (n_argc == ARRAY_SIZE(n_argv)) {
9a5ab8bf QM	222	p_err("line %d has too many arguments, skip",
9a5ab8bf QM	223	lines);
71bb428f JK	224	n_argc = 0;
	225	break;
	226	}
	227	n_argv[n_argc] = strtok(NULL, " \t\n");
	228	}
	229
	230	if (!n_argc)
	231	continue;
	232
3aaca6bf QM	233	if (json_output) {
	234	jsonw_start_object(json_wtr);
	235	jsonw_name(json_wtr, "command");
	236	jsonw_start_array(json_wtr);
	237	for (i = 0; i < n_argc; i++)
	238	jsonw_string(json_wtr, n_argv[i]);
	239	jsonw_end_array(json_wtr);
	240	jsonw_name(json_wtr, "output");
	241	}
	242
71bb428f	243	err = cmd_select(cmds, n_argc, n_argv, do_help);
3aaca6bf QM	244
	245	if (json_output)
	246	jsonw_end_object(json_wtr);
	247
71bb428f JK	248	if (err)
	249	goto err_close;
	250
	251	lines++;
	252	}
	253
	254	if (errno && errno != ENOENT) {
	255	perror("reading batch file failed");
	256	err = -1;
	257	} else {
9a5ab8bf	258	p_info("processed %d lines", lines);
71bb428f JK	259	err = 0;
	260	}
	261	err_close:
	262	fclose(fp);
	263
3aaca6bf QM	264	if (json_output)
	265	jsonw_end_array(json_wtr);
	266
71bb428f JK	267	return err;
	268	}
	269
	270	int main(int argc, char **argv)
	271	{
a2bc2e5c	272	static const struct option options[] = {
d35efba9	273	{ "json", no_argument, NULL, 'j' },
a2bc2e5c	274	{ "help", no_argument, NULL, 'h' },
d35efba9	275	{ "pretty", no_argument, NULL, 'p' },
a2bc2e5c	276	{ "version", no_argument, NULL, 'V' },
c541b734	277	{ "bpffs", no_argument, NULL, 'f' },
a2bc2e5c QM	278	{ 0 }
a2bc2e5c QM	279	};
d35efba9	280	int opt, ret;
a2bc2e5c QM	281
a2bc2e5c QM	282	last_do_help = do_help;
d35efba9 QM	283	pretty_output = false;
d35efba9 QM	284	json_output = false;
c541b734	285	show_pinned = false;
71bb428f	286	bin_name = argv[0];
a2bc2e5c	287
4990f1f4 PB	288	hash_init(prog_table.table);
	289	hash_init(map_table.table);
	290
146882a3	291	opterr = 0;
c541b734	292	while ((opt = getopt_long(argc, argv, "Vhpjf",
a2bc2e5c QM	293	options, NULL)) >= 0) {
	294	switch (opt) {
	295	case 'V':
	296	return do_version(argc, argv);
	297	case 'h':
	298	return do_help(argc, argv);
d35efba9 QM	299	case 'p':
	300	pretty_output = true;
	301	/* fall through */
	302	case 'j':
9b85c2d4 QM	303	if (!json_output) {
	304	json_wtr = jsonw_new(stdout);
	305	if (!json_wtr) {
	306	p_err("failed to create JSON writer");
	307	return -1;
	308	}
	309	json_output = true;
	310	}
	311	jsonw_pretty(json_wtr, pretty_output);
d35efba9	312	break;
c541b734 PB	313	case 'f':
	314	show_pinned = true;
	315	break;
a2bc2e5c	316	default:
146882a3 QM	317	p_err("unrecognized option '%s'", argv[optind - 1]);
	318	if (json_output)
	319	clean_and_exit(-1);
	320	else
	321	usage();
a2bc2e5c QM	322	}
	323	}
	324
	325	argc -= optind;
	326	argv += optind;
	327	if (argc < 0)
	328	usage();
71bb428f JK	329
	330	bfd_init();
	331
d35efba9 QM	332	ret = cmd_select(cmds, argc, argv, do_help);
	333
	334	if (json_output)
	335	jsonw_destroy(&json_wtr);
	336
c541b734 PB	337	if (show_pinned) {
	338	delete_pinned_obj_table(&prog_table);
	339	delete_pinned_obj_table(&map_table);
	340	}
4990f1f4	341
d35efba9	342	return ret;
71bb428f	343	}