diff --git a/sys/ddb/db_pprint.c b/sys/ddb/db_pprint.c index 2925caedd49d..0ca2b0bb952c 100644 --- a/sys/ddb/db_pprint.c +++ b/sys/ddb/db_pprint.c @@ -1,451 +1,473 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2022 Bojan Novković * * 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 #include #include #include #include #include #include #include #include #include #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; - ref_type = db_ctf_typeid_to_type(&sym_data, type->ctt_type); + 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 "; - break; + tid = ref_type->ctt_type; + goto again; case CTF_K_CONST: qual = "const "; - break; + 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; } - val = db_get_value(addr, sizeof(db_addr_t), false); - if (depth < max_depth) { + 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(addr, ref_type, depth + 1); + 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 *) 0x%lx", qual, name, (long)val); + db_printf("(%s%s %.*s) 0x%lx", qual, name, ptrcnt, + asteriskstr, (long)val); else - db_printf("(%s *) 0x%lx", qual, (long)val); + 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] */ 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 */ 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(); }