1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2/* Copyright (C) 2019 Facebook */
   3
   4#ifndef _GNU_SOURCE
   5#define _GNU_SOURCE
   6#endif
   7#include <ctype.h>
   8#include <errno.h>
   9#include <fcntl.h>
  10#include <linux/err.h>
  11#include <stdbool.h>
  12#include <stdio.h>
  13#include <string.h>
  14#include <unistd.h>
  15#include <bpf/bpf.h>
  16#include <bpf/libbpf.h>
  17#include <bpf/libbpf_internal.h>
  18#include <sys/types.h>
  19#include <sys/stat.h>
  20#include <sys/mman.h>
  21#include <bpf/btf.h>
  22
  23#include "json_writer.h"
  24#include "main.h"
  25
  26#define MAX_OBJ_NAME_LEN 64
  27
  28static void sanitize_identifier(char *name)
  29{
  30	int i;
  31
  32	for (i = 0; name[i]; i++)
  33		if (!isalnum(name[i]) && name[i] != '_')
  34			name[i] = '_';
  35}
  36
  37static bool str_has_prefix(const char *str, const char *prefix)
  38{
  39	return strncmp(str, prefix, strlen(prefix)) == 0;
  40}
  41
  42static bool str_has_suffix(const char *str, const char *suffix)
  43{
  44	size_t i, n1 = strlen(str), n2 = strlen(suffix);
  45
  46	if (n1 < n2)
  47		return false;
  48
  49	for (i = 0; i < n2; i++) {
  50		if (str[n1 - i - 1] != suffix[n2 - i - 1])
  51			return false;
  52	}
  53
  54	return true;
  55}
  56
  57static void get_obj_name(char *name, const char *file)
  58{
  59	/* Using basename() GNU version which doesn't modify arg. */
  60	strncpy(name, basename(file), MAX_OBJ_NAME_LEN - 1);
  61	name[MAX_OBJ_NAME_LEN - 1] = '\0';
  62	if (str_has_suffix(name, ".o"))
  63		name[strlen(name) - 2] = '\0';
  64	sanitize_identifier(name);
  65}
  66
  67static void get_header_guard(char *guard, const char *obj_name, const char *suffix)
  68{
  69	int i;
  70
  71	sprintf(guard, "__%s_%s__", obj_name, suffix);
  72	for (i = 0; guard[i]; i++)
  73		guard[i] = toupper(guard[i]);
  74}
  75
  76static bool get_map_ident(const struct bpf_map *map, char *buf, size_t buf_sz)
  77{
  78	static const char *sfxs[] = { ".data", ".rodata", ".bss", ".kconfig" };
  79	const char *name = bpf_map__name(map);
  80	int i, n;
  81
  82	if (!bpf_map__is_internal(map)) {
  83		snprintf(buf, buf_sz, "%s", name);
  84		return true;
  85	}
  86
  87	for  (i = 0, n = ARRAY_SIZE(sfxs); i < n; i++) {
  88		const char *sfx = sfxs[i], *p;
  89
  90		p = strstr(name, sfx);
  91		if (p) {
  92			snprintf(buf, buf_sz, "%s", p + 1);
  93			sanitize_identifier(buf);
  94			return true;
  95		}
  96	}
  97
  98	return false;
  99}
 100
 101static bool get_datasec_ident(const char *sec_name, char *buf, size_t buf_sz)
 102{
 103	static const char *pfxs[] = { ".data", ".rodata", ".bss", ".kconfig" };
 104	int i, n;
 105
 106	for  (i = 0, n = ARRAY_SIZE(pfxs); i < n; i++) {
 107		const char *pfx = pfxs[i];
 108
 109		if (str_has_prefix(sec_name, pfx)) {
 110			snprintf(buf, buf_sz, "%s", sec_name + 1);
 111			sanitize_identifier(buf);
 112			return true;
 113		}
 114	}
 115
 116	return false;
 117}
 118
 119static void codegen_btf_dump_printf(void *ctx, const char *fmt, va_list args)
 120{
 121	vprintf(fmt, args);
 122}
 123
 124static int codegen_datasec_def(struct bpf_object *obj,
 125			       struct btf *btf,
 126			       struct btf_dump *d,
 127			       const struct btf_type *sec,
 128			       const char *obj_name)
 129{
 130	const char *sec_name = btf__name_by_offset(btf, sec->name_off);
 131	const struct btf_var_secinfo *sec_var = btf_var_secinfos(sec);
 132	int i, err, off = 0, pad_cnt = 0, vlen = btf_vlen(sec);
 133	char var_ident[256], sec_ident[256];
 134	bool strip_mods = false;
 135
 136	if (!get_datasec_ident(sec_name, sec_ident, sizeof(sec_ident)))
 137		return 0;
 138
 139	if (strcmp(sec_name, ".kconfig") != 0)
 140		strip_mods = true;
 141
 142	printf("	struct %s__%s {\n", obj_name, sec_ident);
 143	for (i = 0; i < vlen; i++, sec_var++) {
 144		const struct btf_type *var = btf__type_by_id(btf, sec_var->type);
 145		const char *var_name = btf__name_by_offset(btf, var->name_off);
 146		DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts,
 147			.field_name = var_ident,
 148			.indent_level = 2,
 149			.strip_mods = strip_mods,
 150		);
 151		int need_off = sec_var->offset, align_off, align;
 152		__u32 var_type_id = var->type;
 153
 154		/* static variables are not exposed through BPF skeleton */
 155		if (btf_var(var)->linkage == BTF_VAR_STATIC)
 156			continue;
 157
 158		if (off > need_off) {
 159			p_err("Something is wrong for %s's variable #%d: need offset %d, already at %d.\n",
 160			      sec_name, i, need_off, off);
 161			return -EINVAL;
 162		}
 163
 164		align = btf__align_of(btf, var->type);
 165		if (align <= 0) {
 166			p_err("Failed to determine alignment of variable '%s': %d",
 167			      var_name, align);
 168			return -EINVAL;
 169		}
 170		/* Assume 32-bit architectures when generating data section
 171		 * struct memory layout. Given bpftool can't know which target
 172		 * host architecture it's emitting skeleton for, we need to be
 173		 * conservative and assume 32-bit one to ensure enough padding
 174		 * bytes are generated for pointer and long types. This will
 175		 * still work correctly for 64-bit architectures, because in
 176		 * the worst case we'll generate unnecessary padding field,
 177		 * which on 64-bit architectures is not strictly necessary and
 178		 * would be handled by natural 8-byte alignment. But it still
 179		 * will be a correct memory layout, based on recorded offsets
 180		 * in BTF.
 181		 */
 182		if (align > 4)
 183			align = 4;
 184
 185		align_off = (off + align - 1) / align * align;
 186		if (align_off != need_off) {
 187			printf("\t\tchar __pad%d[%d];\n",
 188			       pad_cnt, need_off - off);
 189			pad_cnt++;
 190		}
 191
 192		/* sanitize variable name, e.g., for static vars inside
 193		 * a function, it's name is '<function name>.<variable name>',
 194		 * which we'll turn into a '<function name>_<variable name>'
 195		 */
 196		var_ident[0] = '\0';
 197		strncat(var_ident, var_name, sizeof(var_ident) - 1);
 198		sanitize_identifier(var_ident);
 199
 200		printf("\t\t");
 201		err = btf_dump__emit_type_decl(d, var_type_id, &opts);
 202		if (err)
 203			return err;
 204		printf(";\n");
 205
 206		off = sec_var->offset + sec_var->size;
 207	}
 208	printf("	} *%s;\n", sec_ident);
 209	return 0;
 210}
 211
 212static const struct btf_type *find_type_for_map(struct btf *btf, const char *map_ident)
 213{
 214	int n = btf__type_cnt(btf), i;
 215	char sec_ident[256];
 216
 217	for (i = 1; i < n; i++) {
 218		const struct btf_type *t = btf__type_by_id(btf, i);
 219		const char *name;
 220
 221		if (!btf_is_datasec(t))
 222			continue;
 223
 224		name = btf__str_by_offset(btf, t->name_off);
 225		if (!get_datasec_ident(name, sec_ident, sizeof(sec_ident)))
 226			continue;
 227
 228		if (strcmp(sec_ident, map_ident) == 0)
 229			return t;
 230	}
 231	return NULL;
 232}
 233
 234static bool is_internal_mmapable_map(const struct bpf_map *map, char *buf, size_t sz)
 235{
 236	if (!bpf_map__is_internal(map) || !(bpf_map__map_flags(map) & BPF_F_MMAPABLE))
 237		return false;
 238
 239	if (!get_map_ident(map, buf, sz))
 240		return false;
 241
 242	return true;
 243}
 244
 245static int codegen_datasecs(struct bpf_object *obj, const char *obj_name)
 246{
 247	struct btf *btf = bpf_object__btf(obj);
 248	struct btf_dump *d;
 249	struct bpf_map *map;
 250	const struct btf_type *sec;
 251	char map_ident[256];
 252	int err = 0;
 253
 254	d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL);
 255	if (!d)
 256		return -errno;
 257
 258	bpf_object__for_each_map(map, obj) {
 259		/* only generate definitions for memory-mapped internal maps */
 260		if (!is_internal_mmapable_map(map, map_ident, sizeof(map_ident)))
 261			continue;
 262
 263		sec = find_type_for_map(btf, map_ident);
 264
 265		/* In some cases (e.g., sections like .rodata.cst16 containing
 266		 * compiler allocated string constants only) there will be
 267		 * special internal maps with no corresponding DATASEC BTF
 268		 * type. In such case, generate empty structs for each such
 269		 * map. It will still be memory-mapped and its contents
 270		 * accessible from user-space through BPF skeleton.
 271		 */
 272		if (!sec) {
 273			printf("	struct %s__%s {\n", obj_name, map_ident);
 274			printf("	} *%s;\n", map_ident);
 275		} else {
 276			err = codegen_datasec_def(obj, btf, d, sec, obj_name);
 277			if (err)
 278				goto out;
 279		}
 280	}
 281
 282
 283out:
 284	btf_dump__free(d);
 285	return err;
 286}
 287
 288static bool btf_is_ptr_to_func_proto(const struct btf *btf,
 289				     const struct btf_type *v)
 290{
 291	return btf_is_ptr(v) && btf_is_func_proto(btf__type_by_id(btf, v->type));
 292}
 293
 294static int codegen_subskel_datasecs(struct bpf_object *obj, const char *obj_name)
 295{
 296	struct btf *btf = bpf_object__btf(obj);
 297	struct btf_dump *d;
 298	struct bpf_map *map;
 299	const struct btf_type *sec, *var;
 300	const struct btf_var_secinfo *sec_var;
 301	int i, err = 0, vlen;
 302	char map_ident[256], sec_ident[256];
 303	bool strip_mods = false, needs_typeof = false;
 304	const char *sec_name, *var_name;
 305	__u32 var_type_id;
 306
 307	d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL);
 308	if (!d)
 309		return -errno;
 310
 311	bpf_object__for_each_map(map, obj) {
 312		/* only generate definitions for memory-mapped internal maps */
 313		if (!is_internal_mmapable_map(map, map_ident, sizeof(map_ident)))
 314			continue;
 315
 316		sec = find_type_for_map(btf, map_ident);
 317		if (!sec)
 318			continue;
 319
 320		sec_name = btf__name_by_offset(btf, sec->name_off);
 321		if (!get_datasec_ident(sec_name, sec_ident, sizeof(sec_ident)))
 322			continue;
 323
 324		strip_mods = strcmp(sec_name, ".kconfig") != 0;
 325		printf("	struct %s__%s {\n", obj_name, sec_ident);
 326
 327		sec_var = btf_var_secinfos(sec);
 328		vlen = btf_vlen(sec);
 329		for (i = 0; i < vlen; i++, sec_var++) {
 330			DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts,
 331				.indent_level = 2,
 332				.strip_mods = strip_mods,
 333				/* we'll print the name separately */
 334				.field_name = "",
 335			);
 336
 337			var = btf__type_by_id(btf, sec_var->type);
 338			var_name = btf__name_by_offset(btf, var->name_off);
 339			var_type_id = var->type;
 340
 341			/* static variables are not exposed through BPF skeleton */
 342			if (btf_var(var)->linkage == BTF_VAR_STATIC)
 343				continue;
 344
 345			/* The datasec member has KIND_VAR but we want the
 346			 * underlying type of the variable (e.g. KIND_INT).
 347			 */
 348			var = skip_mods_and_typedefs(btf, var->type, NULL);
 349
 350			printf("\t\t");
 351			/* Func and array members require special handling.
 352			 * Instead of producing `typename *var`, they produce
 353			 * `typeof(typename) *var`. This allows us to keep a
 354			 * similar syntax where the identifier is just prefixed
 355			 * by *, allowing us to ignore C declaration minutiae.
 356			 */
 357			needs_typeof = btf_is_array(var) || btf_is_ptr_to_func_proto(btf, var);
 358			if (needs_typeof)
 359				printf("typeof(");
 360
 361			err = btf_dump__emit_type_decl(d, var_type_id, &opts);
 362			if (err)
 363				goto out;
 364
 365			if (needs_typeof)
 366				printf(")");
 367
 368			printf(" *%s;\n", var_name);
 369		}
 370		printf("	} %s;\n", sec_ident);
 371	}
 372
 373out:
 374	btf_dump__free(d);
 375	return err;
 376}
 377
 378static void codegen(const char *template, ...)
 379{
 380	const char *src, *end;
 381	int skip_tabs = 0, n;
 382	char *s, *dst;
 383	va_list args;
 384	char c;
 385
 386	n = strlen(template);
 387	s = malloc(n + 1);
 388	if (!s)
 389		exit(-1);
 390	src = template;
 391	dst = s;
 392
 393	/* find out "baseline" indentation to skip */
 394	while ((c = *src++)) {
 395		if (c == '\t') {
 396			skip_tabs++;
 397		} else if (c == '\n') {
 398			break;
 399		} else {
 400			p_err("unrecognized character at pos %td in template '%s': '%c'",
 401			      src - template - 1, template, c);
 402			free(s);
 403			exit(-1);
 404		}
 405	}
 406
 407	while (*src) {
 408		/* skip baseline indentation tabs */
 409		for (n = skip_tabs; n > 0; n--, src++) {
 410			if (*src != '\t') {
 411				p_err("not enough tabs at pos %td in template '%s'",
 412				      src - template - 1, template);
 413				free(s);
 414				exit(-1);
 415			}
 416		}
 417		/* trim trailing whitespace */
 418		end = strchrnul(src, '\n');
 419		for (n = end - src; n > 0 && isspace(src[n - 1]); n--)
 420			;
 421		memcpy(dst, src, n);
 422		dst += n;
 423		if (*end)
 424			*dst++ = '\n';
 425		src = *end ? end + 1 : end;
 426	}
 427	*dst++ = '\0';
 428
 429	/* print out using adjusted template */
 430	va_start(args, template);
 431	n = vprintf(s, args);
 432	va_end(args);
 433
 434	free(s);
 435}
 436
 437static void print_hex(const char *data, int data_sz)
 438{
 439	int i, len;
 440
 441	for (i = 0, len = 0; i < data_sz; i++) {
 442		int w = data[i] ? 4 : 2;
 443
 444		len += w;
 445		if (len > 78) {
 446			printf("\\\n");
 447			len = w;
 448		}
 449		if (!data[i])
 450			printf("\\0");
 451		else
 452			printf("\\x%02x", (unsigned char)data[i]);
 453	}
 454}
 455
 456static size_t bpf_map_mmap_sz(const struct bpf_map *map)
 457{
 458	long page_sz = sysconf(_SC_PAGE_SIZE);
 459	size_t map_sz;
 460
 461	map_sz = (size_t)roundup(bpf_map__value_size(map), 8) * bpf_map__max_entries(map);
 462	map_sz = roundup(map_sz, page_sz);
 463	return map_sz;
 464}
 465
 466/* Emit type size asserts for all top-level fields in memory-mapped internal maps. */
 467static void codegen_asserts(struct bpf_object *obj, const char *obj_name)
 468{
 469	struct btf *btf = bpf_object__btf(obj);
 470	struct bpf_map *map;
 471	struct btf_var_secinfo *sec_var;
 472	int i, vlen;
 473	const struct btf_type *sec;
 474	char map_ident[256], var_ident[256];
 475
 476	if (!btf)
 477		return;
 478
 479	codegen("\
 480		\n\
 481		__attribute__((unused)) static void			    \n\
 482		%1$s__assert(struct %1$s *s __attribute__((unused)))	    \n\
 483		{							    \n\
 484		#ifdef __cplusplus					    \n\
 485		#define _Static_assert static_assert			    \n\
 486		#endif							    \n\
 487		", obj_name);
 488
 489	bpf_object__for_each_map(map, obj) {
 490		if (!is_internal_mmapable_map(map, map_ident, sizeof(map_ident)))
 491			continue;
 492
 493		sec = find_type_for_map(btf, map_ident);
 494		if (!sec) {
 495			/* best effort, couldn't find the type for this map */
 496			continue;
 497		}
 498
 499		sec_var = btf_var_secinfos(sec);
 500		vlen =  btf_vlen(sec);
 501
 502		for (i = 0; i < vlen; i++, sec_var++) {
 503			const struct btf_type *var = btf__type_by_id(btf, sec_var->type);
 504			const char *var_name = btf__name_by_offset(btf, var->name_off);
 505			long var_size;
 506
 507			/* static variables are not exposed through BPF skeleton */
 508			if (btf_var(var)->linkage == BTF_VAR_STATIC)
 509				continue;
 510
 511			var_size = btf__resolve_size(btf, var->type);
 512			if (var_size < 0)
 513				continue;
 514
 515			var_ident[0] = '\0';
 516			strncat(var_ident, var_name, sizeof(var_ident) - 1);
 517			sanitize_identifier(var_ident);
 518
 519			printf("\t_Static_assert(sizeof(s->%s->%s) == %ld, \"unexpected size of '%s'\");\n",
 520			       map_ident, var_ident, var_size, var_ident);
 521		}
 522	}
 523	codegen("\
 524		\n\
 525		#ifdef __cplusplus					    \n\
 526		#undef _Static_assert					    \n\
 527		#endif							    \n\
 528		}							    \n\
 529		");
 530}
 531
 532static void codegen_attach_detach(struct bpf_object *obj, const char *obj_name)
 533{
 534	struct bpf_program *prog;
 535
 536	bpf_object__for_each_program(prog, obj) {
 537		const char *tp_name;
 538
 539		codegen("\
 540			\n\
 541			\n\
 542			static inline int					    \n\
 543			%1$s__%2$s__attach(struct %1$s *skel)			    \n\
 544			{							    \n\
 545				int prog_fd = skel->progs.%2$s.prog_fd;		    \n\
 546			", obj_name, bpf_program__name(prog));
 547
 548		switch (bpf_program__type(prog)) {
 549		case BPF_PROG_TYPE_RAW_TRACEPOINT:
 550			tp_name = strchr(bpf_program__section_name(prog), '/') + 1;
 551			printf("\tint fd = skel_raw_tracepoint_open(\"%s\", prog_fd);\n", tp_name);
 552			break;
 553		case BPF_PROG_TYPE_TRACING:
 554		case BPF_PROG_TYPE_LSM:
 555			if (bpf_program__expected_attach_type(prog) == BPF_TRACE_ITER)
 556				printf("\tint fd = skel_link_create(prog_fd, 0, BPF_TRACE_ITER);\n");
 557			else
 558				printf("\tint fd = skel_raw_tracepoint_open(NULL, prog_fd);\n");
 559			break;
 560		default:
 561			printf("\tint fd = ((void)prog_fd, 0); /* auto-attach not supported */\n");
 562			break;
 563		}
 564		codegen("\
 565			\n\
 566										    \n\
 567				if (fd > 0)					    \n\
 568					skel->links.%1$s_fd = fd;		    \n\
 569				return fd;					    \n\
 570			}							    \n\
 571			", bpf_program__name(prog));
 572	}
 573
 574	codegen("\
 575		\n\
 576									    \n\
 577		static inline int					    \n\
 578		%1$s__attach(struct %1$s *skel)				    \n\
 579		{							    \n\
 580			int ret = 0;					    \n\
 581									    \n\
 582		", obj_name);
 583
 584	bpf_object__for_each_program(prog, obj) {
 585		codegen("\
 586			\n\
 587				ret = ret < 0 ? ret : %1$s__%2$s__attach(skel);   \n\
 588			", obj_name, bpf_program__name(prog));
 589	}
 590
 591	codegen("\
 592		\n\
 593			return ret < 0 ? ret : 0;			    \n\
 594		}							    \n\
 595									    \n\
 596		static inline void					    \n\
 597		%1$s__detach(struct %1$s *skel)				    \n\
 598		{							    \n\
 599		", obj_name);
 600
 601	bpf_object__for_each_program(prog, obj) {
 602		codegen("\
 603			\n\
 604				skel_closenz(skel->links.%1$s_fd);	    \n\
 605			", bpf_program__name(prog));
 606	}
 607
 608	codegen("\
 609		\n\
 610		}							    \n\
 611		");
 612}
 613
 614static void codegen_destroy(struct bpf_object *obj, const char *obj_name)
 615{
 616	struct bpf_program *prog;
 617	struct bpf_map *map;
 618	char ident[256];
 619
 620	codegen("\
 621		\n\
 622		static void						    \n\
 623		%1$s__destroy(struct %1$s *skel)			    \n\
 624		{							    \n\
 625			if (!skel)					    \n\
 626				return;					    \n\
 627			%1$s__detach(skel);				    \n\
 628		",
 629		obj_name);
 630
 631	bpf_object__for_each_program(prog, obj) {
 632		codegen("\
 633			\n\
 634				skel_closenz(skel->progs.%1$s.prog_fd);	    \n\
 635			", bpf_program__name(prog));
 636	}
 637
 638	bpf_object__for_each_map(map, obj) {
 639		if (!get_map_ident(map, ident, sizeof(ident)))
 640			continue;
 641		if (bpf_map__is_internal(map) &&
 642		    (bpf_map__map_flags(map) & BPF_F_MMAPABLE))
 643			printf("\tskel_free_map_data(skel->%1$s, skel->maps.%1$s.initial_value, %2$zd);\n",
 644			       ident, bpf_map_mmap_sz(map));
 645		codegen("\
 646			\n\
 647				skel_closenz(skel->maps.%1$s.map_fd);	    \n\
 648			", ident);
 649	}
 650	codegen("\
 651		\n\
 652			skel_free(skel);				    \n\
 653		}							    \n\
 654		",
 655		obj_name);
 656}
 657
 658static int gen_trace(struct bpf_object *obj, const char *obj_name, const char *header_guard)
 659{
 660	DECLARE_LIBBPF_OPTS(gen_loader_opts, opts);
 661	struct bpf_map *map;
 662	char ident[256];
 663	int err = 0;
 664
 665	err = bpf_object__gen_loader(obj, &opts);
 666	if (err)
 667		return err;
 668
 669	err = bpf_object__load(obj);
 670	if (err) {
 671		p_err("failed to load object file");
 672		goto out;
 673	}
 674	/* If there was no error during load then gen_loader_opts
 675	 * are populated with the loader program.
 676	 */
 677
 678	/* finish generating 'struct skel' */
 679	codegen("\
 680		\n\
 681		};							    \n\
 682		", obj_name);
 683
 684
 685	codegen_attach_detach(obj, obj_name);
 686
 687	codegen_destroy(obj, obj_name);
 688
 689	codegen("\
 690		\n\
 691		static inline struct %1$s *				    \n\
 692		%1$s__open(void)					    \n\
 693		{							    \n\
 694			struct %1$s *skel;				    \n\
 695									    \n\
 696			skel = skel_alloc(sizeof(*skel));		    \n\
 697			if (!skel)					    \n\
 698				goto cleanup;				    \n\
 699			skel->ctx.sz = (void *)&skel->links - (void *)skel; \n\
 700		",
 701		obj_name, opts.data_sz);
 702	bpf_object__for_each_map(map, obj) {
 703		const void *mmap_data = NULL;
 704		size_t mmap_size = 0;
 705
 706		if (!is_internal_mmapable_map(map, ident, sizeof(ident)))
 707			continue;
 708
 709		codegen("\
 710		\n\
 711			{						    \n\
 712				static const char data[] __attribute__((__aligned__(8))) = \"\\\n\
 713		");
 714		mmap_data = bpf_map__initial_value(map, &mmap_size);
 715		print_hex(mmap_data, mmap_size);
 716		codegen("\
 717		\n\
 718		\";							    \n\
 719									    \n\
 720				skel->%1$s = skel_prep_map_data((void *)data, %2$zd,\n\
 721								sizeof(data) - 1);\n\
 722				if (!skel->%1$s)			    \n\
 723					goto cleanup;			    \n\
 724				skel->maps.%1$s.initial_value = (__u64) (long) skel->%1$s;\n\
 725			}						    \n\
 726			", ident, bpf_map_mmap_sz(map));
 727	}
 728	codegen("\
 729		\n\
 730			return skel;					    \n\
 731		cleanup:						    \n\
 732			%1$s__destroy(skel);				    \n\
 733			return NULL;					    \n\
 734		}							    \n\
 735									    \n\
 736		static inline int					    \n\
 737		%1$s__load(struct %1$s *skel)				    \n\
 738		{							    \n\
 739			struct bpf_load_and_run_opts opts = {};		    \n\
 740			int err;					    \n\
 741			static const char opts_data[] __attribute__((__aligned__(8))) = \"\\\n\
 
 
 
 742		",
 743		obj_name);
 744	print_hex(opts.data, opts.data_sz);
 745	codegen("\
 746		\n\
 747		\";							    \n\
 748			static const char opts_insn[] __attribute__((__aligned__(8))) = \"\\\n\
 749		");
 
 
 
 
 
 
 
 750	print_hex(opts.insns, opts.insns_sz);
 751	codegen("\
 752		\n\
 753		\";							    \n\
 754									    \n\
 755			opts.ctx = (struct bpf_loader_ctx *)skel;	    \n\
 756			opts.data_sz = sizeof(opts_data) - 1;		    \n\
 757			opts.data = (void *)opts_data;			    \n\
 758			opts.insns_sz = sizeof(opts_insn) - 1;		    \n\
 759			opts.insns = (void *)opts_insn;			    \n\
 760									    \n\
 761			err = bpf_load_and_run(&opts);			    \n\
 762			if (err < 0)					    \n\
 763				return err;				    \n\
 764		");
 765	bpf_object__for_each_map(map, obj) {
 766		const char *mmap_flags;
 767
 768		if (!is_internal_mmapable_map(map, ident, sizeof(ident)))
 769			continue;
 770
 771		if (bpf_map__map_flags(map) & BPF_F_RDONLY_PROG)
 772			mmap_flags = "PROT_READ";
 773		else
 774			mmap_flags = "PROT_READ | PROT_WRITE";
 775
 776		codegen("\
 777		\n\
 778			skel->%1$s = skel_finalize_map_data(&skel->maps.%1$s.initial_value,  \n\
 779							%2$zd, %3$s, skel->maps.%1$s.map_fd);\n\
 780			if (!skel->%1$s)				    \n\
 781				return -ENOMEM;				    \n\
 782			",
 783		       ident, bpf_map_mmap_sz(map), mmap_flags);
 784	}
 785	codegen("\
 786		\n\
 787			return 0;					    \n\
 788		}							    \n\
 789									    \n\
 790		static inline struct %1$s *				    \n\
 791		%1$s__open_and_load(void)				    \n\
 792		{							    \n\
 793			struct %1$s *skel;				    \n\
 794									    \n\
 795			skel = %1$s__open();				    \n\
 796			if (!skel)					    \n\
 797				return NULL;				    \n\
 798			if (%1$s__load(skel)) {				    \n\
 799				%1$s__destroy(skel);			    \n\
 800				return NULL;				    \n\
 801			}						    \n\
 802			return skel;					    \n\
 803		}							    \n\
 804									    \n\
 805		", obj_name);
 806
 807	codegen_asserts(obj, obj_name);
 808
 809	codegen("\
 810		\n\
 811									    \n\
 812		#endif /* %s */						    \n\
 813		",
 814		header_guard);
 815	err = 0;
 816out:
 817	return err;
 818}
 819
 820static void
 821codegen_maps_skeleton(struct bpf_object *obj, size_t map_cnt, bool mmaped)
 822{
 823	struct bpf_map *map;
 824	char ident[256];
 825	size_t i;
 826
 827	if (!map_cnt)
 828		return;
 829
 830	codegen("\
 831		\n\
 832									\n\
 833			/* maps */				    \n\
 834			s->map_cnt = %zu;			    \n\
 835			s->map_skel_sz = sizeof(*s->maps);	    \n\
 836			s->maps = (struct bpf_map_skeleton *)calloc(s->map_cnt, s->map_skel_sz);\n\
 837			if (!s->maps) {				    \n\
 838				err = -ENOMEM;			    \n\
 839				goto err;			    \n\
 840			}					    \n\
 841		",
 842		map_cnt
 843	);
 844	i = 0;
 845	bpf_object__for_each_map(map, obj) {
 846		if (!get_map_ident(map, ident, sizeof(ident)))
 847			continue;
 848
 849		codegen("\
 850			\n\
 851									\n\
 852				s->maps[%zu].name = \"%s\";	    \n\
 853				s->maps[%zu].map = &obj->maps.%s;   \n\
 854			",
 855			i, bpf_map__name(map), i, ident);
 856		/* memory-mapped internal maps */
 857		if (mmaped && is_internal_mmapable_map(map, ident, sizeof(ident))) {
 858			printf("\ts->maps[%zu].mmaped = (void **)&obj->%s;\n",
 859				i, ident);
 860		}
 861		i++;
 862	}
 863}
 864
 865static void
 866codegen_progs_skeleton(struct bpf_object *obj, size_t prog_cnt, bool populate_links)
 867{
 868	struct bpf_program *prog;
 869	int i;
 870
 871	if (!prog_cnt)
 872		return;
 873
 874	codegen("\
 875		\n\
 876									\n\
 877			/* programs */				    \n\
 878			s->prog_cnt = %zu;			    \n\
 879			s->prog_skel_sz = sizeof(*s->progs);	    \n\
 880			s->progs = (struct bpf_prog_skeleton *)calloc(s->prog_cnt, s->prog_skel_sz);\n\
 881			if (!s->progs) {			    \n\
 882				err = -ENOMEM;			    \n\
 883				goto err;			    \n\
 884			}					    \n\
 885		",
 886		prog_cnt
 887	);
 888	i = 0;
 889	bpf_object__for_each_program(prog, obj) {
 890		codegen("\
 891			\n\
 892									\n\
 893				s->progs[%1$zu].name = \"%2$s\";    \n\
 894				s->progs[%1$zu].prog = &obj->progs.%2$s;\n\
 895			",
 896			i, bpf_program__name(prog));
 897
 898		if (populate_links) {
 899			codegen("\
 900				\n\
 901					s->progs[%1$zu].link = &obj->links.%2$s;\n\
 902				",
 903				i, bpf_program__name(prog));
 904		}
 905		i++;
 906	}
 907}
 908
 909static int do_skeleton(int argc, char **argv)
 910{
 911	char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SKEL_H__")];
 912	size_t map_cnt = 0, prog_cnt = 0, file_sz, mmap_sz;
 913	DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts);
 914	char obj_name[MAX_OBJ_NAME_LEN] = "", *obj_data;
 915	struct bpf_object *obj = NULL;
 916	const char *file;
 917	char ident[256];
 918	struct bpf_program *prog;
 919	int fd, err = -1;
 920	struct bpf_map *map;
 921	struct btf *btf;
 922	struct stat st;
 923
 924	if (!REQ_ARGS(1)) {
 925		usage();
 926		return -1;
 927	}
 928	file = GET_ARG();
 929
 930	while (argc) {
 931		if (!REQ_ARGS(2))
 932			return -1;
 933
 934		if (is_prefix(*argv, "name")) {
 935			NEXT_ARG();
 936
 937			if (obj_name[0] != '\0') {
 938				p_err("object name already specified");
 939				return -1;
 940			}
 941
 942			strncpy(obj_name, *argv, MAX_OBJ_NAME_LEN - 1);
 943			obj_name[MAX_OBJ_NAME_LEN - 1] = '\0';
 944		} else {
 945			p_err("unknown arg %s", *argv);
 946			return -1;
 947		}
 948
 949		NEXT_ARG();
 950	}
 951
 952	if (argc) {
 953		p_err("extra unknown arguments");
 954		return -1;
 955	}
 956
 957	if (stat(file, &st)) {
 958		p_err("failed to stat() %s: %s", file, strerror(errno));
 959		return -1;
 960	}
 961	file_sz = st.st_size;
 962	mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE));
 963	fd = open(file, O_RDONLY);
 964	if (fd < 0) {
 965		p_err("failed to open() %s: %s", file, strerror(errno));
 966		return -1;
 967	}
 968	obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0);
 969	if (obj_data == MAP_FAILED) {
 970		obj_data = NULL;
 971		p_err("failed to mmap() %s: %s", file, strerror(errno));
 972		goto out;
 973	}
 974	if (obj_name[0] == '\0')
 975		get_obj_name(obj_name, file);
 976	opts.object_name = obj_name;
 977	if (verifier_logs)
 978		/* log_level1 + log_level2 + stats, but not stable UAPI */
 979		opts.kernel_log_level = 1 + 2 + 4;
 980	obj = bpf_object__open_mem(obj_data, file_sz, &opts);
 981	if (!obj) {
 982		char err_buf[256];
 983
 984		err = -errno;
 985		libbpf_strerror(err, err_buf, sizeof(err_buf));
 986		p_err("failed to open BPF object file: %s", err_buf);
 987		goto out;
 988	}
 989
 990	bpf_object__for_each_map(map, obj) {
 991		if (!get_map_ident(map, ident, sizeof(ident))) {
 992			p_err("ignoring unrecognized internal map '%s'...",
 993			      bpf_map__name(map));
 994			continue;
 995		}
 996		map_cnt++;
 997	}
 998	bpf_object__for_each_program(prog, obj) {
 999		prog_cnt++;
1000	}
1001
1002	get_header_guard(header_guard, obj_name, "SKEL_H");
1003	if (use_loader) {
1004		codegen("\
1005		\n\
1006		/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */   \n\
1007		/* THIS FILE IS AUTOGENERATED BY BPFTOOL! */		    \n\
1008		#ifndef %2$s						    \n\
1009		#define %2$s						    \n\
1010									    \n\
1011		#include <bpf/skel_internal.h>				    \n\
1012									    \n\
1013		struct %1$s {						    \n\
1014			struct bpf_loader_ctx ctx;			    \n\
1015		",
1016		obj_name, header_guard
1017		);
1018	} else {
1019		codegen("\
1020		\n\
1021		/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */   \n\
1022									    \n\
1023		/* THIS FILE IS AUTOGENERATED BY BPFTOOL! */		    \n\
1024		#ifndef %2$s						    \n\
1025		#define %2$s						    \n\
1026									    \n\
1027		#include <errno.h>					    \n\
1028		#include <stdlib.h>					    \n\
1029		#include <bpf/libbpf.h>					    \n\
1030									    \n\
1031		struct %1$s {						    \n\
1032			struct bpf_object_skeleton *skeleton;		    \n\
1033			struct bpf_object *obj;				    \n\
1034		",
1035		obj_name, header_guard
1036		);
1037	}
1038
1039	if (map_cnt) {
1040		printf("\tstruct {\n");
1041		bpf_object__for_each_map(map, obj) {
1042			if (!get_map_ident(map, ident, sizeof(ident)))
1043				continue;
1044			if (use_loader)
1045				printf("\t\tstruct bpf_map_desc %s;\n", ident);
1046			else
1047				printf("\t\tstruct bpf_map *%s;\n", ident);
1048		}
1049		printf("\t} maps;\n");
1050	}
1051
1052	if (prog_cnt) {
1053		printf("\tstruct {\n");
1054		bpf_object__for_each_program(prog, obj) {
1055			if (use_loader)
1056				printf("\t\tstruct bpf_prog_desc %s;\n",
1057				       bpf_program__name(prog));
1058			else
1059				printf("\t\tstruct bpf_program *%s;\n",
1060				       bpf_program__name(prog));
1061		}
1062		printf("\t} progs;\n");
1063		printf("\tstruct {\n");
1064		bpf_object__for_each_program(prog, obj) {
1065			if (use_loader)
1066				printf("\t\tint %s_fd;\n",
1067				       bpf_program__name(prog));
1068			else
1069				printf("\t\tstruct bpf_link *%s;\n",
1070				       bpf_program__name(prog));
1071		}
1072		printf("\t} links;\n");
1073	}
1074
1075	btf = bpf_object__btf(obj);
1076	if (btf) {
1077		err = codegen_datasecs(obj, obj_name);
1078		if (err)
1079			goto out;
1080	}
1081	if (use_loader) {
1082		err = gen_trace(obj, obj_name, header_guard);
1083		goto out;
1084	}
1085
1086	codegen("\
1087		\n\
1088									    \n\
1089		#ifdef __cplusplus					    \n\
1090			static inline struct %1$s *open(const struct bpf_object_open_opts *opts = nullptr);\n\
1091			static inline struct %1$s *open_and_load();	    \n\
1092			static inline int load(struct %1$s *skel);	    \n\
1093			static inline int attach(struct %1$s *skel);	    \n\
1094			static inline void detach(struct %1$s *skel);	    \n\
1095			static inline void destroy(struct %1$s *skel);	    \n\
1096			static inline const void *elf_bytes(size_t *sz);    \n\
1097		#endif /* __cplusplus */				    \n\
1098		};							    \n\
1099									    \n\
1100		static void						    \n\
1101		%1$s__destroy(struct %1$s *obj)				    \n\
1102		{							    \n\
1103			if (!obj)					    \n\
1104				return;					    \n\
1105			if (obj->skeleton)				    \n\
1106				bpf_object__destroy_skeleton(obj->skeleton);\n\
1107			free(obj);					    \n\
1108		}							    \n\
1109									    \n\
1110		static inline int					    \n\
1111		%1$s__create_skeleton(struct %1$s *obj);		    \n\
1112									    \n\
1113		static inline struct %1$s *				    \n\
1114		%1$s__open_opts(const struct bpf_object_open_opts *opts)    \n\
1115		{							    \n\
1116			struct %1$s *obj;				    \n\
1117			int err;					    \n\
1118									    \n\
1119			obj = (struct %1$s *)calloc(1, sizeof(*obj));	    \n\
1120			if (!obj) {					    \n\
1121				errno = ENOMEM;				    \n\
1122				return NULL;				    \n\
1123			}						    \n\
1124									    \n\
1125			err = %1$s__create_skeleton(obj);		    \n\
1126			if (err)					    \n\
1127				goto err_out;				    \n\
1128									    \n\
1129			err = bpf_object__open_skeleton(obj->skeleton, opts);\n\
1130			if (err)					    \n\
1131				goto err_out;				    \n\
1132									    \n\
1133			return obj;					    \n\
1134		err_out:						    \n\
1135			%1$s__destroy(obj);				    \n\
1136			errno = -err;					    \n\
1137			return NULL;					    \n\
1138		}							    \n\
1139									    \n\
1140		static inline struct %1$s *				    \n\
1141		%1$s__open(void)					    \n\
1142		{							    \n\
1143			return %1$s__open_opts(NULL);			    \n\
1144		}							    \n\
1145									    \n\
1146		static inline int					    \n\
1147		%1$s__load(struct %1$s *obj)				    \n\
1148		{							    \n\
1149			return bpf_object__load_skeleton(obj->skeleton);    \n\
1150		}							    \n\
1151									    \n\
1152		static inline struct %1$s *				    \n\
1153		%1$s__open_and_load(void)				    \n\
1154		{							    \n\
1155			struct %1$s *obj;				    \n\
1156			int err;					    \n\
1157									    \n\
1158			obj = %1$s__open();				    \n\
1159			if (!obj)					    \n\
1160				return NULL;				    \n\
1161			err = %1$s__load(obj);				    \n\
1162			if (err) {					    \n\
1163				%1$s__destroy(obj);			    \n\
1164				errno = -err;				    \n\
1165				return NULL;				    \n\
1166			}						    \n\
1167			return obj;					    \n\
1168		}							    \n\
1169									    \n\
1170		static inline int					    \n\
1171		%1$s__attach(struct %1$s *obj)				    \n\
1172		{							    \n\
1173			return bpf_object__attach_skeleton(obj->skeleton);  \n\
1174		}							    \n\
1175									    \n\
1176		static inline void					    \n\
1177		%1$s__detach(struct %1$s *obj)				    \n\
1178		{							    \n\
1179			bpf_object__detach_skeleton(obj->skeleton);	    \n\
1180		}							    \n\
1181		",
1182		obj_name
1183	);
1184
1185	codegen("\
1186		\n\
1187									    \n\
1188		static inline const void *%1$s__elf_bytes(size_t *sz);	    \n\
1189									    \n\
1190		static inline int					    \n\
1191		%1$s__create_skeleton(struct %1$s *obj)			    \n\
1192		{							    \n\
1193			struct bpf_object_skeleton *s;			    \n\
1194			int err;					    \n\
1195									    \n\
1196			s = (struct bpf_object_skeleton *)calloc(1, sizeof(*s));\n\
1197			if (!s)	{					    \n\
1198				err = -ENOMEM;				    \n\
1199				goto err;				    \n\
1200			}						    \n\
1201									    \n\
1202			s->sz = sizeof(*s);				    \n\
1203			s->name = \"%1$s\";				    \n\
1204			s->obj = &obj->obj;				    \n\
1205		",
1206		obj_name
1207	);
1208
1209	codegen_maps_skeleton(obj, map_cnt, true /*mmaped*/);
1210	codegen_progs_skeleton(obj, prog_cnt, true /*populate_links*/);
1211
1212	codegen("\
1213		\n\
1214									    \n\
1215			s->data = %1$s__elf_bytes(&s->data_sz);		    \n\
1216									    \n\
1217			obj->skeleton = s;				    \n\
1218			return 0;					    \n\
1219		err:							    \n\
1220			bpf_object__destroy_skeleton(s);		    \n\
1221			return err;					    \n\
1222		}							    \n\
1223									    \n\
1224		static inline const void *%1$s__elf_bytes(size_t *sz)	    \n\
1225		{							    \n\
1226			static const char data[] __attribute__((__aligned__(8))) = \"\\\n\
1227		",
1228		obj_name
1229	);
1230
1231	/* embed contents of BPF object file */
1232	print_hex(obj_data, file_sz);
1233
1234	codegen("\
1235		\n\
1236		\";							    \n\
1237									    \n\
1238			*sz = sizeof(data) - 1;				    \n\
1239			return (const void *)data;			    \n\
1240		}							    \n\
1241									    \n\
1242		#ifdef __cplusplus					    \n\
1243		struct %1$s *%1$s::open(const struct bpf_object_open_opts *opts) { return %1$s__open_opts(opts); }\n\
1244		struct %1$s *%1$s::open_and_load() { return %1$s__open_and_load(); }	\n\
1245		int %1$s::load(struct %1$s *skel) { return %1$s__load(skel); }		\n\
1246		int %1$s::attach(struct %1$s *skel) { return %1$s__attach(skel); }	\n\
1247		void %1$s::detach(struct %1$s *skel) { %1$s__detach(skel); }		\n\
1248		void %1$s::destroy(struct %1$s *skel) { %1$s__destroy(skel); }		\n\
1249		const void *%1$s::elf_bytes(size_t *sz) { return %1$s__elf_bytes(sz); } \n\
1250		#endif /* __cplusplus */				    \n\
1251									    \n\
1252		",
1253		obj_name);
1254
1255	codegen_asserts(obj, obj_name);
1256
1257	codegen("\
1258		\n\
1259									    \n\
1260		#endif /* %1$s */					    \n\
1261		",
1262		header_guard);
1263	err = 0;
1264out:
1265	bpf_object__close(obj);
1266	if (obj_data)
1267		munmap(obj_data, mmap_sz);
1268	close(fd);
1269	return err;
1270}
1271
1272/* Subskeletons are like skeletons, except they don't own the bpf_object,
1273 * associated maps, links, etc. Instead, they know about the existence of
1274 * variables, maps, programs and are able to find their locations
1275 * _at runtime_ from an already loaded bpf_object.
1276 *
1277 * This allows for library-like BPF objects to have userspace counterparts
1278 * with access to their own items without having to know anything about the
1279 * final BPF object that the library was linked into.
1280 */
1281static int do_subskeleton(int argc, char **argv)
1282{
1283	char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SUBSKEL_H__")];
1284	size_t i, len, file_sz, map_cnt = 0, prog_cnt = 0, mmap_sz, var_cnt = 0, var_idx = 0;
1285	DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts);
1286	char obj_name[MAX_OBJ_NAME_LEN] = "", *obj_data;
1287	struct bpf_object *obj = NULL;
1288	const char *file, *var_name;
1289	char ident[256];
1290	int fd, err = -1, map_type_id;
1291	const struct bpf_map *map;
1292	struct bpf_program *prog;
1293	struct btf *btf;
1294	const struct btf_type *map_type, *var_type;
1295	const struct btf_var_secinfo *var;
1296	struct stat st;
1297
1298	if (!REQ_ARGS(1)) {
1299		usage();
1300		return -1;
1301	}
1302	file = GET_ARG();
1303
1304	while (argc) {
1305		if (!REQ_ARGS(2))
1306			return -1;
1307
1308		if (is_prefix(*argv, "name")) {
1309			NEXT_ARG();
1310
1311			if (obj_name[0] != '\0') {
1312				p_err("object name already specified");
1313				return -1;
1314			}
1315
1316			strncpy(obj_name, *argv, MAX_OBJ_NAME_LEN - 1);
1317			obj_name[MAX_OBJ_NAME_LEN - 1] = '\0';
1318		} else {
1319			p_err("unknown arg %s", *argv);
1320			return -1;
1321		}
1322
1323		NEXT_ARG();
1324	}
1325
1326	if (argc) {
1327		p_err("extra unknown arguments");
1328		return -1;
1329	}
1330
1331	if (use_loader) {
1332		p_err("cannot use loader for subskeletons");
1333		return -1;
1334	}
1335
1336	if (stat(file, &st)) {
1337		p_err("failed to stat() %s: %s", file, strerror(errno));
1338		return -1;
1339	}
1340	file_sz = st.st_size;
1341	mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE));
1342	fd = open(file, O_RDONLY);
1343	if (fd < 0) {
1344		p_err("failed to open() %s: %s", file, strerror(errno));
1345		return -1;
1346	}
1347	obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0);
1348	if (obj_data == MAP_FAILED) {
1349		obj_data = NULL;
1350		p_err("failed to mmap() %s: %s", file, strerror(errno));
1351		goto out;
1352	}
1353	if (obj_name[0] == '\0')
1354		get_obj_name(obj_name, file);
1355
1356	/* The empty object name allows us to use bpf_map__name and produce
1357	 * ELF section names out of it. (".data" instead of "obj.data")
1358	 */
1359	opts.object_name = "";
1360	obj = bpf_object__open_mem(obj_data, file_sz, &opts);
1361	if (!obj) {
1362		char err_buf[256];
1363
1364		libbpf_strerror(errno, err_buf, sizeof(err_buf));
1365		p_err("failed to open BPF object file: %s", err_buf);
1366		obj = NULL;
1367		goto out;
1368	}
1369
1370	btf = bpf_object__btf(obj);
1371	if (!btf) {
1372		err = -1;
1373		p_err("need btf type information for %s", obj_name);
1374		goto out;
1375	}
1376
1377	bpf_object__for_each_program(prog, obj) {
1378		prog_cnt++;
1379	}
1380
1381	/* First, count how many variables we have to find.
1382	 * We need this in advance so the subskel can allocate the right
1383	 * amount of storage.
1384	 */
1385	bpf_object__for_each_map(map, obj) {
1386		if (!get_map_ident(map, ident, sizeof(ident)))
1387			continue;
1388
1389		/* Also count all maps that have a name */
1390		map_cnt++;
1391
1392		if (!is_internal_mmapable_map(map, ident, sizeof(ident)))
1393			continue;
1394
1395		map_type_id = bpf_map__btf_value_type_id(map);
1396		if (map_type_id <= 0) {
1397			err = map_type_id;
1398			goto out;
1399		}
1400		map_type = btf__type_by_id(btf, map_type_id);
1401
1402		var = btf_var_secinfos(map_type);
1403		len = btf_vlen(map_type);
1404		for (i = 0; i < len; i++, var++) {
1405			var_type = btf__type_by_id(btf, var->type);
1406
1407			if (btf_var(var_type)->linkage == BTF_VAR_STATIC)
1408				continue;
1409
1410			var_cnt++;
1411		}
1412	}
1413
1414	get_header_guard(header_guard, obj_name, "SUBSKEL_H");
1415	codegen("\
1416	\n\
1417	/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */	    \n\
1418									    \n\
1419	/* THIS FILE IS AUTOGENERATED! */				    \n\
1420	#ifndef %2$s							    \n\
1421	#define %2$s							    \n\
1422									    \n\
1423	#include <errno.h>						    \n\
1424	#include <stdlib.h>						    \n\
1425	#include <bpf/libbpf.h>						    \n\
1426									    \n\
1427	struct %1$s {							    \n\
1428		struct bpf_object *obj;					    \n\
1429		struct bpf_object_subskeleton *subskel;			    \n\
1430	", obj_name, header_guard);
1431
1432	if (map_cnt) {
1433		printf("\tstruct {\n");
1434		bpf_object__for_each_map(map, obj) {
1435			if (!get_map_ident(map, ident, sizeof(ident)))
1436				continue;
1437			printf("\t\tstruct bpf_map *%s;\n", ident);
1438		}
1439		printf("\t} maps;\n");
1440	}
1441
1442	if (prog_cnt) {
1443		printf("\tstruct {\n");
1444		bpf_object__for_each_program(prog, obj) {
1445			printf("\t\tstruct bpf_program *%s;\n",
1446				bpf_program__name(prog));
1447		}
1448		printf("\t} progs;\n");
1449	}
1450
1451	err = codegen_subskel_datasecs(obj, obj_name);
1452	if (err)
1453		goto out;
1454
1455	/* emit code that will allocate enough storage for all symbols */
1456	codegen("\
1457		\n\
1458									    \n\
1459		#ifdef __cplusplus					    \n\
1460			static inline struct %1$s *open(const struct bpf_object *src);\n\
1461			static inline void destroy(struct %1$s *skel);	    \n\
1462		#endif /* __cplusplus */				    \n\
1463		};							    \n\
1464									    \n\
1465		static inline void					    \n\
1466		%1$s__destroy(struct %1$s *skel)			    \n\
1467		{							    \n\
1468			if (!skel)					    \n\
1469				return;					    \n\
1470			if (skel->subskel)				    \n\
1471				bpf_object__destroy_subskeleton(skel->subskel);\n\
1472			free(skel);					    \n\
1473		}							    \n\
1474									    \n\
1475		static inline struct %1$s *				    \n\
1476		%1$s__open(const struct bpf_object *src)		    \n\
1477		{							    \n\
1478			struct %1$s *obj;				    \n\
1479			struct bpf_object_subskeleton *s;		    \n\
1480			int err;					    \n\
1481									    \n\
1482			obj = (struct %1$s *)calloc(1, sizeof(*obj));	    \n\
1483			if (!obj) {					    \n\
1484				err = -ENOMEM;				    \n\
1485				goto err;				    \n\
1486			}						    \n\
1487			s = (struct bpf_object_subskeleton *)calloc(1, sizeof(*s));\n\
1488			if (!s) {					    \n\
1489				err = -ENOMEM;				    \n\
1490				goto err;				    \n\
1491			}						    \n\
1492			s->sz = sizeof(*s);				    \n\
1493			s->obj = src;					    \n\
1494			s->var_skel_sz = sizeof(*s->vars);		    \n\
1495			obj->subskel = s;				    \n\
1496									    \n\
1497			/* vars */					    \n\
1498			s->var_cnt = %2$d;				    \n\
1499			s->vars = (struct bpf_var_skeleton *)calloc(%2$d, sizeof(*s->vars));\n\
1500			if (!s->vars) {					    \n\
1501				err = -ENOMEM;				    \n\
1502				goto err;				    \n\
1503			}						    \n\
1504		",
1505		obj_name, var_cnt
1506	);
1507
1508	/* walk through each symbol and emit the runtime representation */
1509	bpf_object__for_each_map(map, obj) {
1510		if (!is_internal_mmapable_map(map, ident, sizeof(ident)))
1511			continue;
1512
1513		map_type_id = bpf_map__btf_value_type_id(map);
1514		if (map_type_id <= 0)
1515			/* skip over internal maps with no type*/
1516			continue;
1517
1518		map_type = btf__type_by_id(btf, map_type_id);
1519		var = btf_var_secinfos(map_type);
1520		len = btf_vlen(map_type);
1521		for (i = 0; i < len; i++, var++) {
1522			var_type = btf__type_by_id(btf, var->type);
1523			var_name = btf__name_by_offset(btf, var_type->name_off);
1524
1525			if (btf_var(var_type)->linkage == BTF_VAR_STATIC)
1526				continue;
1527
1528			/* Note that we use the dot prefix in .data as the
1529			 * field access operator i.e. maps%s becomes maps.data
1530			 */
1531			codegen("\
1532			\n\
1533									    \n\
1534				s->vars[%3$d].name = \"%1$s\";		    \n\
1535				s->vars[%3$d].map = &obj->maps.%2$s;	    \n\
1536				s->vars[%3$d].addr = (void **) &obj->%2$s.%1$s;\n\
1537			", var_name, ident, var_idx);
1538
1539			var_idx++;
1540		}
1541	}
1542
1543	codegen_maps_skeleton(obj, map_cnt, false /*mmaped*/);
1544	codegen_progs_skeleton(obj, prog_cnt, false /*links*/);
1545
1546	codegen("\
1547		\n\
1548									    \n\
1549			err = bpf_object__open_subskeleton(s);		    \n\
1550			if (err)					    \n\
1551				goto err;				    \n\
1552									    \n\
1553			return obj;					    \n\
1554		err:							    \n\
1555			%1$s__destroy(obj);				    \n\
1556			errno = -err;					    \n\
1557			return NULL;					    \n\
1558		}							    \n\
1559									    \n\
1560		#ifdef __cplusplus					    \n\
1561		struct %1$s *%1$s::open(const struct bpf_object *src) { return %1$s__open(src); }\n\
1562		void %1$s::destroy(struct %1$s *skel) { %1$s__destroy(skel); }\n\
1563		#endif /* __cplusplus */				    \n\
1564									    \n\
1565		#endif /* %2$s */					    \n\
1566		",
1567		obj_name, header_guard);
1568	err = 0;
1569out:
1570	bpf_object__close(obj);
1571	if (obj_data)
1572		munmap(obj_data, mmap_sz);
1573	close(fd);
1574	return err;
1575}
1576
1577static int do_object(int argc, char **argv)
1578{
1579	struct bpf_linker *linker;
1580	const char *output_file, *file;
1581	int err = 0;
1582
1583	if (!REQ_ARGS(2)) {
1584		usage();
1585		return -1;
1586	}
1587
1588	output_file = GET_ARG();
1589
1590	linker = bpf_linker__new(output_file, NULL);
1591	if (!linker) {
1592		p_err("failed to create BPF linker instance");
1593		return -1;
1594	}
1595
1596	while (argc) {
1597		file = GET_ARG();
1598
1599		err = bpf_linker__add_file(linker, file, NULL);
1600		if (err) {
1601			p_err("failed to link '%s': %s (%d)", file, strerror(errno), errno);
1602			goto out;
1603		}
1604	}
1605
1606	err = bpf_linker__finalize(linker);
1607	if (err) {
1608		p_err("failed to finalize ELF file: %s (%d)", strerror(errno), errno);
1609		goto out;
1610	}
1611
1612	err = 0;
1613out:
1614	bpf_linker__free(linker);
1615	return err;
1616}
1617
1618static int do_help(int argc, char **argv)
1619{
1620	if (json_output) {
1621		jsonw_null(json_wtr);
1622		return 0;
1623	}
1624
1625	fprintf(stderr,
1626		"Usage: %1$s %2$s object OUTPUT_FILE INPUT_FILE [INPUT_FILE...]\n"
1627		"       %1$s %2$s skeleton FILE [name OBJECT_NAME]\n"
1628		"       %1$s %2$s subskeleton FILE [name OBJECT_NAME]\n"
1629		"       %1$s %2$s min_core_btf INPUT OUTPUT OBJECT [OBJECT...]\n"
1630		"       %1$s %2$s help\n"
1631		"\n"
1632		"       " HELP_SPEC_OPTIONS " |\n"
1633		"                    {-L|--use-loader} }\n"
1634		"",
1635		bin_name, "gen");
1636
1637	return 0;
1638}
1639
1640static int btf_save_raw(const struct btf *btf, const char *path)
1641{
1642	const void *data;
1643	FILE *f = NULL;
1644	__u32 data_sz;
1645	int err = 0;
1646
1647	data = btf__raw_data(btf, &data_sz);
1648	if (!data)
1649		return -ENOMEM;
1650
1651	f = fopen(path, "wb");
1652	if (!f)
1653		return -errno;
1654
1655	if (fwrite(data, 1, data_sz, f) != data_sz)
1656		err = -errno;
1657
1658	fclose(f);
1659	return err;
1660}
1661
1662struct btfgen_info {
1663	struct btf *src_btf;
1664	struct btf *marked_btf; /* btf structure used to mark used types */
1665};
1666
1667static size_t btfgen_hash_fn(long key, void *ctx)
1668{
1669	return key;
1670}
1671
1672static bool btfgen_equal_fn(long k1, long k2, void *ctx)
1673{
1674	return k1 == k2;
1675}
1676
1677static void btfgen_free_info(struct btfgen_info *info)
1678{
1679	if (!info)
1680		return;
1681
1682	btf__free(info->src_btf);
1683	btf__free(info->marked_btf);
1684
1685	free(info);
1686}
1687
1688static struct btfgen_info *
1689btfgen_new_info(const char *targ_btf_path)
1690{
1691	struct btfgen_info *info;
1692	int err;
1693
1694	info = calloc(1, sizeof(*info));
1695	if (!info)
1696		return NULL;
1697
1698	info->src_btf = btf__parse(targ_btf_path, NULL);
1699	if (!info->src_btf) {
1700		err = -errno;
1701		p_err("failed parsing '%s' BTF file: %s", targ_btf_path, strerror(errno));
1702		goto err_out;
1703	}
1704
1705	info->marked_btf = btf__parse(targ_btf_path, NULL);
1706	if (!info->marked_btf) {
1707		err = -errno;
1708		p_err("failed parsing '%s' BTF file: %s", targ_btf_path, strerror(errno));
1709		goto err_out;
1710	}
1711
1712	return info;
1713
1714err_out:
1715	btfgen_free_info(info);
1716	errno = -err;
1717	return NULL;
1718}
1719
1720#define MARKED UINT32_MAX
1721
1722static void btfgen_mark_member(struct btfgen_info *info, int type_id, int idx)
1723{
1724	const struct btf_type *t = btf__type_by_id(info->marked_btf, type_id);
1725	struct btf_member *m = btf_members(t) + idx;
1726
1727	m->name_off = MARKED;
1728}
1729
1730static int
1731btfgen_mark_type(struct btfgen_info *info, unsigned int type_id, bool follow_pointers)
1732{
1733	const struct btf_type *btf_type = btf__type_by_id(info->src_btf, type_id);
1734	struct btf_type *cloned_type;
1735	struct btf_param *param;
1736	struct btf_array *array;
1737	int err, i;
1738
1739	if (type_id == 0)
1740		return 0;
1741
1742	/* mark type on cloned BTF as used */
1743	cloned_type = (struct btf_type *) btf__type_by_id(info->marked_btf, type_id);
1744	cloned_type->name_off = MARKED;
1745
1746	/* recursively mark other types needed by it */
1747	switch (btf_kind(btf_type)) {
1748	case BTF_KIND_UNKN:
1749	case BTF_KIND_INT:
1750	case BTF_KIND_FLOAT:
1751	case BTF_KIND_ENUM:
1752	case BTF_KIND_ENUM64:
1753	case BTF_KIND_STRUCT:
1754	case BTF_KIND_UNION:
1755		break;
1756	case BTF_KIND_PTR:
1757		if (follow_pointers) {
1758			err = btfgen_mark_type(info, btf_type->type, follow_pointers);
1759			if (err)
1760				return err;
1761		}
1762		break;
1763	case BTF_KIND_CONST:
1764	case BTF_KIND_RESTRICT:
1765	case BTF_KIND_VOLATILE:
1766	case BTF_KIND_TYPEDEF:
1767		err = btfgen_mark_type(info, btf_type->type, follow_pointers);
1768		if (err)
1769			return err;
1770		break;
1771	case BTF_KIND_ARRAY:
1772		array = btf_array(btf_type);
1773
1774		/* mark array type */
1775		err = btfgen_mark_type(info, array->type, follow_pointers);
1776		/* mark array's index type */
1777		err = err ? : btfgen_mark_type(info, array->index_type, follow_pointers);
1778		if (err)
1779			return err;
1780		break;
1781	case BTF_KIND_FUNC_PROTO:
1782		/* mark ret type */
1783		err = btfgen_mark_type(info, btf_type->type, follow_pointers);
1784		if (err)
1785			return err;
1786
1787		/* mark parameters types */
1788		param = btf_params(btf_type);
1789		for (i = 0; i < btf_vlen(btf_type); i++) {
1790			err = btfgen_mark_type(info, param->type, follow_pointers);
1791			if (err)
1792				return err;
1793			param++;
1794		}
1795		break;
1796	/* tells if some other type needs to be handled */
1797	default:
1798		p_err("unsupported kind: %s (%d)", btf_kind_str(btf_type), type_id);
1799		return -EINVAL;
1800	}
1801
1802	return 0;
1803}
1804
1805static int btfgen_record_field_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
1806{
1807	struct btf *btf = info->src_btf;
1808	const struct btf_type *btf_type;
1809	struct btf_member *btf_member;
1810	struct btf_array *array;
1811	unsigned int type_id = targ_spec->root_type_id;
1812	int idx, err;
1813
1814	/* mark root type */
1815	btf_type = btf__type_by_id(btf, type_id);
1816	err = btfgen_mark_type(info, type_id, false);
1817	if (err)
1818		return err;
1819
1820	/* mark types for complex types (arrays, unions, structures) */
1821	for (int i = 1; i < targ_spec->raw_len; i++) {
1822		/* skip typedefs and mods */
1823		while (btf_is_mod(btf_type) || btf_is_typedef(btf_type)) {
1824			type_id = btf_type->type;
1825			btf_type = btf__type_by_id(btf, type_id);
1826		}
1827
1828		switch (btf_kind(btf_type)) {
1829		case BTF_KIND_STRUCT:
1830		case BTF_KIND_UNION:
1831			idx = targ_spec->raw_spec[i];
1832			btf_member = btf_members(btf_type) + idx;
1833
1834			/* mark member */
1835			btfgen_mark_member(info, type_id, idx);
1836
1837			/* mark member's type */
1838			type_id = btf_member->type;
1839			btf_type = btf__type_by_id(btf, type_id);
1840			err = btfgen_mark_type(info, type_id, false);
1841			if (err)
1842				return err;
1843			break;
1844		case BTF_KIND_ARRAY:
1845			array = btf_array(btf_type);
1846			type_id = array->type;
1847			btf_type = btf__type_by_id(btf, type_id);
1848			break;
1849		default:
1850			p_err("unsupported kind: %s (%d)",
1851			      btf_kind_str(btf_type), btf_type->type);
1852			return -EINVAL;
1853		}
1854	}
1855
1856	return 0;
1857}
1858
1859/* Mark types, members, and member types. Compared to btfgen_record_field_relo,
1860 * this function does not rely on the target spec for inferring members, but
1861 * uses the associated BTF.
1862 *
1863 * The `behind_ptr` argument is used to stop marking of composite types reached
1864 * through a pointer. This way, we can keep BTF size in check while providing
1865 * reasonable match semantics.
1866 */
1867static int btfgen_mark_type_match(struct btfgen_info *info, __u32 type_id, bool behind_ptr)
1868{
1869	const struct btf_type *btf_type;
1870	struct btf *btf = info->src_btf;
1871	struct btf_type *cloned_type;
1872	int i, err;
1873
1874	if (type_id == 0)
1875		return 0;
1876
1877	btf_type = btf__type_by_id(btf, type_id);
1878	/* mark type on cloned BTF as used */
1879	cloned_type = (struct btf_type *)btf__type_by_id(info->marked_btf, type_id);
1880	cloned_type->name_off = MARKED;
1881
1882	switch (btf_kind(btf_type)) {
1883	case BTF_KIND_UNKN:
1884	case BTF_KIND_INT:
1885	case BTF_KIND_FLOAT:
1886	case BTF_KIND_ENUM:
1887	case BTF_KIND_ENUM64:
1888		break;
1889	case BTF_KIND_STRUCT:
1890	case BTF_KIND_UNION: {
1891		struct btf_member *m = btf_members(btf_type);
1892		__u16 vlen = btf_vlen(btf_type);
1893
1894		if (behind_ptr)
1895			break;
1896
1897		for (i = 0; i < vlen; i++, m++) {
1898			/* mark member */
1899			btfgen_mark_member(info, type_id, i);
1900
1901			/* mark member's type */
1902			err = btfgen_mark_type_match(info, m->type, false);
1903			if (err)
1904				return err;
1905		}
1906		break;
1907	}
1908	case BTF_KIND_CONST:
1909	case BTF_KIND_FWD:
1910	case BTF_KIND_RESTRICT:
1911	case BTF_KIND_TYPEDEF:
1912	case BTF_KIND_VOLATILE:
1913		return btfgen_mark_type_match(info, btf_type->type, behind_ptr);
1914	case BTF_KIND_PTR:
1915		return btfgen_mark_type_match(info, btf_type->type, true);
1916	case BTF_KIND_ARRAY: {
1917		struct btf_array *array;
1918
1919		array = btf_array(btf_type);
1920		/* mark array type */
1921		err = btfgen_mark_type_match(info, array->type, false);
1922		/* mark array's index type */
1923		err = err ? : btfgen_mark_type_match(info, array->index_type, false);
1924		if (err)
1925			return err;
1926		break;
1927	}
1928	case BTF_KIND_FUNC_PROTO: {
1929		__u16 vlen = btf_vlen(btf_type);
1930		struct btf_param *param;
1931
1932		/* mark ret type */
1933		err = btfgen_mark_type_match(info, btf_type->type, false);
1934		if (err)
1935			return err;
1936
1937		/* mark parameters types */
1938		param = btf_params(btf_type);
1939		for (i = 0; i < vlen; i++) {
1940			err = btfgen_mark_type_match(info, param->type, false);
1941			if (err)
1942				return err;
1943			param++;
1944		}
1945		break;
1946	}
1947	/* tells if some other type needs to be handled */
1948	default:
1949		p_err("unsupported kind: %s (%d)", btf_kind_str(btf_type), type_id);
1950		return -EINVAL;
1951	}
1952
1953	return 0;
1954}
1955
1956/* Mark types, members, and member types. Compared to btfgen_record_field_relo,
1957 * this function does not rely on the target spec for inferring members, but
1958 * uses the associated BTF.
1959 */
1960static int btfgen_record_type_match_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
1961{
1962	return btfgen_mark_type_match(info, targ_spec->root_type_id, false);
1963}
1964
1965static int btfgen_record_type_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
1966{
1967	return btfgen_mark_type(info, targ_spec->root_type_id, true);
1968}
1969
1970static int btfgen_record_enumval_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
1971{
1972	return btfgen_mark_type(info, targ_spec->root_type_id, false);
1973}
1974
1975static int btfgen_record_reloc(struct btfgen_info *info, struct bpf_core_spec *res)
1976{
1977	switch (res->relo_kind) {
1978	case BPF_CORE_FIELD_BYTE_OFFSET:
1979	case BPF_CORE_FIELD_BYTE_SIZE:
1980	case BPF_CORE_FIELD_EXISTS:
1981	case BPF_CORE_FIELD_SIGNED:
1982	case BPF_CORE_FIELD_LSHIFT_U64:
1983	case BPF_CORE_FIELD_RSHIFT_U64:
1984		return btfgen_record_field_relo(info, res);
1985	case BPF_CORE_TYPE_ID_LOCAL: /* BPF_CORE_TYPE_ID_LOCAL doesn't require kernel BTF */
1986		return 0;
1987	case BPF_CORE_TYPE_ID_TARGET:
1988	case BPF_CORE_TYPE_EXISTS:
1989	case BPF_CORE_TYPE_SIZE:
1990		return btfgen_record_type_relo(info, res);
1991	case BPF_CORE_TYPE_MATCHES:
1992		return btfgen_record_type_match_relo(info, res);
1993	case BPF_CORE_ENUMVAL_EXISTS:
1994	case BPF_CORE_ENUMVAL_VALUE:
1995		return btfgen_record_enumval_relo(info, res);
1996	default:
1997		return -EINVAL;
1998	}
1999}
2000
2001static struct bpf_core_cand_list *
2002btfgen_find_cands(const struct btf *local_btf, const struct btf *targ_btf, __u32 local_id)
2003{
2004	const struct btf_type *local_type;
2005	struct bpf_core_cand_list *cands = NULL;
2006	struct bpf_core_cand local_cand = {};
2007	size_t local_essent_len;
2008	const char *local_name;
2009	int err;
2010
2011	local_cand.btf = local_btf;
2012	local_cand.id = local_id;
2013
2014	local_type = btf__type_by_id(local_btf, local_id);
2015	if (!local_type) {
2016		err = -EINVAL;
2017		goto err_out;
2018	}
2019
2020	local_name = btf__name_by_offset(local_btf, local_type->name_off);
2021	if (!local_name) {
2022		err = -EINVAL;
2023		goto err_out;
2024	}
2025	local_essent_len = bpf_core_essential_name_len(local_name);
2026
2027	cands = calloc(1, sizeof(*cands));
2028	if (!cands)
2029		return NULL;
2030
2031	err = bpf_core_add_cands(&local_cand, local_essent_len, targ_btf, "vmlinux", 1, cands);
2032	if (err)
2033		goto err_out;
2034
2035	return cands;
2036
2037err_out:
2038	bpf_core_free_cands(cands);
2039	errno = -err;
2040	return NULL;
2041}
2042
2043/* Record relocation information for a single BPF object */
2044static int btfgen_record_obj(struct btfgen_info *info, const char *obj_path)
2045{
2046	const struct btf_ext_info_sec *sec;
2047	const struct bpf_core_relo *relo;
2048	const struct btf_ext_info *seg;
2049	struct hashmap_entry *entry;
2050	struct hashmap *cand_cache = NULL;
2051	struct btf_ext *btf_ext = NULL;
2052	unsigned int relo_idx;
2053	struct btf *btf = NULL;
2054	size_t i;
2055	int err;
2056
2057	btf = btf__parse(obj_path, &btf_ext);
2058	if (!btf) {
2059		err = -errno;
2060		p_err("failed to parse BPF object '%s': %s", obj_path, strerror(errno));
2061		return err;
2062	}
2063
2064	if (!btf_ext) {
2065		p_err("failed to parse BPF object '%s': section %s not found",
2066		      obj_path, BTF_EXT_ELF_SEC);
2067		err = -EINVAL;
2068		goto out;
2069	}
2070
2071	if (btf_ext->core_relo_info.len == 0) {
2072		err = 0;
2073		goto out;
2074	}
2075
2076	cand_cache = hashmap__new(btfgen_hash_fn, btfgen_equal_fn, NULL);
2077	if (IS_ERR(cand_cache)) {
2078		err = PTR_ERR(cand_cache);
2079		goto out;
2080	}
2081
2082	seg = &btf_ext->core_relo_info;
2083	for_each_btf_ext_sec(seg, sec) {
2084		for_each_btf_ext_rec(seg, sec, relo_idx, relo) {
2085			struct bpf_core_spec specs_scratch[3] = {};
2086			struct bpf_core_relo_res targ_res = {};
2087			struct bpf_core_cand_list *cands = NULL;
2088			const char *sec_name = btf__name_by_offset(btf, sec->sec_name_off);
2089
2090			if (relo->kind != BPF_CORE_TYPE_ID_LOCAL &&
2091			    !hashmap__find(cand_cache, relo->type_id, &cands)) {
2092				cands = btfgen_find_cands(btf, info->src_btf, relo->type_id);
2093				if (!cands) {
2094					err = -errno;
2095					goto out;
2096				}
2097
2098				err = hashmap__set(cand_cache, relo->type_id, cands,
2099						   NULL, NULL);
2100				if (err)
2101					goto out;
2102			}
2103
2104			err = bpf_core_calc_relo_insn(sec_name, relo, relo_idx, btf, cands,
2105						      specs_scratch, &targ_res);
2106			if (err)
2107				goto out;
2108
2109			/* specs_scratch[2] is the target spec */
2110			err = btfgen_record_reloc(info, &specs_scratch[2]);
2111			if (err)
2112				goto out;
2113		}
2114	}
2115
2116out:
2117	btf__free(btf);
2118	btf_ext__free(btf_ext);
2119
2120	if (!IS_ERR_OR_NULL(cand_cache)) {
2121		hashmap__for_each_entry(cand_cache, entry, i) {
2122			bpf_core_free_cands(entry->pvalue);
2123		}
2124		hashmap__free(cand_cache);
2125	}
2126
2127	return err;
2128}
2129
2130static int btfgen_remap_id(__u32 *type_id, void *ctx)
2131{
2132	unsigned int *ids = ctx;
2133
2134	*type_id = ids[*type_id];
2135
2136	return 0;
2137}
2138
2139/* Generate BTF from relocation information previously recorded */
2140static struct btf *btfgen_get_btf(struct btfgen_info *info)
2141{
2142	struct btf *btf_new = NULL;
2143	unsigned int *ids = NULL;
2144	unsigned int i, n = btf__type_cnt(info->marked_btf);
2145	int err = 0;
2146
2147	btf_new = btf__new_empty();
2148	if (!btf_new) {
2149		err = -errno;
2150		goto err_out;
2151	}
2152
2153	ids = calloc(n, sizeof(*ids));
2154	if (!ids) {
2155		err = -errno;
2156		goto err_out;
2157	}
2158
2159	/* first pass: add all marked types to btf_new and add their new ids to the ids map */
2160	for (i = 1; i < n; i++) {
2161		const struct btf_type *cloned_type, *type;
2162		const char *name;
2163		int new_id;
2164
2165		cloned_type = btf__type_by_id(info->marked_btf, i);
2166
2167		if (cloned_type->name_off != MARKED)
2168			continue;
2169
2170		type = btf__type_by_id(info->src_btf, i);
2171
2172		/* add members for struct and union */
2173		if (btf_is_composite(type)) {
2174			struct btf_member *cloned_m, *m;
2175			unsigned short vlen;
2176			int idx_src;
2177
2178			name = btf__str_by_offset(info->src_btf, type->name_off);
2179
2180			if (btf_is_struct(type))
2181				err = btf__add_struct(btf_new, name, type->size);
2182			else
2183				err = btf__add_union(btf_new, name, type->size);
2184
2185			if (err < 0)
2186				goto err_out;
2187			new_id = err;
2188
2189			cloned_m = btf_members(cloned_type);
2190			m = btf_members(type);
2191			vlen = btf_vlen(cloned_type);
2192			for (idx_src = 0; idx_src < vlen; idx_src++, cloned_m++, m++) {
2193				/* add only members that are marked as used */
2194				if (cloned_m->name_off != MARKED)
2195					continue;
2196
2197				name = btf__str_by_offset(info->src_btf, m->name_off);
2198				err = btf__add_field(btf_new, name, m->type,
2199						     btf_member_bit_offset(cloned_type, idx_src),
2200						     btf_member_bitfield_size(cloned_type, idx_src));
2201				if (err < 0)
2202					goto err_out;
2203			}
2204		} else {
2205			err = btf__add_type(btf_new, info->src_btf, type);
2206			if (err < 0)
2207				goto err_out;
2208			new_id = err;
2209		}
2210
2211		/* add ID mapping */
2212		ids[i] = new_id;
2213	}
2214
2215	/* second pass: fix up type ids */
2216	for (i = 1; i < btf__type_cnt(btf_new); i++) {
2217		struct btf_type *btf_type = (struct btf_type *) btf__type_by_id(btf_new, i);
2218
2219		err = btf_type_visit_type_ids(btf_type, btfgen_remap_id, ids);
2220		if (err)
2221			goto err_out;
2222	}
2223
2224	free(ids);
2225	return btf_new;
2226
2227err_out:
2228	btf__free(btf_new);
2229	free(ids);
2230	errno = -err;
2231	return NULL;
2232}
2233
2234/* Create minimized BTF file for a set of BPF objects.
2235 *
2236 * The BTFGen algorithm is divided in two main parts: (1) collect the
2237 * BTF types that are involved in relocations and (2) generate the BTF
2238 * object using the collected types.
2239 *
2240 * In order to collect the types involved in the relocations, we parse
2241 * the BTF and BTF.ext sections of the BPF objects and use
2242 * bpf_core_calc_relo_insn() to get the target specification, this
2243 * indicates how the types and fields are used in a relocation.
2244 *
2245 * Types are recorded in different ways according to the kind of the
2246 * relocation. For field-based relocations only the members that are
2247 * actually used are saved in order to reduce the size of the generated
2248 * BTF file. For type-based relocations empty struct / unions are
2249 * generated and for enum-based relocations the whole type is saved.
2250 *
2251 * The second part of the algorithm generates the BTF object. It creates
2252 * an empty BTF object and fills it with the types recorded in the
2253 * previous step. This function takes care of only adding the structure
2254 * and union members that were marked as used and it also fixes up the
2255 * type IDs on the generated BTF object.
2256 */
2257static int minimize_btf(const char *src_btf, const char *dst_btf, const char *objspaths[])
2258{
2259	struct btfgen_info *info;
2260	struct btf *btf_new = NULL;
2261	int err, i;
2262
2263	info = btfgen_new_info(src_btf);
2264	if (!info) {
2265		err = -errno;
2266		p_err("failed to allocate info structure: %s", strerror(errno));
2267		goto out;
2268	}
2269
2270	for (i = 0; objspaths[i] != NULL; i++) {
2271		err = btfgen_record_obj(info, objspaths[i]);
2272		if (err) {
2273			p_err("error recording relocations for %s: %s", objspaths[i],
2274			      strerror(errno));
2275			goto out;
2276		}
2277	}
2278
2279	btf_new = btfgen_get_btf(info);
2280	if (!btf_new) {
2281		err = -errno;
2282		p_err("error generating BTF: %s", strerror(errno));
2283		goto out;
2284	}
2285
2286	err = btf_save_raw(btf_new, dst_btf);
2287	if (err) {
2288		p_err("error saving btf file: %s", strerror(errno));
2289		goto out;
2290	}
2291
2292out:
2293	btf__free(btf_new);
2294	btfgen_free_info(info);
2295
2296	return err;
2297}
2298
2299static int do_min_core_btf(int argc, char **argv)
2300{
2301	const char *input, *output, **objs;
2302	int i, err;
2303
2304	if (!REQ_ARGS(3)) {
2305		usage();
2306		return -1;
2307	}
2308
2309	input = GET_ARG();
2310	output = GET_ARG();
2311
2312	objs = (const char **) calloc(argc + 1, sizeof(*objs));
2313	if (!objs) {
2314		p_err("failed to allocate array for object names");
2315		return -ENOMEM;
2316	}
2317
2318	i = 0;
2319	while (argc)
2320		objs[i++] = GET_ARG();
2321
2322	err = minimize_btf(input, output, objs);
2323	free(objs);
2324	return err;
2325}
2326
2327static const struct cmd cmds[] = {
2328	{ "object",		do_object },
2329	{ "skeleton",		do_skeleton },
2330	{ "subskeleton",	do_subskeleton },
2331	{ "min_core_btf",	do_min_core_btf},
2332	{ "help",		do_help },
2333	{ 0 }
2334};
2335
2336int do_gen(int argc, char **argv)
2337{
2338	return cmd_select(cmds, argc, argv, do_help);
2339}