HardenedBSD/sys/ddb/db_pprint.c

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2022 Bojan Novković <bnovkov@freebsd.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/ctype.h>
#include <sys/linker.h>

#include <machine/stdarg.h>

#include <ddb/ddb.h>
#include <ddb/db_ctf.h>
#include <ddb/db_lex.h>
#include <ddb/db_sym.h>
#include <ddb/db_access.h>

#define DB_PPRINT_DEFAULT_DEPTH 1

static void db_pprint_type(db_addr_t addr, struct ctf_type_v3 *type,
    u_int depth);

static u_int max_depth = DB_PPRINT_DEFAULT_DEPTH;
static struct db_ctf_sym_data sym_data;
static const char *asteriskstr = "*****";

/*
 * Pretty-prints a CTF_INT type.
 */
static inline void
db_pprint_int(db_addr_t addr, struct ctf_type_v3 *type, u_int depth)
{
	uint32_t data;
	size_t type_struct_size;

	type_struct_size = (type->ctt_size == CTF_V3_LSIZE_SENT) ?
		sizeof(struct ctf_type_v3) :
		sizeof(struct ctf_stype_v3);

	data = db_get_value((db_expr_t)type + type_struct_size,
		sizeof(uint32_t), 0);
	u_int bits = CTF_INT_BITS(data);
	boolean_t sign = !!(CTF_INT_ENCODING(data) & CTF_INT_SIGNED);

	if (db_pager_quit) {
		return;
	}
	if (bits > 64) {
		db_printf("Invalid size '%d' found for integer type\n", bits);
		return;
	}
	db_printf("0x%lx",
	    (long)db_get_value(addr, (bits / 8) ? (bits / 8) : 1, sign));
}

/*
 * Pretty-prints a struct. Nested structs are pretty-printed up 'depth' nested
 * levels.
 */
static inline void
db_pprint_struct(db_addr_t addr, struct ctf_type_v3 *type, u_int depth)
{
	size_t type_struct_size;
	size_t struct_size;
	struct ctf_type_v3 *mtype;
	const char *mname;
	db_addr_t maddr;
	u_int vlen;

	type_struct_size = (type->ctt_size == CTF_V3_LSIZE_SENT) ?
		sizeof(struct ctf_type_v3) :
		sizeof(struct ctf_stype_v3);
	struct_size = ((type->ctt_size == CTF_V3_LSIZE_SENT) ?
		CTF_TYPE_LSIZE(type) :
		type->ctt_size);
	vlen = CTF_V3_INFO_VLEN(type->ctt_info);

	if (db_pager_quit) {
		return;
	}
	if (depth > max_depth) {
		db_printf("{ ... }");
		return;
	}
	db_printf("{\n");

	if (struct_size < CTF_V3_LSTRUCT_THRESH) {
		struct ctf_member_v3 *mp, *endp;

		mp = (struct ctf_member_v3 *)((db_addr_t)type +
		    type_struct_size);
		endp = mp + vlen;
		for (; mp < endp; mp++) {
			if (db_pager_quit) {
				return;
			}
			mtype = db_ctf_typeid_to_type(&sym_data, mp->ctm_type);
			maddr = addr + (mp->ctm_offset / NBBY);
			mname = db_ctf_stroff_to_str(&sym_data, mp->ctm_name);
			db_indent = depth;
			if (mname != NULL) {
				db_iprintf("%s = ", mname);
			} else {
				db_iprintf("");
			}

			db_pprint_type(maddr, mtype, depth + 1);
			db_printf(",\n");
		}
	} else {
		struct ctf_lmember_v3 *mp, *endp;

		mp = (struct ctf_lmember_v3 *)((db_addr_t)type +
		    type_struct_size);
		endp = mp + vlen;
		for (; mp < endp; mp++) {
			if (db_pager_quit) {
				return;
			}
			mtype = db_ctf_typeid_to_type(&sym_data, mp->ctlm_type);
			maddr = addr + (CTF_LMEM_OFFSET(mp) / NBBY);
			mname = db_ctf_stroff_to_str(&sym_data, mp->ctlm_name);
			db_indent = depth;
			if (mname != NULL) {
				db_iprintf("%s = ", mname);
			} else {
				db_iprintf("");
			}

			db_pprint_type(maddr, mtype, depth + 1);
			db_printf(",");
		}
	}
	db_indent = depth - 1;
	db_iprintf("}");
}

/*
 * Pretty-prints an array. Each array member is printed out in a separate line
 * indented with 'depth' spaces.
 */
static inline void
db_pprint_arr(db_addr_t addr, struct ctf_type_v3 *type, u_int depth)
{
	struct ctf_type_v3 *elem_type;
	struct ctf_array_v3 *arr;
	db_addr_t elem_addr, end;
	size_t type_struct_size;
	size_t elem_size;

	type_struct_size = (type->ctt_size == CTF_V3_LSIZE_SENT) ?
		sizeof(struct ctf_type_v3) :
		sizeof(struct ctf_stype_v3);
	arr = (struct ctf_array_v3 *)((db_addr_t)type + type_struct_size);
	elem_type = db_ctf_typeid_to_type(&sym_data, arr->cta_contents);
	elem_size = ((elem_type->ctt_size == CTF_V3_LSIZE_SENT) ?
		CTF_TYPE_LSIZE(elem_type) :
		elem_type->ctt_size);
	elem_addr = addr;
	end = addr + (arr->cta_nelems * elem_size);

	db_indent = depth;
	db_printf("[\n");
	/* Loop through and print individual elements. */
	for (; elem_addr < end; elem_addr += elem_size) {
		if (db_pager_quit) {
			return;
		}
		db_iprintf("");
		db_pprint_type(elem_addr, elem_type, depth);
		if ((elem_addr + elem_size) < end) {
			db_printf(",\n");
		}
	}
	db_printf("\n");
	db_indent = depth - 1;
	db_iprintf("]");
}

/*
 * Pretty-prints an enum value. Also prints out symbolic name of value, if any.
 */
static inline void
db_pprint_enum(db_addr_t addr, struct ctf_type_v3 *type, u_int depth)
{
	struct ctf_enum *ep, *endp;
	size_t type_struct_size;
	const char *valname;
	db_expr_t val;
	u_int vlen;

	type_struct_size = (type->ctt_size == CTF_V3_LSIZE_SENT) ?
		sizeof(struct ctf_type_v3) :
		sizeof(struct ctf_stype_v3);
	vlen = CTF_V3_INFO_VLEN(type->ctt_info);
	val = db_get_value(addr, sizeof(int), 0);

	if (db_pager_quit) {
		return;
	}
	ep = (struct ctf_enum *)((db_addr_t)type + type_struct_size);
	endp = ep + vlen;
	for (; ep < endp; ep++) {
		if (val == ep->cte_value) {
			valname = db_ctf_stroff_to_str(&sym_data, ep->cte_name);
			if (valname != NULL) {
				db_printf("%s (0x%lx)", valname, (long)val);
				break;
			}
		}
	}
	if (ep == endp)
		db_printf("0x%lx", (long)val);
}

/*
 * Pretty-prints a pointer. If the 'depth' parameter is less than the
 * 'max_depth' global var, the pointer is "dereference", i.e. the contents of
 * the memory it points to are also printed. The value of the pointer is printed
 * otherwise.
 */
static inline void
db_pprint_ptr(db_addr_t addr, struct ctf_type_v3 *type, u_int depth)
{
	struct ctf_type_v3 *ref_type;
	const char *qual = "";
	const char *name;
	db_addr_t val;
	uint32_t tid;
	u_int kind;
	int ptrcnt;

	ptrcnt = 1;
	tid = type->ctt_type;
again:
	ref_type = db_ctf_typeid_to_type(&sym_data, tid);
	kind = CTF_V3_INFO_KIND(ref_type->ctt_info);
	switch (kind) {
	case CTF_K_STRUCT:
		qual = "struct ";
		break;
	case CTF_K_VOLATILE:
		qual = "volatile ";
		tid = ref_type->ctt_type;
		goto again;
	case CTF_K_CONST:
		qual = "const ";
		tid = ref_type->ctt_type;
		goto again;
	case CTF_K_RESTRICT:
		qual = "restrict ";
		tid = ref_type->ctt_type;
		goto again;
	case CTF_K_POINTER:
		ptrcnt++;
		tid = ref_type->ctt_type;
		goto again;
	case CTF_K_TYPEDEF:
		tid = ref_type->ctt_type;
		goto again;
	default:
		break;
	}

	ptrcnt = min(ptrcnt, strlen(asteriskstr));
	val = (addr != 0) ? db_get_value(addr, sizeof(db_addr_t), false) : 0;
	if (depth < max_depth && (val != 0)) {
		/* Print contents of memory pointed to by this pointer. */
		db_pprint_type(val, ref_type, depth + 1);
	} else {
		name = db_ctf_stroff_to_str(&sym_data, ref_type->ctt_name);
		db_indent = depth;
		if (name != NULL)
			db_printf("(%s%s %.*s) 0x%lx", qual, name, ptrcnt,
			    asteriskstr, (long)val);
		else
			db_printf("(%s %.*s) 0x%lx", qual, ptrcnt, asteriskstr,
			    (long)val);
	}
}

/*
 * Pretty-print dispatching function.
 */
static void
db_pprint_type(db_addr_t addr, struct ctf_type_v3 *type, u_int depth)
{

	if (db_pager_quit) {
		return;
	}
	if (type == NULL) {
		db_printf("unknown type");
		return;
	}

	switch (CTF_V3_INFO_KIND(type->ctt_info)) {
	case CTF_K_INTEGER:
		db_pprint_int(addr, type, depth);
		break;
	case CTF_K_UNION:
	case CTF_K_STRUCT:
		db_pprint_struct(addr, type, depth);
		break;
	case CTF_K_FUNCTION:
	case CTF_K_FLOAT:
		db_indent = depth;
		db_iprintf("0x%lx", (long)addr);
		break;
	case CTF_K_POINTER:
		db_pprint_ptr(addr, type, depth);
		break;
	case CTF_K_TYPEDEF:
	case CTF_K_VOLATILE:
	case CTF_K_RESTRICT:
	case CTF_K_CONST: {
		struct ctf_type_v3 *ref_type = db_ctf_typeid_to_type(&sym_data,
		    type->ctt_type);
		db_pprint_type(addr, ref_type, depth);
		break;
	}
	case CTF_K_ENUM:
		db_pprint_enum(addr, type, depth);
		break;
	case CTF_K_ARRAY:
		db_pprint_arr(addr, type, depth);
		break;
	case CTF_K_UNKNOWN:
	case CTF_K_FORWARD:
	default:
		break;
	}
}

/*
 * Symbol pretty-printing command.
 * Syntax: pprint [/d depth] <sym_name>
 */
static void
db_pprint_symbol_cmd(const char *name)
{
	db_addr_t addr;
	int db_indent_old;
	const char *type_name = NULL;
	struct ctf_type_v3 *type = NULL;

	if (db_pager_quit) {
		return;
	}
	/* Clear symbol and CTF info */
	memset(&sym_data, 0, sizeof(struct db_ctf_sym_data));
	if (db_ctf_find_symbol(name, &sym_data) != 0) {
		db_error("Symbol not found\n");
	}
	if (ELF_ST_TYPE(sym_data.sym->st_info) != STT_OBJECT) {
		db_error("Symbol is not a variable\n");
	}
	addr = sym_data.sym->st_value;
	type = db_ctf_sym_to_type(&sym_data);
	if (type == NULL) {
		db_error("Can't find CTF type info\n");
	}
	type_name = db_ctf_stroff_to_str(&sym_data, type->ctt_name);
	if (type_name != NULL)
		db_printf("%s ", type_name);
	db_printf("%s = ", name);

	db_indent_old = db_indent;
	db_pprint_type(addr, type, 0);
	db_indent = db_indent_old;
}

/*
 * Command for pretty-printing arbitrary addresses.
 * Syntax: pprint [/d depth] struct <struct_name> <addr>
 */
static void
db_pprint_struct_cmd(db_expr_t addr, const char *struct_name)
{
	int db_indent_old;
	struct ctf_type_v3 *type = NULL;

	type = db_ctf_find_typename(&sym_data, struct_name);
	if (type == NULL) {
		db_error("Can't find CTF type info\n");
		return;
	}

	db_printf("struct %s ", struct_name);
	db_printf("%p = ", (void *)addr);

	db_indent_old = db_indent;
	db_pprint_type(addr, type, 0);
	db_indent = db_indent_old;
}

/*
 * Pretty print an address or a symbol.
 */
void
db_pprint_cmd(db_expr_t addr, bool have_addr, db_expr_t count, char *modif)
{
	int t = 0;
	const char *name;

	/* Set default depth */
	max_depth = DB_PPRINT_DEFAULT_DEPTH;
	/* Parse print modifiers */
	t = db_read_token();
	if (t == tSLASH) {
		t = db_read_token();
		if (t != tIDENT) {
			db_error("Invalid flag passed\n");
		}
		/* Parse desired depth level */
		if (strcmp(db_tok_string, "d") == 0) {
			t = db_read_token();
			if (t != tNUMBER) {
				db_error("Invalid depth provided\n");
			}
			max_depth = db_tok_number;
		} else {
			db_error("Invalid flag passed\n");
		}
		/* Fetch next token */
		t = db_read_token();
	}
	/* Parse subcomannd */
	if (t == tIDENT) {
		if (strcmp(db_tok_string, "struct") == 0) {
			t = db_read_token();

			if (t != tIDENT) {
				db_error("Invalid struct type name provided\n");
			}
			name = db_tok_string;

			if (db_expression(&addr) == 0) {
				db_error("Address not provided\n");
			}
			db_pprint_struct_cmd(addr, name);
		} else {
			name = db_tok_string;
			db_pprint_symbol_cmd(name);
		}
	} else {
		db_error("Invalid subcommand\n");
	}
	db_skip_to_eol();
}