/* bpf.c - core analysis suite

 *

 * Copyright (C) 2018 David Anderson

 * Copyright (C) 2018 Red Hat, Inc. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#include "defs.h"

struct bpf_info {

	ulong status;

	ulong progs, maps;

	struct list_pair *proglist;

	struct list_pair *maplist;

	char *bpf_prog_buf;

	char *bpf_prog_aux_buf;

	char *bpf_map_buf;

	char *bytecode_buf;

	int bpf_prog_type_size;

	int bpf_map_map_type_size;

	int idr_type;

#define IDR_ORIG   (1)

#define IDR_RADIX  (2)

#define IDR_XARRAY (3)

	char prog_hdr1[81];

	char map_hdr1[81];

} bpf_info = { 

	.status = UNINITIALIZED,

};

static void do_bpf(ulong, ulong, ulong, int);

static void bpf_init(struct bpf_info *);

static int bpf_type_size_init(void);

static char *bpf_prog_type_string(int, char *);

static char *bpf_map_map_type_string(int, char *);

static char *bpf_prog_used_maps(int, char *);

static char *bpf_prog_tag_string(char *, char *);

static void bpf_prog_gpl_compatible(char *, ulong);

static void dump_xlated_plain(void *, unsigned int, int);

static void print_boot_time(unsigned long long, char *, unsigned int);

static int do_old_idr(int, ulong, struct list_pair *);

#define IDR_ORIG_INIT   (1)

#define IDR_ORIG_COUNT  (2)

#define IDR_ORIG_GATHER (3)

#define PROG_ID        (0x1)

#define MAP_ID         (0x2)

#define DUMP_STRUCT    (0x4)

#define JITED          (0x8)

#define XLATED        (0x10)

#define OPCODES       (0x20)

#define PROG_VERBOSE  (0x40)

#define MAP_VERBOSE   (0x80)

void

cmd_bpf(void)

{

	int c, radix;

	ulong flags, prog_id, map_id;

	flags = prog_id = map_id = radix = 0;

	while ((c = getopt(argcnt, args, "PMtTjsxdm:p:")) != EOF) {

		switch(c)

		{

		case 'j':

			flags |= JITED;

			break;

		case 'T':

			flags |= (XLATED|OPCODES);

			break;

		case 't':

			flags |= XLATED;

			break;

		case 'm':

			map_id = stol(optarg, FAULT_ON_ERROR, NULL);

			flags |= MAP_ID;

			break;

		case 'p':	

			prog_id = stol(optarg, FAULT_ON_ERROR, NULL);

			flags |= PROG_ID;

			break;

		case 's':

			flags |= DUMP_STRUCT;

			break;

		case 'P':

			flags |= PROG_VERBOSE;

			break;

		case 'M':

			flags |= MAP_VERBOSE;

			break;

		case 'x':

			if (radix == 10)

				error(FATAL, "-d and -x are mutually exclusive\n");

			radix = 16;

			break;

		case 'd':

			if (radix == 16)

				error(FATAL, "-d and -x are mutually exclusive\n");

			radix = 16;

			break;

		default:

			argerrs++;

			break;

		}

	}

	if (argerrs)

		cmd_usage(pc->curcmd, SYNOPSIS);

	if ((flags & JITED) && !(flags & (PROG_ID|PROG_VERBOSE)))

		error(FATAL, "-j option only applicable with -p or -P\n");

	if ((flags & XLATED) && !(flags & (PROG_ID|PROG_VERBOSE)))

		error(FATAL, "-t option only applicable with -p or -P\n");

	if ((flags & DUMP_STRUCT) && !(flags & (PROG_ID|PROG_VERBOSE|MAP_ID|MAP_VERBOSE)))

		error(FATAL, "-s option requires either -p, -P, -m or -M\n");

	if (radix && !(flags & (PROG_ID|PROG_VERBOSE|MAP_ID|MAP_VERBOSE)))

		error(FATAL, "-%c option requires -s\n", radix == 10 ? 'd' : 'x');

	while (args[optind]) {

		error(FATAL, "invalid argument: %s\n", args[optind]);

		optind++;

	}

	do_bpf(flags, prog_id, map_id, radix);

}

static void

bpf_init(struct bpf_info *bpf)

{

	long len;

	char buf1[BUFSIZE];

	char buf2[BUFSIZE];

	char buf3[BUFSIZE];

	char buf4[BUFSIZE];

	switch (bpf->status)

	{

	case UNINITIALIZED:

		if (!kernel_symbol_exists("prog_idr") || 

		    !kernel_symbol_exists("map_idr")) {

			bpf->status = FALSE;

			command_not_supported();

		}

		STRUCT_SIZE_INIT(bpf_prog, "bpf_prog");

		STRUCT_SIZE_INIT(bpf_prog_aux, "bpf_prog_aux");

		STRUCT_SIZE_INIT(bpf_map, "bpf_map");

		STRUCT_SIZE_INIT(bpf_insn, "bpf_insn");

		MEMBER_OFFSET_INIT(bpf_prog_aux, "bpf_prog", "aux");

		MEMBER_OFFSET_INIT(bpf_prog_type, "bpf_prog", "type");

		MEMBER_OFFSET_INIT(bpf_prog_tag, "bpf_prog", "tag");

		MEMBER_OFFSET_INIT(bpf_prog_jited_len, "bpf_prog", "jited_len");

		MEMBER_OFFSET_INIT(bpf_prog_bpf_func, "bpf_prog", "bpf_func");

		MEMBER_OFFSET_INIT(bpf_prog_len, "bpf_prog", "len");

		MEMBER_OFFSET_INIT(bpf_prog_insnsi, "bpf_prog", "insnsi");

		MEMBER_OFFSET_INIT(bpf_map_map_type, "bpf_map", "map_type");

		MEMBER_OFFSET_INIT(bpf_map_map_flags, "bpf_map", "map_flags");

		MEMBER_OFFSET_INIT(bpf_prog_aux_used_maps, "bpf_prog_aux", "used_maps");

		MEMBER_OFFSET_INIT(bpf_prog_aux_used_map_cnt, "bpf_prog_aux", "used_map_cnt");

		if (!VALID_STRUCT(bpf_prog) || 

		    !VALID_STRUCT(bpf_prog_aux) ||

		    !VALID_STRUCT(bpf_map) ||

		    !VALID_STRUCT(bpf_insn) ||

		    INVALID_MEMBER(bpf_prog_aux) ||

		    INVALID_MEMBER(bpf_prog_type) ||

		    INVALID_MEMBER(bpf_prog_tag) ||

		    INVALID_MEMBER(bpf_prog_jited_len) ||

		    INVALID_MEMBER(bpf_prog_bpf_func) ||

		    INVALID_MEMBER(bpf_prog_len) ||

		    INVALID_MEMBER(bpf_prog_insnsi) ||

		    INVALID_MEMBER(bpf_map_map_flags) ||

		    INVALID_MEMBER(bpf_map_map_type) ||

		    INVALID_MEMBER(bpf_prog_aux_used_maps) ||

		    INVALID_MEMBER(bpf_prog_aux_used_map_cnt)) {

			bpf->status = FALSE;

			command_not_supported();

		}	

		/*

		 *  Not required for basic functionality

		 */

		MEMBER_OFFSET_INIT(bpf_prog_pages, "bpf_prog", "pages");

		MEMBER_OFFSET_INIT(bpf_prog_aux_load_time, "bpf_prog_aux", "load_time");

		MEMBER_OFFSET_INIT(bpf_prog_aux_user, "bpf_prog_aux", "user");

		MEMBER_OFFSET_INIT(bpf_map_key_size, "bpf_map", "key_size");

		MEMBER_OFFSET_INIT(bpf_map_value_size, "bpf_map", "value_size");

		MEMBER_OFFSET_INIT(bpf_map_max_entries, "bpf_map", "max_entries");

		MEMBER_OFFSET_INIT(bpf_map_pages, "bpf_map", "pages");

		MEMBER_OFFSET_INIT(bpf_map_name, "bpf_map", "name");

		MEMBER_OFFSET_INIT(bpf_map_user, "bpf_map", "user");

		MEMBER_OFFSET_INIT(user_struct_uid, "user_struct", "uid");

		if (!bpf_type_size_init()) {

			bpf->status = FALSE;

			command_not_supported();

		}

		sprintf(bpf->prog_hdr1, "%s %s %s %s ",

			mkstring(buf1, 4, CENTER|LJUST, "ID"),

			mkstring(buf2, VADDR_PRLEN, CENTER|LJUST, "BPF_PROG"),

			mkstring(buf3, VADDR_PRLEN, CENTER|LJUST, "BPF_PROG_AUX"),

			mkstring(buf4, bpf->bpf_prog_type_size, CENTER|LJUST, "BPF_PROG_TYPE"));

		strcat(bpf->prog_hdr1, "      TAG        USED_MAPS");

		sprintf(bpf->map_hdr1, "%s %s %s MAP_FLAGS",

			mkstring(buf1, 4, CENTER|LJUST, "ID"),

			mkstring(buf2, VADDR_PRLEN, CENTER|LJUST, "BPF_MAP"),

			mkstring(buf3, bpf->bpf_map_map_type_size, CENTER|LJUST, "BPF_MAP_TYPE"));

		if (INVALID_MEMBER(idr_idr_rt)) {

			bpf->idr_type = IDR_ORIG;

			do_old_idr(IDR_ORIG_INIT, 0, NULL);

		} else if (STREQ(MEMBER_TYPE_NAME("idr", "idr_rt"), "radix_tree_root"))

			if (MEMBER_EXISTS("radix_tree_root", "rnode"))

				bpf->idr_type = IDR_RADIX;

			else if (MEMBER_EXISTS("radix_tree_root", "xa_head"))

				bpf->idr_type = IDR_XARRAY;

			else

				error(FATAL, "cannot determine IDR list type\n");

		else if (STREQ(MEMBER_TYPE_NAME("idr", "idr_rt"), "xarray"))

			bpf->idr_type = IDR_XARRAY;

		else

			error(FATAL, "cannot determine IDR list type\n");

		bpf->status = TRUE;

		break;

	case TRUE:

		break;

	case FALSE:

		command_not_supported();

	}

	switch (bpf->idr_type)

	{

	case IDR_ORIG:

		bpf->progs = do_old_idr(IDR_ORIG_COUNT, symbol_value("prog_idr"), NULL);

		break;

	case IDR_RADIX:

		bpf->progs = do_radix_tree(symbol_value("prog_idr") + OFFSET(idr_idr_rt),

			RADIX_TREE_COUNT, NULL);

		break;

	case IDR_XARRAY:

		bpf->progs = do_xarray(symbol_value("prog_idr") + OFFSET(idr_idr_rt),

			XARRAY_COUNT, NULL);

		break;

	}

	if (bpf->progs) {

		len = sizeof(struct list_pair) * (bpf->progs+1);

		bpf->proglist = (struct list_pair *)GETBUF(len);

		bpf->proglist[0].index = bpf->progs;

		switch (bpf->idr_type)

		{

		case IDR_ORIG:

			bpf->progs = do_old_idr(IDR_ORIG_GATHER, symbol_value("prog_idr"), bpf->proglist);

			break;

		case IDR_RADIX:

			bpf->progs = do_radix_tree(symbol_value("prog_idr") + OFFSET(idr_idr_rt),

				RADIX_TREE_GATHER, bpf->proglist);

			break;

		case IDR_XARRAY:

			bpf->progs = do_xarray(symbol_value("prog_idr") + OFFSET(idr_idr_rt),

				XARRAY_GATHER, bpf->proglist);

			break;

		}

	}

	switch (bpf->idr_type)

	{

	case IDR_ORIG:

		bpf->maps = do_old_idr(IDR_ORIG_COUNT, symbol_value("map_idr"), NULL);

		break;

	case IDR_RADIX:

		bpf->maps = do_radix_tree(symbol_value("map_idr") + OFFSET(idr_idr_rt), 

			RADIX_TREE_COUNT, NULL);

		break;

	case IDR_XARRAY:

		bpf->maps = do_xarray(symbol_value("map_idr") + OFFSET(idr_idr_rt), 

			XARRAY_COUNT, NULL);

		break;

	}

	if (bpf->maps) {

		len = sizeof(struct list_pair) * (bpf->maps+1);

		bpf->maplist = (struct list_pair *)GETBUF(len);

		bpf->maplist[0].index = bpf->maps;

		switch (bpf->idr_type)

		{

		case IDR_ORIG:

			bpf->maps = do_old_idr(IDR_ORIG_GATHER, symbol_value("map_idr"), bpf->maplist);

			break;

		case IDR_RADIX:

			bpf->maps = do_radix_tree(symbol_value("map_idr") + OFFSET(idr_idr_rt),

				RADIX_TREE_GATHER, bpf->maplist);

			break;

		case IDR_XARRAY:

			bpf->maps = do_xarray(symbol_value("map_idr") + OFFSET(idr_idr_rt),

				XARRAY_GATHER, bpf->maplist);

			break;

		}

	}

	bpf->bpf_prog_buf = GETBUF(SIZE(bpf_prog));

	bpf->bpf_prog_aux_buf = GETBUF(SIZE(bpf_prog_aux));

	bpf->bpf_map_buf = GETBUF(SIZE(bpf_map));

}

static void

do_bpf(ulong flags, ulong prog_id, ulong map_id, int radix)

{

	struct bpf_info *bpf;

	int i, c, found, entries, type;

	uint uid, map_pages, key_size, value_size, max_entries;

	ulong bpf_prog_aux, bpf_func, end_func, addr, insnsi, user;

	ulong do_progs, do_maps;

	ulonglong load_time;

	char *symbol;

	ushort prog_pages;

	int jited_len, len;

	char *arglist[MAXARGS];

	char buf1[BUFSIZE];

	char buf2[BUFSIZE];

	char buf3[BUFSIZE];

	char buf4[BUFSIZE];

	char buf5[BUFSIZE/2];

	bpf = &bpf_info;

	bpf->proglist = NULL;

	bpf->maplist = NULL;

	bpf->bpf_prog_buf = bpf->bpf_prog_aux_buf = bpf->bpf_map_buf = NULL;

	bpf->bytecode_buf = NULL;

	bpf_init(bpf);

	if (flags & PROG_ID) {

		for (i = found = 0; i < bpf->progs; i++) {

			if (prog_id == bpf->proglist[i].index) {

				found++;

				break;

			}

		}

		if (!found) {

			error(INFO, "invalid program ID: %ld\n", prog_id);

			goto bailout;

		}

	}

	if (flags & MAP_ID) {

		for (i = found = 0; i < bpf->maps; i++) {

			if (map_id == bpf->maplist[i].index) {

				found++;

				break;

			}

		}

		if (!found) {

			error(INFO, "invalid map ID: %ld\n", map_id);

			goto bailout;

		}

	}

	if (!(flags & (PROG_ID|PROG_VERBOSE|MAP_ID|MAP_VERBOSE)))

		do_progs = do_maps = TRUE;

	else {

		do_progs = do_maps = FALSE;

		if (flags & (PROG_ID|PROG_VERBOSE))

			do_progs = TRUE;

		if (flags & (MAP_ID|MAP_VERBOSE))

			do_maps = TRUE;

	}

	if (!do_progs)

		goto do_map_only;

	for (i = entries = 0; i < bpf->progs; i++) {

		if (bpf->proglist[i].value == 0) 

			continue;

		if (((flags & (PROG_ID|PROG_VERBOSE)) == PROG_ID) && 

		    (prog_id != bpf->proglist[i].index)) 

			continue;

		if (!readmem((ulong)bpf->proglist[i].value, KVADDR, bpf->bpf_prog_buf, 

		    SIZE(bpf_prog), "struct bpf_prog", RETURN_ON_ERROR))

			goto bailout;

		bpf_prog_aux = ULONG(bpf->bpf_prog_buf + OFFSET(bpf_prog_aux));

		if (!readmem(bpf_prog_aux, KVADDR, bpf->bpf_prog_aux_buf, 

		    SIZE(bpf_prog_aux), "struct bpf_prog_aux", RETURN_ON_ERROR))

			goto bailout;

		if (entries && (flags & PROG_VERBOSE))

			fprintf(fp, "\n%s\n", bpf->prog_hdr1);

		if (entries++ == 0)

			fprintf(fp, "%s\n", bpf->prog_hdr1);

		fprintf(fp, "%s %s %s ", 

			mkstring(buf1, 4, CENTER|LJUST|LONG_DEC, MKSTR(bpf->proglist[i].index)),

			mkstring(buf2, VADDR_PRLEN, CENTER|LJUST|LONG_HEX, MKSTR(bpf->proglist[i].value)),

			mkstring(buf3, VADDR_PRLEN, CENTER|LJUST|LONG_HEX, MKSTR(bpf_prog_aux)));

		type = INT(bpf->bpf_prog_buf + OFFSET(bpf_prog_type));

		fprintf(fp, "%s ", 

			mkstring(buf1, bpf->bpf_prog_type_size, CENTER|LJUST, bpf_prog_type_string(type, buf2)));

		fprintf(fp, "%s ", bpf_prog_tag_string(bpf->bpf_prog_buf + OFFSET(bpf_prog_tag), buf1));

		fprintf(fp, "%s ", 

			mkstring(buf1, strlen("USED_MAPS"), CENTER|LJUST, bpf_prog_used_maps(i, buf2)));

		fprintf(fp, "\n");

		if (flags & (PROG_ID|PROG_VERBOSE)) {

			jited_len = UINT(bpf->bpf_prog_buf + OFFSET(bpf_prog_jited_len));

			len = UINT(bpf->bpf_prog_buf + OFFSET(bpf_prog_len));

			len *= SIZE(bpf_insn);

			if (VALID_MEMBER(bpf_prog_pages)) {

				prog_pages = USHORT(bpf->bpf_prog_buf + OFFSET(bpf_prog_pages));

				prog_pages *= PAGESIZE();

			} else

				prog_pages = 0;

			fprintf(fp, "     XLATED: %d  JITED: %d  MEMLOCK: ", len, jited_len);

			if (VALID_MEMBER(bpf_prog_pages)) {

				fprintf(fp, "%d\n", prog_pages);

			} else

				fprintf(fp, "(unknown)\n");

			fprintf(fp, "     LOAD_TIME: ");

			if (VALID_MEMBER(bpf_prog_aux_load_time)) {

				load_time = ULONGLONG(bpf->bpf_prog_aux_buf + OFFSET(bpf_prog_aux_load_time));

				print_boot_time(load_time, buf5, BUFSIZE/2);

				fprintf(fp, "%s\n", buf5);

			} else

				fprintf(fp, "(unknown)\n");

			bpf_prog_gpl_compatible(buf1, (ulong)bpf->proglist[i].value);

			fprintf(fp, "     GPL_COMPATIBLE: %s", buf1);

			fprintf(fp, "  UID: ");

			if (VALID_MEMBER(bpf_prog_aux_user) && VALID_MEMBER(user_struct_uid)) {

				user = ULONG(bpf->bpf_prog_aux_buf + OFFSET(bpf_prog_aux_user));

				if (readmem(user + OFFSET(user_struct_uid), KVADDR, &uid, sizeof(uint), 

				    "user_struct.uid", QUIET|RETURN_ON_ERROR))

					fprintf(fp, "%d\n", uid);

				else

					fprintf(fp, "(unknown)\n");

			} else

				fprintf(fp, "(unknown)\n");

		}

		if (flags & JITED) {

			fprintf(fp, "\n");

			jited_len = UINT(bpf->bpf_prog_buf + OFFSET(bpf_prog_jited_len));

			bpf_func = ULONG(bpf->bpf_prog_buf + OFFSET(bpf_prog_bpf_func));

			end_func = bpf_func + jited_len;

			if (jited_len) {

				open_tmpfile();

				pc->curcmd_private = (ulonglong)end_func;

				sprintf(buf1, "x/%di 0x%lx", jited_len, bpf_func);

				gdb_pass_through(buf1, NULL, GNU_RETURN_ON_ERROR);

				rewind(pc->tmpfile);

				while (fgets(buf1, BUFSIZE, pc->tmpfile)) {

					strcpy(buf2, strip_linefeeds(buf1));

					c = parse_line(buf1, arglist);

					if (STRNEQ(arglist[0], "0x") && 

					    (LASTCHAR(arglist[0]) == ':')) {

						addr = htol(strip_ending_char(arglist[0], ':'), 

							RETURN_ON_ERROR, NULL);

						if (addr >= end_func)

							break;

					}

					symbol = NULL;

					if ((c > 1) && IS_A_NUMBER(arglist[c-1])) {

						addr = htol(arglist[c-1], RETURN_ON_ERROR, NULL);

						symbol = value_to_symstr(addr, buf3, radix); 

						if (strlen(symbol)) {

							sprintf(buf4, "<%s>", symbol);

							symbol = buf4;

						}

					}

					fprintf(pc->saved_fp, "%s %s\n", buf2, symbol ? symbol : "");

				}

				pc->curcmd_private = 0;

				close_tmpfile();

			} else

				fprintf(fp, "(program not jited)\n");

		}

		if (flags & XLATED) {

			fprintf(fp, "\n");

			len = UINT(bpf->bpf_prog_buf + OFFSET(bpf_prog_len));

			insnsi = (ulong)bpf->proglist[i].value + OFFSET(bpf_prog_insnsi);

			bpf->bytecode_buf = GETBUF(len * SIZE(bpf_insn));

			if (CRASHDEBUG(1))

				fprintf(fp, "bytecode_buf: [%lx] len %d * size %ld = %ld  from: %lx\n", 

					(ulong)bpf->bytecode_buf,

					len, SIZE(bpf_insn), len * SIZE(bpf_insn), insnsi);

			if (!readmem(insnsi, KVADDR, bpf->bytecode_buf, len * SIZE(bpf_insn), 

			    "bpf_prog.insnsi contents", RETURN_ON_ERROR))

				goto bailout;

			dump_xlated_plain((void *)bpf->bytecode_buf, len * SIZE(bpf_insn), flags & OPCODES);

		}

		if (flags & DUMP_STRUCT) {

			fprintf(fp, "\n");

			dump_struct("bpf_prog", (ulong)bpf->proglist[i].value, radix);

			fprintf(fp, "\n");

			dump_struct("bpf_prog_aux", bpf_prog_aux, radix);

		}

	}

	if (!do_maps)

		goto bailout;

	else

		fprintf(fp, "\n");

do_map_only:

	for (i = entries = 0; i < bpf->maps; i++) {

		if (bpf->maplist[i].value == 0) 

			continue;

		if (((flags & (MAP_ID|MAP_VERBOSE)) == MAP_ID) && 

		    (map_id != bpf->maplist[i].index))

			continue;

		if (entries && (flags & MAP_VERBOSE))

			fprintf(fp, "\n%s\n", bpf->map_hdr1);

		if (entries++ == 0)

			fprintf(fp, "%s\n", bpf->map_hdr1);

		if (!readmem((ulong)bpf->maplist[i].value, KVADDR, bpf->bpf_map_buf, 

		    SIZE(bpf_map), "struct bpf_map", RETURN_ON_ERROR))

			goto bailout;

		fprintf(fp, "%s %s ", 

			mkstring(buf1, 4, CENTER|LJUST|LONG_DEC, MKSTR(bpf->maplist[i].index)),

			mkstring(buf2, VADDR_PRLEN, CENTER|LJUST|LONG_HEX, MKSTR(bpf->maplist[i].value)));

		type = INT(bpf->bpf_map_buf + OFFSET(bpf_map_map_type));

		fprintf(fp, "%s ", 

			mkstring(buf1, bpf->bpf_map_map_type_size, CENTER|LJUST, bpf_map_map_type_string(type, buf2)));

		fprintf(fp, " %08x ", UINT(bpf->bpf_map_buf + OFFSET(bpf_map_map_flags)));

		fprintf(fp, "\n");

		if (flags & (MAP_ID|MAP_VERBOSE)) {

			fprintf(fp, "     KEY_SIZE: ");

			if (VALID_MEMBER(bpf_map_key_size)) {

				key_size = UINT(bpf->bpf_map_buf + OFFSET(bpf_map_key_size));

				fprintf(fp, "%d", key_size);

			} else

				fprintf(fp, "(unknown)");

			fprintf(fp, "  VALUE_SIZE: ");

			if (VALID_MEMBER(bpf_map_value_size)) {

				value_size = UINT(bpf->bpf_map_buf + OFFSET(bpf_map_value_size));

				fprintf(fp, "%d", value_size);

			} else

				fprintf(fp, "(unknown)");

			fprintf(fp, "  MAX_ENTRIES: ");

			if (VALID_MEMBER(bpf_map_max_entries)) {

				max_entries = UINT(bpf->bpf_map_buf + OFFSET(bpf_map_max_entries));

				fprintf(fp, "%d", max_entries);

			} else

				fprintf(fp, "(unknown)");

			fprintf(fp, "  MEMLOCK: ");

			if (VALID_MEMBER(bpf_map_pages)) {

				map_pages = UINT(bpf->bpf_map_buf + OFFSET(bpf_map_pages));

				fprintf(fp, "%d\n", map_pages * PAGESIZE());

			} else

				fprintf(fp, "(unknown)\n");

			fprintf(fp, "     NAME: ");

			if (VALID_MEMBER(bpf_map_name)) {

				BCOPY(&bpf->bpf_map_buf[OFFSET(bpf_map_name)], buf1, 16);

				buf1[17] = NULLCHAR;

				if (strlen(buf1))

					fprintf(fp, "\"%s\"", buf1);

				else

					fprintf(fp, "(unused)");

			} else

				fprintf(fp, "(unknown)\n");

			fprintf(fp, "  UID: ");

			if (VALID_MEMBER(bpf_map_user) && VALID_MEMBER(user_struct_uid)) {

				user = ULONG(bpf->bpf_map_buf + OFFSET(bpf_map_user));

				if (readmem(user + OFFSET(user_struct_uid), KVADDR, &uid, sizeof(uint), 

				    "user_struct.uid", QUIET|RETURN_ON_ERROR))

					fprintf(fp, "%d\n", uid);

				else

					fprintf(fp, "(unknown)\n");

			} else

				fprintf(fp, "(unknown)\n");

		}

		if (flags & DUMP_STRUCT) {

			fprintf(fp, "\n");

			dump_struct("bpf_map", (ulong)bpf->maplist[i].value, radix);

		}

	}

bailout:

	if (bpf->proglist)

		FREEBUF(bpf->proglist);

	if (bpf->maplist)

		FREEBUF(bpf->maplist);

	FREEBUF(bpf->bpf_prog_buf);

	FREEBUF(bpf->bpf_prog_aux_buf);

	FREEBUF(bpf->bpf_map_buf);

	if (bpf->bytecode_buf)

		FREEBUF(bpf->bytecode_buf);

}

static int 

bpf_type_size_init(void)

{

	int c ATTRIBUTE_UNUSED; 

	size_t max;

	char *arglist[MAXARGS];

	char buf[BUFSIZE];

	struct bpf_info *bpf = &bpf_info;

	open_tmpfile();

	if (dump_enumerator_list("bpf_prog_type")) {

		max = 0;

		rewind(pc->tmpfile);

		while (fgets(buf, BUFSIZE, pc->tmpfile)) {

			if (!strstr(buf, " = "))

				continue;

			c = parse_line(buf, arglist);

			if (CRASHDEBUG(1))

				fprintf(pc->saved_fp, "%s\n", arglist[0]);

			max = MAX(max, strlen(arglist[0]));

		}

		bpf->bpf_prog_type_size = max - strlen("BPF_PROG_TYPE_");

	} else {

		close_tmpfile();

		return FALSE;

	}

	/*

	 * Keep bpf program header at 80 columns

	 */

	bpf->bpf_prog_type_size = MIN(13, bpf->bpf_prog_type_size);

	close_tmpfile();

	open_tmpfile();

	if (dump_enumerator_list("bpf_map_type")) {

		max = 0;

		rewind(pc->tmpfile);

		while (fgets(buf, BUFSIZE, pc->tmpfile)) {

			if (!strstr(buf, " = "))

				continue;

			c = parse_line(buf, arglist);

			if (CRASHDEBUG(1))

				fprintf(pc->saved_fp, "%s\n", arglist[0]);

			max = MAX(max, strlen(arglist[0]));

		}

		bpf->bpf_map_map_type_size = max - strlen("BPF_PROG_TYPE_");

	} else {

		close_tmpfile();

		return FALSE;

	}

	close_tmpfile();

	return TRUE;

}

static char *

bpf_prog_type_string(int type, char *retbuf)

{

	char *p;	

	int c ATTRIBUTE_UNUSED; 

	char *arglist[MAXARGS];

	char buf[BUFSIZE];

	retbuf[0] = NULLCHAR;

	open_tmpfile();

	if (dump_enumerator_list("bpf_prog_type")) {

		rewind(pc->tmpfile);

		while (fgets(buf, BUFSIZE, pc->tmpfile)) {

			if (!strstr(buf, " = "))

				continue;

			c = parse_line(buf, arglist);

			if (atoi(arglist[2]) == type) {

				p = arglist[0];

				p += strlen("BPF_PROG_TYPE_");

				strcpy(retbuf, p);

				break;

			}

		}

	} 

	close_tmpfile();

	return retbuf;

}

static char *

bpf_map_map_type_string(int map_type, char *retbuf)

{

	char *p;	

	int c ATTRIBUTE_UNUSED; 

	char *arglist[MAXARGS];

	char buf[BUFSIZE];

	retbuf[0] = NULLCHAR;

	open_tmpfile();

	if (dump_enumerator_list("bpf_map_type")) {

		rewind(pc->tmpfile);

		while (fgets(buf, BUFSIZE, pc->tmpfile)) {

			if (!strstr(buf, " = "))

				continue;

			c = parse_line(buf, arglist);

			if (atoi(arglist[2]) == map_type) {

				p = arglist[0];

				p += strlen("BPF_MAP_TYPE_");

				strcpy(retbuf, p);

				break;

			}

		}

	} 

	close_tmpfile();

	return retbuf;

}

static char *

bpf_prog_used_maps(int idx, char *retbuf)

{

	int i, m, cnt;

	struct bpf_info *bpf = &bpf_info;

	uint used_map_cnt;

	ulong used_maps, map;

	retbuf[0] = NULLCHAR;

	used_map_cnt = UINT(bpf->bpf_prog_aux_buf + OFFSET(bpf_prog_aux_used_map_cnt));

	used_maps = ULONG(bpf->bpf_prog_aux_buf + OFFSET(bpf_prog_aux_used_maps));

	for (i = cnt = 0; i < used_map_cnt; i++) {

		if (!readmem(used_maps + (sizeof(ulong)*i), KVADDR, &map,

		    sizeof(ulong), "bpf_prog_aux.used_maps", RETURN_ON_ERROR))

			return retbuf;

		for (m = 0; m < bpf->maps; m++) {

			if (map == (ulong)bpf->maplist[m].value) {

				sprintf(&retbuf[strlen(retbuf)], "%s%ld", 

					strlen(retbuf) ? "," : "",

					bpf->maplist[m].index);

			}

		}

	}

	return retbuf;

}

static char *

bpf_prog_tag_string(char *tag, char *buf)

{

	int i;

	buf[0] = NULLCHAR;

	for (i = 0; i < 8; i++)

		sprintf(&buf[strlen(buf)], "%02x", (unsigned char)tag[i]);

	return buf;

}

static void

bpf_prog_gpl_compatible(char *retbuf, ulong bpf_prog)

{

	char buf[BUFSIZE];

	sprintf(retbuf, "(unknown)");

	open_tmpfile();

        sprintf(buf, "p (*(struct bpf_prog *)0x%lx).gpl_compatible", bpf_prog);

	gdb_pass_through(buf, NULL, GNU_RETURN_ON_ERROR);

	rewind(pc->tmpfile);

	while (fgets(buf, BUFSIZE, pc->tmpfile)) {

		if (strstr(buf, " = 1")) {

			sprintf(retbuf, "yes");

			break;

		} else if (strstr(buf, " = 0")) {

			sprintf(retbuf, "no");

			break;

		}

	}

	close_tmpfile();

}

// #include <linux/bpf_common.h>

/*

 *  Taken from: "/usr/include/linux/bpf_common.h"

 */

/*

 *  bpf_common.h

 */

/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */

#ifndef __LINUX_BPF_COMMON_H__

#define __LINUX_BPF_COMMON_H__

/* Instruction classes */

#define BPF_CLASS(code) ((code) & 0x07)

#define		BPF_LD		0x00

#define		BPF_LDX		0x01

#define		BPF_ST		0x02

#define		BPF_STX		0x03

#define		BPF_ALU		0x04

#define		BPF_JMP		0x05

#define		BPF_RET		0x06

#define		BPF_MISC        0x07

/* ld/ldx fields */

#define BPF_SIZE(code)  ((code) & 0x18)

#define		BPF_W		0x00 /* 32-bit */

#define		BPF_H		0x08 /* 16-bit */

#define		BPF_B		0x10 /*  8-bit */

/* eBPF		BPF_DW		0x18    64-bit */

#define BPF_MODE(code)  ((code) & 0xe0)

#define		BPF_IMM		0x00

#define		BPF_ABS		0x20

#define		BPF_IND		0x40

#define		BPF_MEM		0x60

#define		BPF_LEN		0x80

#define		BPF_MSH		0xa0

/* alu/jmp fields */

#define BPF_OP(code)    ((code) & 0xf0)

#define		BPF_ADD		0x00

#define		BPF_SUB		0x10

#define		BPF_MUL		0x20

#define		BPF_DIV		0x30

#define		BPF_OR		0x40

#define		BPF_AND		0x50

#define		BPF_LSH		0x60

#define		BPF_RSH		0x70

#define		BPF_NEG		0x80

#define		BPF_MOD		0x90

#define		BPF_XOR		0xa0

#define		BPF_JA		0x00

#define		BPF_JEQ		0x10

#define		BPF_JGT		0x20

#define		BPF_JGE		0x30

#define		BPF_JSET        0x40

#define BPF_SRC(code)   ((code) & 0x08)

#define		BPF_K		0x00

#define		BPF_X		0x08

#ifndef BPF_MAXINSNS

#define BPF_MAXINSNS 4096

#endif

#endif /* __LINUX_BPF_COMMON_H__ */

/*

 *  Taken from: /usr/include/asm-generic/int-ll64.h

 */

typedef unsigned char __u8;

typedef __signed__ short __s16;

typedef __signed__ int __s32;