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

// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
/* Copyright (C) 2020 Facebook */

#include <errno.h>
#include <stdio.h>
#include <unistd.h>

#include <linux/err.h>

#include <bpf/bpf.h>
#include <bpf/btf.h>
#include <bpf/libbpf.h>

#include "json_writer.h"
#include "main.h"

#define STRUCT_OPS_VALUE_PREFIX "bpf_struct_ops_"

static const struct btf_type *map_info_type;
static __u32 map_info_alloc_len;
static struct btf *btf_vmlinux;
static __s32 map_info_type_id;

struct res {
	unsigned int nr_maps;
	unsigned int nr_errs;
};

static const struct btf *get_btf_vmlinux(void)
{
	if (btf_vmlinux)
		return btf_vmlinux;

	btf_vmlinux = libbpf_find_kernel_btf();
	if (!btf_vmlinux)
		p_err("struct_ops requires kernel CONFIG_DEBUG_INFO_BTF=y");

	return btf_vmlinux;
}

static const char *get_kern_struct_ops_name(const struct bpf_map_info *info)
{
	const struct btf *kern_btf;
	const struct btf_type *t;
	const char *st_ops_name;

	kern_btf = get_btf_vmlinux();
	if (!kern_btf)
		return "<btf_vmlinux_not_found>";

	t = btf__type_by_id(kern_btf, info->btf_vmlinux_value_type_id);
	st_ops_name = btf__name_by_offset(kern_btf, t->name_off);
	st_ops_name += strlen(STRUCT_OPS_VALUE_PREFIX);

	return st_ops_name;
}

static __s32 get_map_info_type_id(void)
{
	const struct btf *kern_btf;

	if (map_info_type_id)
		return map_info_type_id;

	kern_btf = get_btf_vmlinux();
	if (!kern_btf)
		return 0;

	map_info_type_id = btf__find_by_name_kind(kern_btf, "bpf_map_info",
						  BTF_KIND_STRUCT);
	if (map_info_type_id < 0) {
		p_err("can't find bpf_map_info from btf_vmlinux");
		return map_info_type_id;
	}
	map_info_type = btf__type_by_id(kern_btf, map_info_type_id);

	/* Ensure map_info_alloc() has at least what the bpftool needs */
	map_info_alloc_len = map_info_type->size;
	if (map_info_alloc_len < sizeof(struct bpf_map_info))
		map_info_alloc_len = sizeof(struct bpf_map_info);

	return map_info_type_id;
}

/* If the subcmd needs to print out the bpf_map_info,
 * it should always call map_info_alloc to allocate
 * a bpf_map_info object instead of allocating it
 * on the stack.
 *
 * map_info_alloc() will take the running kernel's btf
 * into account.  i.e. it will consider the
 * sizeof(struct bpf_map_info) of the running kernel.
 *
 * It will enable the "struct_ops" cmd to print the latest
 * "struct bpf_map_info".
 *
 * [ Recall that "struct_ops" requires the kernel's btf to
 *   be available ]
 */
static struct bpf_map_info *map_info_alloc(__u32 *alloc_len)
{
	struct bpf_map_info *info;

	if (get_map_info_type_id() < 0)
		return NULL;

	info = calloc(1, map_info_alloc_len);
	if (!info)
		p_err("mem alloc failed");
	else
		*alloc_len = map_info_alloc_len;

	return info;
}

/* It iterates all struct_ops maps of the system.
 * It returns the fd in "*res_fd" and map_info in "*info".
 * In the very first iteration, info->id should be 0.
 * An optional map "*name" filter can be specified.
 * The filter can be made more flexible in the future.
 * e.g. filter by kernel-struct-ops-name, regex-name, glob-name, ...etc.
 *
 * Return value:
 *     1: A struct_ops map found.  It is returned in "*res_fd" and "*info".
 *	  The caller can continue to call get_next in the future.
 *     0: No struct_ops map is returned.
 *        All struct_ops map has been found.
 *    -1: Error and the caller should abort the iteration.
 */
static int get_next_struct_ops_map(const char *name, int *res_fd,
				   struct bpf_map_info *info, __u32 info_len)
{
	__u32 id = info->id;
	int err, fd;

	while (true) {
		err = bpf_map_get_next_id(id, &id);
		if (err) {
			if (errno == ENOENT)
				return 0;
			p_err("can't get next map: %s", strerror(errno));
			return -1;
		}

		fd = bpf_map_get_fd_by_id(id);
		if (fd < 0) {
			if (errno == ENOENT)
				continue;
			p_err("can't get map by id (%u): %s",
			      id, strerror(errno));
			return -1;
		}

		err = bpf_map_get_info_by_fd(fd, info, &info_len);
		if (err) {
			p_err("can't get map info: %s", strerror(errno));
			close(fd);
			return -1;
		}

		if (info->type == BPF_MAP_TYPE_STRUCT_OPS &&
		    (!name || !strcmp(name, info->name))) {
			*res_fd = fd;
			return 1;
		}
		close(fd);
	}
}

static int cmd_retval(const struct res *res, bool must_have_one_map)
{
	if (res->nr_errs || (!res->nr_maps && must_have_one_map))
		return -1;

	return 0;
}

/* "data" is the work_func private storage */
typedef int (*work_func)(int fd, const struct bpf_map_info *info, void *data,
			 struct json_writer *wtr);

/* Find all struct_ops map in the system.
 * Filter out by "name" (if specified).
 * Then call "func(fd, info, data, wtr)" on each struct_ops map found.
 */
static struct res do_search(const char *name, work_func func, void *data,
			    struct json_writer *wtr)
{
	struct bpf_map_info *info;
	struct res res = {};
	__u32 info_len;
	int fd, err;

	info = map_info_alloc(&info_len);
	if (!info) {
		res.nr_errs++;
		return res;
	}

	if (wtr)
		jsonw_start_array(wtr);
	while ((err = get_next_struct_ops_map(name, &fd, info, info_len)) == 1) {
		res.nr_maps++;
		err = func(fd, info, data, wtr);
		if (err)
			res.nr_errs++;
		close(fd);
	}
	if (wtr)
		jsonw_end_array(wtr);

	if (err)
		res.nr_errs++;

	if (!wtr && name && !res.nr_errs && !res.nr_maps)
		/* It is not printing empty [].
		 * Thus, needs to specifically say nothing found
		 * for "name" here.
		 */
		p_err("no struct_ops found for %s", name);
	else if (!wtr && json_output && !res.nr_errs)
		/* The "func()" above is not writing any json (i.e. !wtr
		 * test here).
		 *
		 * However, "-j" is enabled and there is no errs here,
		 * so call json_null() as the current convention of
		 * other cmds.
		 */
		jsonw_null(json_wtr);

	free(info);
	return res;
}

static struct res do_one_id(const char *id_str, work_func func, void *data,
			    struct json_writer *wtr)
{
	struct bpf_map_info *info;
	struct res res = {};
	unsigned long id;
	__u32 info_len;
	char *endptr;
	int fd;

	id = strtoul(id_str, &endptr, 0);
	if (*endptr || !id || id > UINT32_MAX) {
		p_err("invalid id %s", id_str);
		res.nr_errs++;
		return res;
	}

	fd = bpf_map_get_fd_by_id(id);
	if (fd < 0) {
		p_err("can't get map by id (%lu): %s", id, strerror(errno));
		res.nr_errs++;
		return res;
	}

	info = map_info_alloc(&info_len);
	if (!info) {
		res.nr_errs++;
		goto done;
	}

	if (bpf_map_get_info_by_fd(fd, info, &info_len)) {
		p_err("can't get map info: %s", strerror(errno));
		res.nr_errs++;
		goto done;
	}

	if (info->type != BPF_MAP_TYPE_STRUCT_OPS) {
		p_err("%s id %u is not a struct_ops map", info->name, info->id);
		res.nr_errs++;
		goto done;
	}

	res.nr_maps++;

	if (func(fd, info, data, wtr))
		res.nr_errs++;
	else if (!wtr && json_output)
		/* The "func()" above is not writing any json (i.e. !wtr
		 * test here).
		 *
		 * However, "-j" is enabled and there is no errs here,
		 * so call json_null() as the current convention of
		 * other cmds.
		 */
		jsonw_null(json_wtr);

done:
	free(info);
	close(fd);

	return res;
}

static struct res do_work_on_struct_ops(const char *search_type,
					const char *search_term,
					work_func func, void *data,
					struct json_writer *wtr)
{
	if (search_type) {
		if (is_prefix(search_type, "id"))
			return do_one_id(search_term, func, data, wtr);
		else if (!is_prefix(search_type, "name"))
			usage();
	}

	return do_search(search_term, func, data, wtr);
}

static int __do_show(int fd, const struct bpf_map_info *info, void *data,
		     struct json_writer *wtr)
{
	if (wtr) {
		jsonw_start_object(wtr);
		jsonw_uint_field(wtr, "id", info->id);
		jsonw_string_field(wtr, "name", info->name);
		jsonw_string_field(wtr, "kernel_struct_ops",
				   get_kern_struct_ops_name(info));
		jsonw_end_object(wtr);
	} else {
		printf("%u: %-15s %-32s\n", info->id, info->name,
		       get_kern_struct_ops_name(info));
	}

	return 0;
}

static int do_show(int argc, char **argv)
{
	const char *search_type = NULL, *search_term = NULL;
	struct res res;

	if (argc && argc != 2)
		usage();

	if (argc == 2) {
		search_type = GET_ARG();
		search_term = GET_ARG();
	}

	res = do_work_on_struct_ops(search_type, search_term, __do_show,
				    NULL, json_wtr);

	return cmd_retval(&res, !!search_term);
}

static int __do_dump(int fd, const struct bpf_map_info *info, void *data,
		     struct json_writer *wtr)
{
	struct btf_dumper *d = (struct btf_dumper *)data;
	const struct btf_type *struct_ops_type;
	const struct btf *kern_btf = d->btf;
	const char *struct_ops_name;
	int zero = 0;
	void *value;

	/* note: d->jw == wtr */

	kern_btf = d->btf;

	/* The kernel supporting BPF_MAP_TYPE_STRUCT_OPS must have
	 * btf_vmlinux_value_type_id.
	 */
	struct_ops_type = btf__type_by_id(kern_btf,
					  info->btf_vmlinux_value_type_id);
	struct_ops_name = btf__name_by_offset(kern_btf,
					      struct_ops_type->name_off);
	value = calloc(1, info->value_size);
	if (!value) {
		p_err("mem alloc failed");
		return -1;
	}

	if (bpf_map_lookup_elem(fd, &zero, value)) {
		p_err("can't lookup struct_ops map %s id %u",
		      info->name, info->id);
		free(value);
		return -1;
	}

	jsonw_start_object(wtr);
	jsonw_name(wtr, "bpf_map_info");
	btf_dumper_type(d, map_info_type_id, (void *)info);
	jsonw_end_object(wtr);

	jsonw_start_object(wtr);
	jsonw_name(wtr, struct_ops_name);
	btf_dumper_type(d, info->btf_vmlinux_value_type_id, value);
	jsonw_end_object(wtr);

	free(value);

	return 0;
}

static int do_dump(int argc, char **argv)
{
	const char *search_type = NULL, *search_term = NULL;
	json_writer_t *wtr = json_wtr;
	const struct btf *kern_btf;
	struct btf_dumper d = {};
	struct res res;

	if (argc && argc != 2)
		usage();

	if (argc == 2) {
		search_type = GET_ARG();
		search_term = GET_ARG();
	}

	kern_btf = get_btf_vmlinux();
	if (!kern_btf)
		return -1;

	if (!json_output) {
		wtr = jsonw_new(stdout);
		if (!wtr) {
			p_err("can't create json writer");
			return -1;
		}
		jsonw_pretty(wtr, true);
	}

	d.btf = kern_btf;
	d.jw = wtr;
	d.is_plain_text = !json_output;
	d.prog_id_as_func_ptr = true;

	res = do_work_on_struct_ops(search_type, search_term, __do_dump, &d,
				    wtr);

	if (!json_output)
		jsonw_destroy(&wtr);

	return cmd_retval(&res, !!search_term);
}

static int __do_unregister(int fd, const struct bpf_map_info *info, void *data,
			   struct json_writer *wtr)
{
	int zero = 0;

	if (bpf_map_delete_elem(fd, &zero)) {
		p_err("can't unload %s %s id %u: %s",
		      get_kern_struct_ops_name(info), info->name,
		      info->id, strerror(errno));
		return -1;
	}

	p_info("Unregistered %s %s id %u",
	       get_kern_struct_ops_name(info), info->name,
	       info->id);

	return 0;
}

static int do_unregister(int argc, char **argv)
{
	const char *search_type, *search_term;
	struct res res;

	if (argc != 2)
		usage();

	search_type = GET_ARG();
	search_term = GET_ARG();

	res = do_work_on_struct_ops(search_type, search_term,
				    __do_unregister, NULL, NULL);

	return cmd_retval(&res, true);
}

static int pin_link(struct bpf_link *link, const char *pindir,
		    const char *name)
{
	char pinfile[PATH_MAX];
	int err;

	err = pathname_concat(pinfile, sizeof(pinfile), pindir, name);
	if (err)
		return -1;

	return bpf_link__pin(link, pinfile);
}

static int do_register(int argc, char **argv)
{
	LIBBPF_OPTS(bpf_object_open_opts, open_opts);
	__u32 link_info_len = sizeof(struct bpf_link_info);
	struct bpf_link_info link_info = {};
	struct bpf_map_info info = {};
	__u32 info_len = sizeof(info);
	int nr_errs = 0, nr_maps = 0;
	const char *linkdir = NULL;
	struct bpf_object *obj;
	struct bpf_link *link;
	struct bpf_map *map;
	const char *file;

	if (argc != 1 && argc != 2)
		usage();

	file = GET_ARG();
	if (argc == 1)
		linkdir = GET_ARG();

	if (linkdir && mount_bpffs_for_pin(linkdir)) {
		p_err("can't mount bpffs for pinning");
		return -1;
	}

	if (verifier_logs)
		/* log_level1 + log_level2 + stats, but not stable UAPI */
		open_opts.kernel_log_level = 1 + 2 + 4;

	obj = bpf_object__open_file(file, &open_opts);
	if (!obj)
		return -1;

	set_max_rlimit();

	if (bpf_object__load(obj)) {
		bpf_object__close(obj);
		return -1;
	}

	bpf_object__for_each_map(map, obj) {
		if (bpf_map__type(map) != BPF_MAP_TYPE_STRUCT_OPS)
			continue;

		link = bpf_map__attach_struct_ops(map);
		if (!link) {
			p_err("can't register struct_ops %s: %s",
			      bpf_map__name(map), strerror(errno));
			nr_errs++;
			continue;
		}
		nr_maps++;

		if (bpf_map_get_info_by_fd(bpf_map__fd(map), &info,
					   &info_len)) {
			/* Not p_err.  The struct_ops was attached
			 * successfully.
			 */
			p_info("Registered %s but can't find id: %s",
			       bpf_map__name(map), strerror(errno));
			goto clean_link;
		}
		if (!(bpf_map__map_flags(map) & BPF_F_LINK)) {
			p_info("Registered %s %s id %u",
			       get_kern_struct_ops_name(&info),
			       info.name,
			       info.id);
			goto clean_link;
		}
		if (bpf_link_get_info_by_fd(bpf_link__fd(link),
					    &link_info,
					    &link_info_len)) {
			p_err("Registered %s but can't find link id: %s",
			      bpf_map__name(map), strerror(errno));
			nr_errs++;
			goto clean_link;
		}
		if (linkdir && pin_link(link, linkdir, info.name)) {
			p_err("can't pin link %u for %s: %s",
			      link_info.id, info.name,
			      strerror(errno));
			nr_errs++;
			goto clean_link;
		}
		p_info("Registered %s %s map id %u link id %u",
		       get_kern_struct_ops_name(&info),
		       info.name, info.id, link_info.id);

clean_link:
		bpf_link__disconnect(link);
		bpf_link__destroy(link);
	}

	bpf_object__close(obj);

	if (nr_errs)
		return -1;

	if (!nr_maps) {
		p_err("no struct_ops found in %s", file);
		return -1;
	}

	if (json_output)
		jsonw_null(json_wtr);

	return 0;
}

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

	fprintf(stderr,
		"Usage: %1$s %2$s { show | list } [STRUCT_OPS_MAP]\n"
		"       %1$s %2$s dump [STRUCT_OPS_MAP]\n"
		"       %1$s %2$s register OBJ [LINK_DIR]\n"
		"       %1$s %2$s unregister STRUCT_OPS_MAP\n"
		"       %1$s %2$s help\n"
		"\n"
		"       STRUCT_OPS_MAP := [ id STRUCT_OPS_MAP_ID | name STRUCT_OPS_MAP_NAME ]\n"
		"       " HELP_SPEC_OPTIONS " }\n"
		"",
		bin_name, argv[-2]);

	return 0;
}

static const struct cmd cmds[] = {
	{ "show",	do_show },
	{ "list",	do_show },
	{ "register",	do_register },
	{ "unregister",	do_unregister },
	{ "dump",	do_dump },
	{ "help",	do_help },
	{ 0 }
};

int do_struct_ops(int argc, char **argv)
{
	int err;

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

	btf__free(btf_vmlinux);

	return err;
}
Commit	Line	Data
65c93628 MKL	1	// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
	2	/* Copyright (C) 2020 Facebook */
	3
	4	#include <errno.h>
	5	#include <stdio.h>
	6	#include <unistd.h>
	7
	8	#include <linux/err.h>
	9
	10	#include <bpf/bpf.h>
	11	#include <bpf/btf.h>
	12	#include <bpf/libbpf.h>
	13
	14	#include "json_writer.h"
	15	#include "main.h"
	16
	17	#define STRUCT_OPS_VALUE_PREFIX "bpf_struct_ops_"
	18
	19	static const struct btf_type *map_info_type;
	20	static __u32 map_info_alloc_len;
	21	static struct btf *btf_vmlinux;
	22	static __s32 map_info_type_id;
	23
	24	struct res {
	25	unsigned int nr_maps;
	26	unsigned int nr_errs;
	27	};
	28
	29	static const struct btf *get_btf_vmlinux(void)
	30	{
	31	if (btf_vmlinux)
	32	return btf_vmlinux;
	33
	34	btf_vmlinux = libbpf_find_kernel_btf();
d1313e01	35	if (!btf_vmlinux)
65c93628 MKL	36	p_err("struct_ops requires kernel CONFIG_DEBUG_INFO_BTF=y");
	37
	38	return btf_vmlinux;
	39	}
	40
	41	static const char get_kern_struct_ops_name(const struct bpf_map_info info)
	42	{
	43	const struct btf *kern_btf;
	44	const struct btf_type *t;
	45	const char *st_ops_name;
	46
	47	kern_btf = get_btf_vmlinux();
d1313e01	48	if (!kern_btf)
65c93628 MKL	49	return "<btf_vmlinux_not_found>";
	50
	51	t = btf__type_by_id(kern_btf, info->btf_vmlinux_value_type_id);
	52	st_ops_name = btf__name_by_offset(kern_btf, t->name_off);
	53	st_ops_name += strlen(STRUCT_OPS_VALUE_PREFIX);
	54
	55	return st_ops_name;
	56	}
	57
	58	static __s32 get_map_info_type_id(void)
	59	{
	60	const struct btf *kern_btf;
	61
	62	if (map_info_type_id)
	63	return map_info_type_id;
	64
	65	kern_btf = get_btf_vmlinux();
989f2851 SOF	66	if (!kern_btf)
989f2851 SOF	67	return 0;
65c93628 MKL	68
	69	map_info_type_id = btf__find_by_name_kind(kern_btf, "bpf_map_info",
	70	BTF_KIND_STRUCT);
	71	if (map_info_type_id < 0) {
	72	p_err("can't find bpf_map_info from btf_vmlinux");
	73	return map_info_type_id;
	74	}
	75	map_info_type = btf__type_by_id(kern_btf, map_info_type_id);
	76
	77	/* Ensure map_info_alloc() has at least what the bpftool needs */
	78	map_info_alloc_len = map_info_type->size;
	79	if (map_info_alloc_len < sizeof(struct bpf_map_info))
	80	map_info_alloc_len = sizeof(struct bpf_map_info);
	81
	82	return map_info_type_id;
	83	}
	84
	85	/* If the subcmd needs to print out the bpf_map_info,
	86	* it should always call map_info_alloc to allocate
	87	* a bpf_map_info object instead of allocating it
	88	* on the stack.
	89	*
	90	* map_info_alloc() will take the running kernel's btf
	91	* into account. i.e. it will consider the
	92	* sizeof(struct bpf_map_info) of the running kernel.
	93	*
	94	* It will enable the "struct_ops" cmd to print the latest
	95	* "struct bpf_map_info".
	96	*
	97	* [ Recall that "struct_ops" requires the kernel's btf to
	98	* be available ]
	99	*/
	100	static struct bpf_map_info map_info_alloc(__u32 alloc_len)
	101	{
	102	struct bpf_map_info *info;
	103
	104	if (get_map_info_type_id() < 0)
	105	return NULL;
	106
	107	info = calloc(1, map_info_alloc_len);
	108	if (!info)
	109	p_err("mem alloc failed");
	110	else
	111	*alloc_len = map_info_alloc_len;
	112
	113	return info;
	114	}
	115
	116	/* It iterates all struct_ops maps of the system.
	117	* It returns the fd in "res_fd" and map_info in "info".
	118	* In the very first iteration, info->id should be 0.
	119	* An optional map "*name" filter can be specified.
	120	* The filter can be made more flexible in the future.
	121	* e.g. filter by kernel-struct-ops-name, regex-name, glob-name, ...etc.
	122	*
	123	* Return value:
	124	* 1: A struct_ops map found. It is returned in "res_fd" and "info".
	125	* The caller can continue to call get_next in the future.
	126	* 0: No struct_ops map is returned.
	127	* All struct_ops map has been found.
	128	* -1: Error and the caller should abort the iteration.
	129	*/
	130	static int get_next_struct_ops_map(const char name, int res_fd,
	131	struct bpf_map_info *info, __u32 info_len)
132	{
133	__u32 id = info->id;
134	int err, fd;
135
136	while (true) {
137	err = bpf_map_get_next_id(id, &id);
138	if (err) {
139	if (errno == ENOENT)
140	return 0;
141	p_err("can't get next map: %s", strerror(errno));
142	return -1;
143	}
144
145	fd = bpf_map_get_fd_by_id(id);
146	if (fd < 0) {
147	if (errno == ENOENT)
148	continue;
149	p_err("can't get map by id (%u): %s",
150	id, strerror(errno));
151	return -1;
152	}
153
38f0408e	154	err = bpf_map_get_info_by_fd(fd, info, &info_len);
65c93628 MKL	155	if (err) {
	156	p_err("can't get map info: %s", strerror(errno));
	157	close(fd);
	158	return -1;
	159	}
	160
	161	if (info->type == BPF_MAP_TYPE_STRUCT_OPS &&
	162	(!name \|\| !strcmp(name, info->name))) {
	163	*res_fd = fd;
	164	return 1;
	165	}
	166	close(fd);
	167	}
	168	}
	169
	170	static int cmd_retval(const struct res *res, bool must_have_one_map)
	171	{
	172	if (res->nr_errs \|\| (!res->nr_maps && must_have_one_map))
	173	return -1;
	174
	175	return 0;
	176	}
	177
	178	/* "data" is the work_func private storage */
	179	typedef int (work_func)(int fd, const struct bpf_map_info info, void *data,
	180	struct json_writer *wtr);
	181
	182	/* Find all struct_ops map in the system.
	183	* Filter out by "name" (if specified).
	184	* Then call "func(fd, info, data, wtr)" on each struct_ops map found.
	185	*/
	186	static struct res do_search(const char name, work_func func, void data,
	187	struct json_writer *wtr)
	188	{
	189	struct bpf_map_info *info;
	190	struct res res = {};
	191	__u32 info_len;
	192	int fd, err;
	193
	194	info = map_info_alloc(&info_len);
	195	if (!info) {
	196	res.nr_errs++;
	197	return res;
	198	}
	199
	200	if (wtr)
	201	jsonw_start_array(wtr);
	202	while ((err = get_next_struct_ops_map(name, &fd, info, info_len)) == 1) {
	203	res.nr_maps++;
	204	err = func(fd, info, data, wtr);
	205	if (err)
	206	res.nr_errs++;
	207	close(fd);
	208	}
	209	if (wtr)
	210	jsonw_end_array(wtr);
	211
	212	if (err)
	213	res.nr_errs++;
	214
	215	if (!wtr && name && !res.nr_errs && !res.nr_maps)
	216	/* It is not printing empty [].
	217	* Thus, needs to specifically say nothing found
	218	* for "name" here.
219	*/
220	p_err("no struct_ops found for %s", name);
221	else if (!wtr && json_output && !res.nr_errs)
222	/* The "func()" above is not writing any json (i.e. !wtr
223	* test here).
224	*
225	* However, "-j" is enabled and there is no errs here,
226	* so call json_null() as the current convention of
227	* other cmds.
228	*/
229	jsonw_null(json_wtr);
230
231	free(info);
232	return res;
233	}
234
235	static struct res do_one_id(const char id_str, work_func func, void data,
236	struct json_writer *wtr)
237	{
238	struct bpf_map_info *info;
239	struct res res = {};
240	unsigned long id;
241	__u32 info_len;
242	char *endptr;
243	int fd;
244
245	id = strtoul(id_str, &endptr, 0);
246	if (*endptr \|\| !id \|\| id > UINT32_MAX) {
247	p_err("invalid id %s", id_str);
248	res.nr_errs++;
249	return res;
250	}
251
252	fd = bpf_map_get_fd_by_id(id);
60f27075	253	if (fd < 0) {
65c93628 MKL	254	p_err("can't get map by id (%lu): %s", id, strerror(errno));
	255	res.nr_errs++;
	256	return res;
	257	}
	258
	259	info = map_info_alloc(&info_len);
	260	if (!info) {
	261	res.nr_errs++;
	262	goto done;
	263	}
	264
38f0408e	265	if (bpf_map_get_info_by_fd(fd, info, &info_len)) {
65c93628 MKL	266	p_err("can't get map info: %s", strerror(errno));
	267	res.nr_errs++;
	268	goto done;
	269	}
	270
	271	if (info->type != BPF_MAP_TYPE_STRUCT_OPS) {
	272	p_err("%s id %u is not a struct_ops map", info->name, info->id);
	273	res.nr_errs++;
	274	goto done;
	275	}
	276
	277	res.nr_maps++;
	278
	279	if (func(fd, info, data, wtr))
	280	res.nr_errs++;
	281	else if (!wtr && json_output)
	282	/* The "func()" above is not writing any json (i.e. !wtr
	283	* test here).
	284	*
	285	* However, "-j" is enabled and there is no errs here,
	286	* so call json_null() as the current convention of
	287	* other cmds.
	288	*/
	289	jsonw_null(json_wtr);
	290
	291	done:
	292	free(info);
	293	close(fd);
	294
	295	return res;
	296	}
	297
	298	static struct res do_work_on_struct_ops(const char *search_type,
	299	const char *search_term,
	300	work_func func, void *data,
	301	struct json_writer *wtr)
	302	{
	303	if (search_type) {
	304	if (is_prefix(search_type, "id"))
	305	return do_one_id(search_term, func, data, wtr);
	306	else if (!is_prefix(search_type, "name"))
	307	usage();
	308	}
	309
	310	return do_search(search_term, func, data, wtr);
	311	}
	312
	313	static int __do_show(int fd, const struct bpf_map_info info, void data,
	314	struct json_writer *wtr)
	315	{
	316	if (wtr) {
	317	jsonw_start_object(wtr);
	318	jsonw_uint_field(wtr, "id", info->id);
	319	jsonw_string_field(wtr, "name", info->name);
	320	jsonw_string_field(wtr, "kernel_struct_ops",
	321	get_kern_struct_ops_name(info));
	322	jsonw_end_object(wtr);
	323	} else {
	324	printf("%u: %-15s %-32s\n", info->id, info->name,
	325	get_kern_struct_ops_name(info));
	326	}
	327
	328	return 0;
	329	}
330
331	static int do_show(int argc, char **argv)
332	{
333	const char search_type = NULL, search_term = NULL;
334	struct res res;
335
336	if (argc && argc != 2)
337	usage();
338
339	if (argc == 2) {
340	search_type = GET_ARG();
341	search_term = GET_ARG();
342	}
343
344	res = do_work_on_struct_ops(search_type, search_term, __do_show,
345	NULL, json_wtr);
346
347	return cmd_retval(&res, !!search_term);
348	}
349
350	static int __do_dump(int fd, const struct bpf_map_info info, void data,
351	struct json_writer *wtr)
352	{
353	struct btf_dumper d = (struct btf_dumper )data;
354	const struct btf_type *struct_ops_type;
355	const struct btf *kern_btf = d->btf;
356	const char *struct_ops_name;
357	int zero = 0;
358	void *value;
359
360	/* note: d->jw == wtr */
361
362	kern_btf = d->btf;
363
364	/* The kernel supporting BPF_MAP_TYPE_STRUCT_OPS must have
365	* btf_vmlinux_value_type_id.
366	*/
367	struct_ops_type = btf__type_by_id(kern_btf,
368	info->btf_vmlinux_value_type_id);
369	struct_ops_name = btf__name_by_offset(kern_btf,
370	struct_ops_type->name_off);
371	value = calloc(1, info->value_size);
372	if (!value) {
373	p_err("mem alloc failed");
374	return -1;
375	}
376
377	if (bpf_map_lookup_elem(fd, &zero, value)) {
378	p_err("can't lookup struct_ops map %s id %u",
379	info->name, info->id);
380	free(value);
381	return -1;
382	}
383
384	jsonw_start_object(wtr);
385	jsonw_name(wtr, "bpf_map_info");
386	btf_dumper_type(d, map_info_type_id, (void *)info);
387	jsonw_end_object(wtr);
388
389	jsonw_start_object(wtr);
390	jsonw_name(wtr, struct_ops_name);
391	btf_dumper_type(d, info->btf_vmlinux_value_type_id, value);
392	jsonw_end_object(wtr);
393
394	free(value);
395
396	return 0;
397	}
398
399	static int do_dump(int argc, char **argv)
400	{
401	const char search_type = NULL, search_term = NULL;
402	json_writer_t *wtr = json_wtr;
403	const struct btf *kern_btf;
404	struct btf_dumper d = {};
405	struct res res;
406
407	if (argc && argc != 2)
408	usage();
409
410	if (argc == 2) {
411	search_type = GET_ARG();
412	search_term = GET_ARG();
413	}
414
415	kern_btf = get_btf_vmlinux();
d1313e01	416	if (!kern_btf)
65c93628 MKL	417	return -1;
	418
	419	if (!json_output) {
	420	wtr = jsonw_new(stdout);
	421	if (!wtr) {
	422	p_err("can't create json writer");
	423	return -1;
	424	}
	425	jsonw_pretty(wtr, true);
	426	}
	427
	428	d.btf = kern_btf;
	429	d.jw = wtr;
	430	d.is_plain_text = !json_output;
	431	d.prog_id_as_func_ptr = true;
	432
	433	res = do_work_on_struct_ops(search_type, search_term, __do_dump, &d,
	434	wtr);
	435
	436	if (!json_output)
	437	jsonw_destroy(&wtr);
	438
	439	return cmd_retval(&res, !!search_term);
	440	}
	441
	442	static int __do_unregister(int fd, const struct bpf_map_info info, void data,
	443	struct json_writer *wtr)
	444	{
	445	int zero = 0;
	446
	447	if (bpf_map_delete_elem(fd, &zero)) {
	448	p_err("can't unload %s %s id %u: %s",
	449	get_kern_struct_ops_name(info), info->name,
	450	info->id, strerror(errno));
	451	return -1;
	452	}
	453
	454	p_info("Unregistered %s %s id %u",
	455	get_kern_struct_ops_name(info), info->name,
	456	info->id);
	457
	458	return 0;
	459	}
	460
	461	static int do_unregister(int argc, char **argv)
	462	{
	463	const char search_type, search_term;
	464	struct res res;
	465
	466	if (argc != 2)
	467	usage();
	468
	469	search_type = GET_ARG();
	470	search_term = GET_ARG();
	471
	472	res = do_work_on_struct_ops(search_type, search_term,
	473	__do_unregister, NULL, NULL);
	474
	475	return cmd_retval(&res, true);
	476	}
	477
0232b788 KFL	478	static int pin_link(struct bpf_link link, const char pindir,
	479	const char *name)
	480	{
	481	char pinfile[PATH_MAX];
	482	int err;
	483
	484	err = pathname_concat(pinfile, sizeof(pinfile), pindir, name);
	485	if (err)
	486	return -1;
	487
	488	return bpf_link__pin(link, pinfile);
	489	}
	490
65c93628 MKL	491	static int do_register(int argc, char **argv)
65c93628 MKL	492	{
b59e4ce8	493	LIBBPF_OPTS(bpf_object_open_opts, open_opts);
0232b788 KFL	494	__u32 link_info_len = sizeof(struct bpf_link_info);
0232b788 KFL	495	struct bpf_link_info link_info = {};
65c93628 MKL	496	struct bpf_map_info info = {};
	497	__u32 info_len = sizeof(info);
	498	int nr_errs = 0, nr_maps = 0;
0232b788	499	const char *linkdir = NULL;
65c93628 MKL	500	struct bpf_object *obj;
	501	struct bpf_link *link;
	502	struct bpf_map *map;
	503	const char *file;
	504
0232b788	505	if (argc != 1 && argc != 2)
65c93628 MKL	506	usage();
	507
	508	file = GET_ARG();
0232b788 KFL	509	if (argc == 1)
	510	linkdir = GET_ARG();
	511
	512	if (linkdir && mount_bpffs_for_pin(linkdir)) {
	513	p_err("can't mount bpffs for pinning");
	514	return -1;
	515	}
65c93628	516
b59e4ce8 AN	517	if (verifier_logs)
	518	/* log_level1 + log_level2 + stats, but not stable UAPI */
	519	open_opts.kernel_log_level = 1 + 2 + 4;
	520
	521	obj = bpf_object__open_file(file, &open_opts);
d1313e01	522	if (!obj)
65c93628 MKL	523	return -1;
65c93628 MKL	524
6b4384ff QM	525	set_max_rlimit();
6b4384ff QM	526
b59e4ce8	527	if (bpf_object__load(obj)) {
65c93628 MKL	528	bpf_object__close(obj);
	529	return -1;
	530	}
	531
	532	bpf_object__for_each_map(map, obj) {
3c28919f	533	if (bpf_map__type(map) != BPF_MAP_TYPE_STRUCT_OPS)
65c93628 MKL	534	continue;
	535
	536	link = bpf_map__attach_struct_ops(map);
d2973ffd	537	if (!link) {
65c93628	538	p_err("can't register struct_ops %s: %s",
d2973ffd	539	bpf_map__name(map), strerror(errno));
65c93628 MKL	540	nr_errs++;
	541	continue;
	542	}
	543	nr_maps++;
	544
0232b788 KFL	545	if (bpf_map_get_info_by_fd(bpf_map__fd(map), &info,
0232b788 KFL	546	&info_len)) {
65c93628 MKL	547	/* Not p_err. The struct_ops was attached
	548	* successfully.
	549	*/
	550	p_info("Registered %s but can't find id: %s",
	551	bpf_map__name(map), strerror(errno));
0232b788 KFL	552	goto clean_link;
	553	}
	554	if (!(bpf_map__map_flags(map) & BPF_F_LINK)) {
	555	p_info("Registered %s %s id %u",
	556	get_kern_struct_ops_name(&info),
	557	info.name,
	558	info.id);
	559	goto clean_link;
	560	}
	561	if (bpf_link_get_info_by_fd(bpf_link__fd(link),
	562	&link_info,
	563	&link_info_len)) {
	564	p_err("Registered %s but can't find link id: %s",
	565	bpf_map__name(map), strerror(errno));
	566	nr_errs++;
	567	goto clean_link;
	568	}
	569	if (linkdir && pin_link(link, linkdir, info.name)) {
	570	p_err("can't pin link %u for %s: %s",
	571	link_info.id, info.name,
	572	strerror(errno));
	573	nr_errs++;
	574	goto clean_link;
	575	}
	576	p_info("Registered %s %s map id %u link id %u",
	577	get_kern_struct_ops_name(&info),
	578	info.name, info.id, link_info.id);
	579
	580	clean_link:
	581	bpf_link__disconnect(link);
	582	bpf_link__destroy(link);
65c93628 MKL	583	}
	584
	585	bpf_object__close(obj);
	586
	587	if (nr_errs)
	588	return -1;
	589
	590	if (!nr_maps) {
	591	p_err("no struct_ops found in %s", file);
	592	return -1;
	593	}
	594
	595	if (json_output)
	596	jsonw_null(json_wtr);
	597
	598	return 0;
	599	}
	600
	601	static int do_help(int argc, char **argv)
	602	{
	603	if (json_output) {
	604	jsonw_null(json_wtr);
	605	return 0;
	606	}
	607
	608	fprintf(stderr,
90040351 QM	609	"Usage: %1$s %2$s { show \| list } [STRUCT_OPS_MAP]\n"
90040351 QM	610	" %1$s %2$s dump [STRUCT_OPS_MAP]\n"
0232b788	611	" %1$s %2$s register OBJ [LINK_DIR]\n"
90040351 QM	612	" %1$s %2$s unregister STRUCT_OPS_MAP\n"
90040351 QM	613	" %1$s %2$s help\n"
65c93628	614	"\n"
90040351	615	" STRUCT_OPS_MAP := [ id STRUCT_OPS_MAP_ID \| name STRUCT_OPS_MAP_NAME ]\n"
c07ba629	616	" " HELP_SPEC_OPTIONS " }\n"
90040351	617	"",
65c93628 MKL	618	bin_name, argv[-2]);
	619
	620	return 0;
	621	}
	622
	623	static const struct cmd cmds[] = {
	624	{ "show", do_show },
	625	{ "list", do_show },
	626	{ "register", do_register },
	627	{ "unregister", do_unregister },
	628	{ "dump", do_dump },
	629	{ "help", do_help },
	630	{ 0 }
	631	};
	632
	633	int do_struct_ops(int argc, char **argv)
	634	{
	635	int err;
	636
	637	err = cmd_select(cmds, argc, argv, do_help);
	638
d1313e01	639	btf__free(btf_vmlinux);
96b2eb6e	640
65c93628 MKL	641	return err;
65c93628 MKL	642	}