Gitiles
Code Review Sign In
code.illumos.org / illumos-gate / 1700af3add37a7b6db478d0876536849c3f691fe / . / usr / src / cmd / mdb / common / mdb / mdb_print.c
blob: 3a083d4ac0aa740c3a5808c71710096d6935b858 [file] [log] [blame]
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright (c) 2012, 2014 by Delphix. All rights reserved.
* Copyright 2015 Joyent, Inc.
* Copyright (c) 2014 Nexenta Systems, Inc. All rights reserved.
*/
#include <mdb/mdb_modapi.h>
#include <mdb/mdb_target.h>
#include <mdb/mdb_argvec.h>
#include <mdb/mdb_string.h>
#include <mdb/mdb_stdlib.h>
#include <mdb/mdb_err.h>
#include <mdb/mdb_debug.h>
#include <mdb/mdb_fmt.h>
#include <mdb/mdb_ctf.h>
#include <mdb/mdb_ctf_impl.h>
#include <mdb/mdb.h>
#include <mdb/mdb_tab.h>
#include <sys/isa_defs.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <netinet/in.h>
#include <strings.h>
#include <libctf.h>
#include <ctype.h>
typedef struct holeinfo {
ulong_t hi_offset; /* expected offset */
uchar_t hi_isunion; /* represents a union */
} holeinfo_t;
typedef struct printarg {
mdb_tgt_t *pa_tgt; /* current target */
mdb_tgt_t *pa_realtgt; /* real target (for -i) */
mdb_tgt_t *pa_immtgt; /* immediate target (for -i) */
mdb_tgt_as_t pa_as; /* address space to use for i/o */
mdb_tgt_addr_t pa_addr; /* base address for i/o */
ulong_t pa_armemlim; /* limit on array elements to print */
ulong_t pa_arstrlim; /* limit on array chars to print */
const char *pa_delim; /* element delimiter string */
const char *pa_prefix; /* element prefix string */
const char *pa_suffix; /* element suffix string */
holeinfo_t *pa_holes; /* hole detection information */
int pa_nholes; /* size of holes array */
int pa_flags; /* formatting flags (see below) */
int pa_depth; /* previous depth */
int pa_nest; /* array nesting depth */
int pa_tab; /* tabstop width */
uint_t pa_maxdepth; /* Limit max depth */
uint_t pa_nooutdepth; /* don't print output past this depth */
} printarg_t;
#define PA_SHOWTYPE 0x001 /* print type name */
#define PA_SHOWBASETYPE 0x002 /* print base type name */
#define PA_SHOWNAME 0x004 /* print member name */
#define PA_SHOWADDR 0x008 /* print address */
#define PA_SHOWVAL 0x010 /* print value */
#define PA_SHOWHOLES 0x020 /* print holes in structs */
#define PA_INTHEX 0x040 /* print integer values in hex */
#define PA_INTDEC 0x080 /* print integer values in decimal */
#define PA_NOSYMBOLIC 0x100 /* don't print ptrs as func+offset */
#define IS_CHAR(e) \
(((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == \
(CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY)
#define COMPOSITE_MASK ((1 << CTF_K_STRUCT) | \
(1 << CTF_K_UNION) | (1 << CTF_K_ARRAY))
#define IS_COMPOSITE(k) (((1 << k) & COMPOSITE_MASK) != 0)
#define SOU_MASK ((1 << CTF_K_STRUCT) | (1 << CTF_K_UNION))
#define IS_SOU(k) (((1 << k) & SOU_MASK) != 0)
#define MEMBER_DELIM_ERR -1
#define MEMBER_DELIM_DONE 0
#define MEMBER_DELIM_PTR 1
#define MEMBER_DELIM_DOT 2
#define MEMBER_DELIM_LBR 3
typedef int printarg_f(const char *, const char *,
mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, printarg_t *);
static int elt_print(const char *, mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, int,
void *);
static void print_close_sou(printarg_t *, int);
/*
* Given an address, look up the symbol ID of the specified symbol in its
* containing module. We only support lookups for exact matches.
*/
static const char *
addr_to_sym(mdb_tgt_t *t, uintptr_t addr, char *name, size_t namelen,
GElf_Sym *symp, mdb_syminfo_t *sip)
{
const mdb_map_t *mp;
const char *p;
if (mdb_tgt_lookup_by_addr(t, addr, MDB_TGT_SYM_EXACT, name,
namelen, NULL, NULL) == -1)
return (NULL); /* address does not exactly match a symbol */
if ((p = strrsplit(name, '`')) != NULL) {
if (mdb_tgt_lookup_by_name(t, name, p, symp, sip) == -1)
return (NULL);
return (p);
}
if ((mp = mdb_tgt_addr_to_map(t, addr)) == NULL)
return (NULL); /* address does not fall within a mapping */
if (mdb_tgt_lookup_by_name(t, mp->map_name, name, symp, sip) == -1)
return (NULL);
return (name);
}
/*
* This lets dcmds be a little fancy with their processing of type arguments
* while still treating them more or less as a single argument.
* For example, if a command is invokes like this:
*
* ::<dcmd> proc_t ...
*
* this function will just copy "proc_t" into the provided buffer. If the
* command is instead invoked like this:
*
* ::<dcmd> struct proc ...
*
* this function will place the string "struct proc" into the provided buffer
* and increment the caller's argv and argc. This allows the caller to still
* treat the type argument logically as it would an other atomic argument.
*/
int
args_to_typename(int *argcp, const mdb_arg_t **argvp, char *buf, size_t len)
{
int argc = *argcp;
const mdb_arg_t *argv = *argvp;
if (argc < 1 || argv->a_type != MDB_TYPE_STRING)
return (DCMD_USAGE);
if (strcmp(argv->a_un.a_str, "struct") == 0 ||
strcmp(argv->a_un.a_str, "enum") == 0 ||
strcmp(argv->a_un.a_str, "union") == 0) {
if (argc <= 1) {
mdb_warn("%s is not a valid type\n", argv->a_un.a_str);
return (DCMD_ABORT);
}
if (argv[1].a_type != MDB_TYPE_STRING)
return (DCMD_USAGE);
(void) mdb_snprintf(buf, len, "%s %s",
argv[0].a_un.a_str, argv[1].a_un.a_str);
*argcp = argc - 1;
*argvp = argv + 1;
} else {
(void) mdb_snprintf(buf, len, "%s", argv[0].a_un.a_str);
}
return (0);
}
/*ARGSUSED*/
int
cmd_sizeof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
mdb_ctf_id_t id;
char tn[MDB_SYM_NAMLEN];
int ret;
if (flags & DCMD_ADDRSPEC)
return (DCMD_USAGE);
if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0)
return (ret);
if (argc != 1)
return (DCMD_USAGE);
if (mdb_ctf_lookup_by_name(tn, &id) != 0) {
mdb_warn("failed to look up type %s", tn);
return (DCMD_ERR);
}
if (flags & DCMD_PIPE_OUT)
mdb_printf("%#lr\n", mdb_ctf_type_size(id));
else
mdb_printf("sizeof (%s) = %#lr\n", tn, mdb_ctf_type_size(id));
return (DCMD_OK);
}
int
cmd_sizeof_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
const mdb_arg_t *argv)
{
char tn[MDB_SYM_NAMLEN];
int ret;
if (argc == 0 && !(flags & DCMD_TAB_SPACE))
return (0);
if (argc == 0 && (flags & DCMD_TAB_SPACE))
return (mdb_tab_complete_type(mcp, NULL, MDB_TABC_NOPOINT));
if ((ret = mdb_tab_typename(&argc, &argv, tn, sizeof (tn))) < 0)
return (ret);
if (argc == 1)
return (mdb_tab_complete_type(mcp, tn, MDB_TABC_NOPOINT));
return (0);
}
/*ARGSUSED*/
int
cmd_offsetof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
const char *member;
mdb_ctf_id_t id;
ulong_t off;
char tn[MDB_SYM_NAMLEN];
ssize_t sz;
int ret;
if (flags & DCMD_ADDRSPEC)
return (DCMD_USAGE);
if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0)
return (ret);
if (argc != 2 || argv[1].a_type != MDB_TYPE_STRING)
return (DCMD_USAGE);
if (mdb_ctf_lookup_by_name(tn, &id) != 0) {
mdb_warn("failed to look up type %s", tn);
return (DCMD_ERR);
}
member = argv[1].a_un.a_str;
if (mdb_ctf_member_info(id, member, &off, &id) != 0) {
mdb_warn("failed to find member %s of type %s", member, tn);
return (DCMD_ERR);
}
if (flags & DCMD_PIPE_OUT) {
if (off % NBBY != 0) {
mdb_warn("member %s of type %s is not byte-aligned\n",
member, tn);
return (DCMD_ERR);
}
mdb_printf("%#lr", off / NBBY);
return (DCMD_OK);
}
mdb_printf("offsetof (%s, %s) = %#lr",
tn, member, off / NBBY);
if (off % NBBY != 0)
mdb_printf(".%lr", off % NBBY);
if ((sz = mdb_ctf_type_size(id)) > 0)
mdb_printf(", sizeof (...->%s) = %#lr", member, sz);
mdb_printf("\n");
return (DCMD_OK);
}
/*ARGSUSED*/
static int
enum_prefix_scan_cb(const char *name, int value, void *arg)
{
char *str = arg;
/*
* This function is called with every name in the enum. We make
* "arg" be the common prefix, if any.
*/
if (str[0] == 0) {
if (strlcpy(arg, name, MDB_SYM_NAMLEN) >= MDB_SYM_NAMLEN)
return (1);
return (0);
}
while (*name == *str) {
if (*str == 0) {
if (str != arg) {
str--; /* don't smother a name completely */
}
break;
}
name++;
str++;
}
*str = 0;
return (str == arg); /* only continue if prefix is non-empty */
}
struct enum_p2_info {
intmax_t e_value; /* value we're processing */
char *e_buf; /* buffer for holding names */
size_t e_size; /* size of buffer */
size_t e_prefix; /* length of initial prefix */
uint_t e_allprefix; /* apply prefix to first guy, too */
uint_t e_bits; /* bits seen */
uint8_t e_found; /* have we seen anything? */
uint8_t e_first; /* does buf contain the first one? */
uint8_t e_zero; /* have we seen a zero value? */
};
static int
enum_p2_cb(const char *name, int bit_arg, void *arg)
{
struct enum_p2_info *eiip = arg;
uintmax_t bit = bit_arg;
if (bit != 0 && !ISP2(bit))
return (1); /* non-power-of-2; abort processing */
if ((bit == 0 && eiip->e_zero) ||
(bit != 0 && (eiip->e_bits & bit) != 0)) {
return (0); /* already seen this value */
}
if (bit == 0)
eiip->e_zero = 1;
else
eiip->e_bits |= bit;
if (eiip->e_buf != NULL && (eiip->e_value & bit) != 0) {
char *buf = eiip->e_buf;
size_t prefix = eiip->e_prefix;
if (eiip->e_found) {
(void) strlcat(buf, "|", eiip->e_size);
if (eiip->e_first && !eiip->e_allprefix && prefix > 0) {
char c1 = buf[prefix];
char c2 = buf[prefix + 1];
buf[prefix] = '{';
buf[prefix + 1] = 0;
mdb_printf("%s", buf);
buf[prefix] = c1;
buf[prefix + 1] = c2;
mdb_printf("%s", buf + prefix);
} else {
mdb_printf("%s", buf);
}
}
/* skip the common prefix as necessary */
if ((eiip->e_found || eiip->e_allprefix) &&
strlen(name) > prefix)
name += prefix;
(void) strlcpy(eiip->e_buf, name, eiip->e_size);
eiip->e_first = !eiip->e_found;
eiip->e_found = 1;
}
return (0);
}
static int
enum_is_p2(mdb_ctf_id_t id)
{
struct enum_p2_info eii;
bzero(&eii, sizeof (eii));
return (mdb_ctf_type_kind(id) == CTF_K_ENUM &&
mdb_ctf_enum_iter(id, enum_p2_cb, &eii) == 0 &&
eii.e_bits != 0);
}
static int
enum_value_print_p2(mdb_ctf_id_t id, intmax_t value, uint_t allprefix)
{
struct enum_p2_info eii;
char prefix[MDB_SYM_NAMLEN + 2];
intmax_t missed;
bzero(&eii, sizeof (eii));
eii.e_value = value;
eii.e_buf = prefix;
eii.e_size = sizeof (prefix);
eii.e_allprefix = allprefix;
prefix[0] = 0;
if (mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0)
eii.e_prefix = strlen(prefix);
if (mdb_ctf_enum_iter(id, enum_p2_cb, &eii) != 0 || eii.e_bits == 0)
return (-1);
missed = (value & ~(intmax_t)eii.e_bits);
if (eii.e_found) {
/* push out any final value, with a | if we missed anything */
if (!eii.e_first)
(void) strlcat(prefix, "}", sizeof (prefix));
if (missed != 0)
(void) strlcat(prefix, "|", sizeof (prefix));
mdb_printf("%s", prefix);
}
if (!eii.e_found || missed) {
mdb_printf("%#llx", missed);
}
return (0);
}
struct enum_cbinfo {
uint_t e_flags;
const char *e_string; /* NULL for value searches */
size_t e_prefix;
intmax_t e_value;
uint_t e_found;
mdb_ctf_id_t e_id;
};
#define E_PRETTY 0x01
#define E_HEX 0x02
#define E_SEARCH_STRING 0x04
#define E_SEARCH_VALUE 0x08
#define E_ELIDE_PREFIX 0x10
static void
enum_print(struct enum_cbinfo *info, const char *name, int value)
{
uint_t flags = info->e_flags;
uint_t elide_prefix = (info->e_flags & E_ELIDE_PREFIX);
if (name != NULL && info->e_prefix && strlen(name) > info->e_prefix)
name += info->e_prefix;
if (flags & E_PRETTY) {
uint_t indent = 5 + ((flags & E_HEX) ? 8 : 11);
mdb_printf((flags & E_HEX)? "%8x " : "%11d ", value);
(void) mdb_inc_indent(indent);
if (name != NULL) {
mdb_iob_puts(mdb.m_out, name);
} else {
(void) enum_value_print_p2(info->e_id, value,
elide_prefix);
}
(void) mdb_dec_indent(indent);
mdb_printf("\n");
} else {
mdb_printf("%#r\n", value);
}
}
static int
enum_cb(const char *name, int value, void *arg)
{
struct enum_cbinfo *info = arg;
uint_t flags = info->e_flags;
if (flags & E_SEARCH_STRING) {
if (strcmp(name, info->e_string) != 0)
return (0);
} else if (flags & E_SEARCH_VALUE) {
if (value != info->e_value)
return (0);
}
enum_print(info, name, value);
info->e_found = 1;
return (0);
}
void
enum_help(void)
{
mdb_printf("%s",
"Without an address and name, print all values for the enumeration \"enum\".\n"
"With an address, look up a particular value in \"enum\". With a name, look\n"
"up a particular name in \"enum\".\n");
(void) mdb_dec_indent(2);
mdb_printf("\n%<b>OPTIONS%</b>\n");
(void) mdb_inc_indent(2);
mdb_printf("%s",
" -e remove common prefixes from enum names\n"
" -x report enum values in hexadecimal\n");
}
/*ARGSUSED*/
int
cmd_enum(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
struct enum_cbinfo info;
char type[MDB_SYM_NAMLEN + sizeof ("enum ")];
char tn2[MDB_SYM_NAMLEN + sizeof ("enum ")];
char prefix[MDB_SYM_NAMLEN];
mdb_ctf_id_t id;
mdb_ctf_id_t idr;
int i;
intmax_t search;
uint_t isp2;
info.e_flags = (flags & DCMD_PIPE_OUT)? 0 : E_PRETTY;
info.e_string = NULL;
info.e_value = 0;
info.e_found = 0;
i = mdb_getopts(argc, argv,
'e', MDB_OPT_SETBITS, E_ELIDE_PREFIX, &info.e_flags,
'x', MDB_OPT_SETBITS, E_HEX, &info.e_flags,
NULL);
argc -= i;
argv += i;
if ((i = args_to_typename(&argc, &argv, type, MDB_SYM_NAMLEN)) != 0)
return (i);
if (strchr(type, ' ') == NULL) {
/*
* Check as an enumeration tag first, and fall back
* to checking for a typedef. Yes, this means that
* anonymous enumerations whose typedefs conflict with
* an enum tag can't be accessed. Don't do that.
*/
(void) mdb_snprintf(tn2, sizeof (tn2), "enum %s", type);
if (mdb_ctf_lookup_by_name(tn2, &id) == 0) {
(void) strcpy(type, tn2);
} else if (mdb_ctf_lookup_by_name(type, &id) != 0) {
mdb_warn("types '%s', '%s'", tn2, type);
return (DCMD_ERR);
}
} else {
if (mdb_ctf_lookup_by_name(type, &id) != 0) {
mdb_warn("'%s'", type);
return (DCMD_ERR);
}
}
/* resolve it, and make sure we're looking at an enumeration */
if (mdb_ctf_type_resolve(id, &idr) == -1) {
mdb_warn("unable to resolve '%s'", type);
return (DCMD_ERR);
}
if (mdb_ctf_type_kind(idr) != CTF_K_ENUM) {
mdb_warn("'%s': not an enumeration\n", type);
return (DCMD_ERR);
}
info.e_id = idr;
if (argc > 2)
return (DCMD_USAGE);
if (argc == 2) {
if (flags & DCMD_ADDRSPEC) {
mdb_warn("may only specify one of: name, address\n");
return (DCMD_USAGE);
}
if (argv[1].a_type == MDB_TYPE_STRING) {
info.e_flags |= E_SEARCH_STRING;
info.e_string = argv[1].a_un.a_str;
} else if (argv[1].a_type == MDB_TYPE_IMMEDIATE) {
info.e_flags |= E_SEARCH_VALUE;
search = argv[1].a_un.a_val;
} else {
return (DCMD_USAGE);
}
}
if (flags & DCMD_ADDRSPEC) {
info.e_flags |= E_SEARCH_VALUE;
search = mdb_get_dot();
}
if (info.e_flags & E_SEARCH_VALUE) {
if ((int)search != search) {
mdb_warn("value '%lld' out of enumeration range\n",
search);
}
info.e_value = search;
}
isp2 = enum_is_p2(idr);
if (isp2)
info.e_flags |= E_HEX;
if (DCMD_HDRSPEC(flags) && (info.e_flags & E_PRETTY)) {
if (info.e_flags & E_HEX)
mdb_printf("%<u>%8s %-64s%</u>\n", "VALUE", "NAME");
else
mdb_printf("%<u>%11s %-64s%</u>\n", "VALUE", "NAME");
}
/* if the enum is a power-of-two one, process it that way */
if ((info.e_flags & E_SEARCH_VALUE) && isp2) {
enum_print(&info, NULL, info.e_value);
return (DCMD_OK);
}
prefix[0] = 0;
if ((info.e_flags & E_ELIDE_PREFIX) &&
mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0)
info.e_prefix = strlen(prefix);
if (mdb_ctf_enum_iter(idr, enum_cb, &info) == -1) {
mdb_warn("cannot walk '%s' as enum", type);
return (DCMD_ERR);
}
if (info.e_found == 0 &&
(info.e_flags & (E_SEARCH_STRING | E_SEARCH_VALUE)) != 0) {
if (info.e_flags & E_SEARCH_STRING)
mdb_warn("name \"%s\" not in '%s'\n", info.e_string,
type);
else
mdb_warn("value %#lld not in '%s'\n", info.e_value,
type);
return (DCMD_ERR);
}
return (DCMD_OK);
}
static int
setup_vcb(const char *name, uintptr_t addr)
{
const char *p;
mdb_var_t *v;
if ((v = mdb_nv_lookup(&mdb.m_nv, name)) == NULL) {
if ((p = strbadid(name)) != NULL) {
mdb_warn("'%c' may not be used in a variable "
"name\n", *p);
return (DCMD_ABORT);
}
if ((v = mdb_nv_insert(&mdb.m_nv, name, NULL, addr, 0)) == NULL)
return (DCMD_ERR);
} else {
if (v->v_flags & MDB_NV_RDONLY) {
mdb_warn("variable %s is read-only\n", name);
return (DCMD_ABORT);
}
}
/*
* If there already exists a vcb for this variable, we may be
* calling the dcmd in a loop. We only create a vcb for this
* variable on the first invocation.
*/
if (mdb_vcb_find(v, mdb.m_frame) == NULL)
mdb_vcb_insert(mdb_vcb_create(v), mdb.m_frame);
return (0);
}
/*ARGSUSED*/
int
cmd_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
int offset;
uintptr_t a, tmp;
int ret;
if (!(flags & DCMD_ADDRSPEC) || argc == 0)
return (DCMD_USAGE);
if (argv->a_type != MDB_TYPE_STRING) {
/*
* We are being given a raw offset in lieu of a type and
* member; confirm the number of arguments and argument
* type.
*/
if (argc != 1 || argv->a_type != MDB_TYPE_IMMEDIATE)
return (DCMD_USAGE);
offset = argv->a_un.a_val;
argv++;
argc--;
if (offset % sizeof (uintptr_t)) {
mdb_warn("offset must fall on a word boundary\n");
return (DCMD_ABORT);
}
} else {
const char *member;
char buf[MDB_SYM_NAMLEN];
int ret;
ret = args_to_typename(&argc, &argv, buf, sizeof (buf));
if (ret != 0)
return (ret);
argv++;
argc--;
/*
* If we make it here, we were provided a type name. We should
* only continue if we still have arguments left (e.g. member
* name and potentially a variable name).
*/
if (argc == 0)
return (DCMD_USAGE);
member = argv->a_un.a_str;
offset = mdb_ctf_offsetof_by_name(buf, member);
if (offset == -1)
return (DCMD_ABORT);
argv++;
argc--;
if (offset % (sizeof (uintptr_t)) != 0) {
mdb_warn("%s is not a word-aligned member\n", member);
return (DCMD_ABORT);
}
}
/*
* If we have any unchewed arguments, a variable name must be present.
*/
if (argc == 1) {
if (argv->a_type != MDB_TYPE_STRING)
return (DCMD_USAGE);
if ((ret = setup_vcb(argv->a_un.a_str, addr)) != 0)
return (ret);
} else if (argc != 0) {
return (DCMD_USAGE);
}
a = addr;
do {
mdb_printf("%lr\n", a);
if (mdb_vread(&tmp, sizeof (tmp), a + offset) == -1) {
mdb_warn("failed to read next pointer from object %p",
a);
return (DCMD_ERR);
}
a = tmp;
} while (a != addr && a != NULL);
return (DCMD_OK);
}
int
cmd_array(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
mdb_ctf_id_t id;
ssize_t elemsize = 0;
char tn[MDB_SYM_NAMLEN];
int ret, nelem = -1;
mdb_tgt_t *t = mdb.m_target;
GElf_Sym sym;
mdb_ctf_arinfo_t ar;
mdb_syminfo_t s_info;
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
if (argc >= 2) {
ret = args_to_typename(&argc, &argv, tn, sizeof (tn));
if (ret != 0)
return (ret);
if (argc == 1) /* unquoted compound type without count */
return (DCMD_USAGE);
if (mdb_ctf_lookup_by_name(tn, &id) != 0) {
mdb_warn("failed to look up type %s", tn);
return (DCMD_ABORT);
}
if (argv[1].a_type == MDB_TYPE_IMMEDIATE)
nelem = argv[1].a_un.a_val;
else
nelem = mdb_strtoull(argv[1].a_un.a_str);
elemsize = mdb_ctf_type_size(id);
} else if (addr_to_sym(t, addr, tn, sizeof (tn), &sym, &s_info)
!= NULL && mdb_ctf_lookup_by_symbol(&sym, &s_info, &id)
== 0 && mdb_ctf_type_kind(id) == CTF_K_ARRAY &&
mdb_ctf_array_info(id, &ar) != -1) {
elemsize = mdb_ctf_type_size(id) / ar.mta_nelems;
nelem = ar.mta_nelems;
} else {
mdb_warn("no symbol information for %a", addr);
return (DCMD_ERR);
}
if (argc == 3 || argc == 1) {
if (argv[argc - 1].a_type != MDB_TYPE_STRING)
return (DCMD_USAGE);
if ((ret = setup_vcb(argv[argc - 1].a_un.a_str, addr)) != 0)
return (ret);
} else if (argc > 3) {
return (DCMD_USAGE);
}
for (; nelem > 0; nelem--) {
mdb_printf("%lr\n", addr);
addr = addr + elemsize;
}
return (DCMD_OK);
}
/*
* Print an integer bitfield in hexadecimal by reading the enclosing byte(s)
* and then shifting and masking the data in the lower bits of a uint64_t.
*/
static int
print_bitfield(ulong_t off, printarg_t *pap, ctf_encoding_t *ep)
{
mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
size_t size = (ep->cte_bits + (NBBY - 1)) / NBBY;
uint64_t mask = (1ULL << ep->cte_bits) - 1;
uint64_t value = 0;
uint8_t *buf = (uint8_t *)&value;
uint8_t shift;
const char *format;
if (!(pap->pa_flags & PA_SHOWVAL))
return (0);
if (ep->cte_bits > sizeof (value) * NBBY - 1) {
mdb_printf("??? (invalid bitfield size %u)", ep->cte_bits);
return (0);
}
/*
* On big-endian machines, we need to adjust the buf pointer to refer
* to the lowest 'size' bytes in 'value', and we need shift based on
* the offset from the end of the data, not the offset of the start.
*/
#ifdef _BIG_ENDIAN
buf += sizeof (value) - size;
off += ep->cte_bits;
#endif
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, buf, size, addr) != size) {
mdb_warn("failed to read %lu bytes at %llx",
(ulong_t)size, addr);
return (1);
}
shift = off % NBBY;
/*
* Offsets are counted from opposite ends on little- and
* big-endian machines.
*/
#ifdef _BIG_ENDIAN
shift = NBBY - shift;
#endif
/*
* If the bits we want do not begin on a byte boundary, shift the data
* right so that the value is in the lowest 'cte_bits' of 'value'.
*/
if (off % NBBY != 0)
value >>= shift;
value &= mask;
/*
* We default to printing signed bitfields as decimals,
* and unsigned bitfields in hexadecimal. If they specify
* hexadecimal, we treat the field as unsigned.
*/
if ((pap->pa_flags & PA_INTHEX) ||
!(ep->cte_format & CTF_INT_SIGNED)) {
format = (pap->pa_flags & PA_INTDEC)? "%#llu" : "%#llx";
} else {
int sshift = sizeof (value) * NBBY - ep->cte_bits;
/* sign-extend value, and print as a signed decimal */
value = ((int64_t)value << sshift) >> sshift;
format = "%#lld";
}
mdb_printf(format, value);
return (0);
}
/*
* Print out a character or integer value. We use some simple heuristics,
* described below, to determine the appropriate radix to use for output.
*/
static int
print_int_val(const char *type, ctf_encoding_t *ep, ulong_t off,
printarg_t *pap)
{
static const char *const sformat[] = { "%#d", "%#d", "%#d", "%#lld" };
static const char *const uformat[] = { "%#u", "%#u", "%#u", "%#llu" };
static const char *const xformat[] = { "%#x", "%#x", "%#x", "%#llx" };
mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
const char *const *fsp;
size_t size;
union {
uint64_t i8;
uint32_t i4;
uint16_t i2;
uint8_t i1;
time_t t;
ipaddr_t I;
} u;
if (!(pap->pa_flags & PA_SHOWVAL))
return (0);
if (ep->cte_format & CTF_INT_VARARGS) {
mdb_printf("...\n");
return (0);
}
/*
* If the size is not a power-of-two number of bytes in the range 1-8
* then we assume it is a bitfield and print it as such.
*/
size = ep->cte_bits / NBBY;
if (size > 8 || (ep->cte_bits % NBBY) != 0 || (size & (size - 1)) != 0)
return (print_bitfield(off, pap, ep));
if (IS_CHAR(*ep)) {
mdb_printf("'");
if (mdb_fmt_print(pap->pa_tgt, pap->pa_as,
addr, 1, 'C') == addr)
return (1);
mdb_printf("'");
return (0);
}
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, addr) != size) {
mdb_warn("failed to read %lu bytes at %llx",
(ulong_t)size, addr);
return (1);
}
/*
* We pretty-print some integer based types. time_t values are
* printed as a calendar date and time, and IPv4 addresses as human
* readable dotted quads.
*/
if (!(pap->pa_flags & (PA_INTHEX | PA_INTDEC))) {
if (strcmp(type, "time_t") == 0 && u.t != 0) {
mdb_printf("%Y", u.t);
return (0);
}
if (strcmp(type, "ipaddr_t") == 0 ||
strcmp(type, "in_addr_t") == 0) {
mdb_printf("%I", u.I);
return (0);
}
}
/*
* The default format is hexadecimal.
*/
if (!(pap->pa_flags & PA_INTDEC))
fsp = xformat;
else if (ep->cte_format & CTF_INT_SIGNED)
fsp = sformat;
else
fsp = uformat;
switch (size) {
case sizeof (uint8_t):
mdb_printf(fsp[0], u.i1);
break;
case sizeof (uint16_t):
mdb_printf(fsp[1], u.i2);
break;
case sizeof (uint32_t):
mdb_printf(fsp[2], u.i4);
break;
case sizeof (uint64_t):
mdb_printf(fsp[3], u.i8);
break;
}
return (0);
}
/*ARGSUSED*/
static int
print_int(const char *type, const char *name, mdb_ctf_id_t id,
mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
{
ctf_encoding_t e;
if (!(pap->pa_flags & PA_SHOWVAL))
return (0);
if (mdb_ctf_type_encoding(base, &e) != 0) {
mdb_printf("??? (%s)", mdb_strerror(errno));
return (0);
}
return (print_int_val(type, &e, off, pap));
}
/*
* Print out a floating point value. We only provide support for floats in
* the ANSI-C float, double, and long double formats.
*/
/*ARGSUSED*/
static int
print_float(const char *type, const char *name, mdb_ctf_id_t id,
mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
{
#ifndef _KMDB
mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
ctf_encoding_t e;
union {
float f;
double d;
long double ld;
} u;
if (!(pap->pa_flags & PA_SHOWVAL))
return (0);
if (mdb_ctf_type_encoding(base, &e) == 0) {
if (e.cte_format == CTF_FP_SINGLE &&
e.cte_bits == sizeof (float) * NBBY) {
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.f,
sizeof (u.f), addr) != sizeof (u.f)) {
mdb_warn("failed to read float at %llx", addr);
return (1);
}
mdb_printf("%s", doubletos(u.f, 7, 'e'));
} else if (e.cte_format == CTF_FP_DOUBLE &&
e.cte_bits == sizeof (double) * NBBY) {
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.d,
sizeof (u.d), addr) != sizeof (u.d)) {
mdb_warn("failed to read float at %llx", addr);
return (1);
}
mdb_printf("%s", doubletos(u.d, 7, 'e'));
} else if (e.cte_format == CTF_FP_LDOUBLE &&
e.cte_bits == sizeof (long double) * NBBY) {
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.ld,
sizeof (u.ld), addr) != sizeof (u.ld)) {
mdb_warn("failed to read float at %llx", addr);
return (1);
}
mdb_printf("%s", longdoubletos(&u.ld, 16, 'e'));
} else {
mdb_printf("??? (unsupported FP format %u / %u bits\n",
e.cte_format, e.cte_bits);
}
} else
mdb_printf("??? (%s)", mdb_strerror(errno));
#else
mdb_printf("<FLOAT>");
#endif
return (0);
}
/*
* Print out a pointer value as a symbol name + offset or a hexadecimal value.
* If the pointer itself is a char *, we attempt to read a bit of the data
* referenced by the pointer and display it if it is a printable ASCII string.
*/
/*ARGSUSED*/
static int
print_ptr(const char *type, const char *name, mdb_ctf_id_t id,
mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
{
mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
ctf_encoding_t e;
uintptr_t value;
char buf[256];
ssize_t len;
if (!(pap->pa_flags & PA_SHOWVAL))
return (0);
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
&value, sizeof (value), addr) != sizeof (value)) {
mdb_warn("failed to read %s pointer at %llx", name, addr);
return (1);
}
if (pap->pa_flags & PA_NOSYMBOLIC) {
mdb_printf("%#lx", value);
return (0);
}
mdb_printf("%a", value);
if (value == NULL || strcmp(type, "caddr_t") == 0)
return (0);
if (mdb_ctf_type_kind(base) == CTF_K_POINTER &&
mdb_ctf_type_reference(base, &base) != -1 &&
mdb_ctf_type_resolve(base, &base) != -1 &&
mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e)) {
if ((len = mdb_tgt_readstr(pap->pa_realtgt, pap->pa_as,
buf, sizeof (buf), value)) >= 0 && strisprint(buf)) {
if (len == sizeof (buf))
(void) strabbr(buf, sizeof (buf));
mdb_printf(" \"%s\"", buf);
}
}
return (0);
}
/*
* Print out a fixed-size array. We special-case arrays of characters
* and attempt to print them out as ASCII strings if possible. For other
* arrays, we iterate over a maximum of pa_armemlim members and call
* mdb_ctf_type_visit() again on each element to print its value.
*/
/*ARGSUSED*/
static int
print_array(const char *type, const char *name, mdb_ctf_id_t id,
mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
{
mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
printarg_t pa = *pap;
ssize_t eltsize;
mdb_ctf_arinfo_t r;
ctf_encoding_t e;
uint_t i, kind, limit;
int d, sou;
char buf[8];
char *str;
if (!(pap->pa_flags & PA_SHOWVAL))
return (0);
if (pap->pa_depth == pap->pa_maxdepth) {
mdb_printf("[ ... ]");
return (0);
}
/*
* Determine the base type and size of the array's content. If this
* fails, we cannot print anything and just give up.
*/
if (mdb_ctf_array_info(base, &r) == -1 ||
mdb_ctf_type_resolve(r.mta_contents, &base) == -1 ||
(eltsize = mdb_ctf_type_size(base)) == -1) {
mdb_printf("[ ??? ] (%s)", mdb_strerror(errno));
return (0);
}
/*
* Read a few bytes and determine if the content appears to be
* printable ASCII characters. If so, read the entire array and
* attempt to display it as a string if it is printable.
*/
if ((pap->pa_arstrlim == MDB_ARR_NOLIMIT ||
r.mta_nelems <= pap->pa_arstrlim) &&
mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e) &&
mdb_tgt_readstr(pap->pa_tgt, pap->pa_as, buf,
MIN(sizeof (buf), r.mta_nelems), addr) > 0 && strisprint(buf)) {
str = mdb_alloc(r.mta_nelems + 1, UM_SLEEP | UM_GC);
str[r.mta_nelems] = '\0';
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, str,
r.mta_nelems, addr) != r.mta_nelems) {
mdb_warn("failed to read char array at %llx", addr);
return (1);
}
if (strisprint(str)) {
mdb_printf("[ \"%s\" ]", str);
return (0);
}
}
if (pap->pa_armemlim != MDB_ARR_NOLIMIT)
limit = MIN(r.mta_nelems, pap->pa_armemlim);
else
limit = r.mta_nelems;
if (limit == 0) {
mdb_printf("[ ... ]");
return (0);
}
kind = mdb_ctf_type_kind(base);
sou = IS_COMPOSITE(kind);
pa.pa_addr = addr; /* set base address to start of array */
pa.pa_maxdepth = pa.pa_maxdepth - pa.pa_depth - 1;
pa.pa_nest += pa.pa_depth + 1; /* nesting level is current depth + 1 */
pa.pa_depth = 0; /* reset depth to 0 for new scope */
pa.pa_prefix = NULL;
if (sou) {
pa.pa_delim = "\n";
mdb_printf("[\n");
} else {
pa.pa_flags &= ~(PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR);
pa.pa_delim = ", ";
mdb_printf("[ ");
}
for (i = 0; i < limit; i++, pa.pa_addr += eltsize) {
if (i == limit - 1 && !sou) {
if (limit < r.mta_nelems)
pa.pa_delim = ", ... ]";
else
pa.pa_delim = " ]";
}
if (mdb_ctf_type_visit(r.mta_contents, elt_print, &pa) == -1) {
mdb_warn("failed to print array data");
return (1);
}
}
if (sou) {
for (d = pa.pa_depth - 1; d >= 0; d--)
print_close_sou(&pa, d);
if (limit < r.mta_nelems) {
mdb_printf("%*s... ]",
(pap->pa_depth + pap->pa_nest) * pap->pa_tab, "");
} else {
mdb_printf("%*s]",
(pap->pa_depth + pap->pa_nest) * pap->pa_tab, "");
}
}
/* copy the hole array info, since it may have been grown */
pap->pa_holes = pa.pa_holes;
pap->pa_nholes = pa.pa_nholes;
return (0);
}
/*
* Print out a struct or union header. We need only print the open brace
* because mdb_ctf_type_visit() itself will automatically recurse through
* all members of the given struct or union.
*/
/*ARGSUSED*/
static int
print_sou(const char *type, const char *name, mdb_ctf_id_t id,
mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
{
mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
/*
* We have pretty-printing for some structures where displaying
* structure contents has no value.
*/
if (pap->pa_flags & PA_SHOWVAL) {
if (strcmp(type, "in6_addr_t") == 0 ||
strcmp(type, "struct in6_addr") == 0) {
in6_addr_t in6addr;
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &in6addr,
sizeof (in6addr), addr) != sizeof (in6addr)) {
mdb_warn("failed to read %s pointer at %llx",
name, addr);
return (1);
}
mdb_printf("%N", &in6addr);
/*
* Don't print anything further down in the
* structure.
*/
pap->pa_nooutdepth = pap->pa_depth;
return (0);
}
if (strcmp(type, "struct in_addr") == 0) {
in_addr_t inaddr;
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &inaddr,
sizeof (inaddr), addr) != sizeof (inaddr)) {
mdb_warn("failed to read %s pointer at %llx",
name, addr);
return (1);
}
mdb_printf("%I", inaddr);
pap->pa_nooutdepth = pap->pa_depth;
return (0);
}
}
if (pap->pa_depth == pap->pa_maxdepth)
mdb_printf("{ ... }");
else
mdb_printf("{");
pap->pa_delim = "\n";
return (0);
}
/*
* Print an enum value. We attempt to convert the value to the corresponding
* enum name and print that if possible.
*/
/*ARGSUSED*/
static int
print_enum(const char *type, const char *name, mdb_ctf_id_t id,
mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
{
mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
const char *ename;
int value;
int isp2 = enum_is_p2(base);
int flags = pap->pa_flags | (isp2 ? PA_INTHEX : 0);
if (!(flags & PA_SHOWVAL))
return (0);
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
&value, sizeof (value), addr) != sizeof (value)) {
mdb_warn("failed to read %s integer at %llx", name, addr);
return (1);
}
if (flags & PA_INTHEX)
mdb_printf("%#x", value);
else
mdb_printf("%#d", value);
(void) mdb_inc_indent(8);
mdb_printf(" (");
if (!isp2 || enum_value_print_p2(base, value, 0) != 0) {
ename = mdb_ctf_enum_name(base, value);
if (ename == NULL) {
ename = "???";
}
mdb_printf("%s", ename);
}
mdb_printf(")");
(void) mdb_dec_indent(8);
return (0);
}
/*
* This will only get called if the structure isn't found in any available CTF
* data.
*/
/*ARGSUSED*/
static int
print_tag(const char *type, const char *name, mdb_ctf_id_t id,
mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
{
char basename[MDB_SYM_NAMLEN];
if (pap->pa_flags & PA_SHOWVAL)
mdb_printf("; ");
if (mdb_ctf_type_name(base, basename, sizeof (basename)) != NULL)
mdb_printf("<forward declaration of %s>", basename);
else
mdb_printf("<forward declaration of unknown type>");
return (0);
}
static void
print_hole(printarg_t *pap, int depth, ulong_t off, ulong_t endoff)
{
ulong_t bits = endoff - off;
ulong_t size = bits / NBBY;
ctf_encoding_t e;
static const char *const name = "<<HOLE>>";
char type[MDB_SYM_NAMLEN];
int bitfield =
(off % NBBY != 0 ||
bits % NBBY != 0 ||
size > 8 ||
(size & (size - 1)) != 0);
ASSERT(off < endoff);
if (bits > NBBY * sizeof (uint64_t)) {
ulong_t end;
/*
* The hole is larger than the largest integer type. To
* handle this, we split up the hole at 8-byte-aligned
* boundaries, recursing to print each subsection. For
* normal C structures, we'll loop at most twice.
*/
for (; off < endoff; off = end) {
end = P2END(off, NBBY * sizeof (uint64_t));
if (end > endoff)
end = endoff;
ASSERT((end - off) <= NBBY * sizeof (uint64_t));
print_hole(pap, depth, off, end);
}
ASSERT(end == endoff);
return;
}
if (bitfield)
(void) mdb_snprintf(type, sizeof (type), "unsigned");
else
(void) mdb_snprintf(type, sizeof (type), "uint%d_t", bits);
if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR))
mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, "");
if (pap->pa_flags & PA_SHOWADDR) {
if (off % NBBY == 0)
mdb_printf("%llx ", pap->pa_addr + off / NBBY);
else
mdb_printf("%llx.%lx ",
pap->pa_addr + off / NBBY, off % NBBY);
}
if (pap->pa_flags & PA_SHOWTYPE)
mdb_printf("%s ", type);
if (pap->pa_flags & PA_SHOWNAME)
mdb_printf("%s", name);
if (bitfield && (pap->pa_flags & PA_SHOWTYPE))
mdb_printf(" :%d", bits);
mdb_printf("%s ", (pap->pa_flags & PA_SHOWVAL)? " =" : "");
/*
* We fake up a ctf_encoding_t, and use print_int_val() to print
* the value. Holes are always processed as unsigned integers.
*/
bzero(&e, sizeof (e));
e.cte_format = 0;
e.cte_offset = 0;
e.cte_bits = bits;
if (print_int_val(type, &e, off, pap) != 0)
mdb_iob_discard(mdb.m_out);
else
mdb_iob_puts(mdb.m_out, pap->pa_delim);
}
/*
* The print_close_sou() function is called for each structure or union
* which has been completed. For structures, we detect and print any holes
* before printing the closing brace.
*/
static void
print_close_sou(printarg_t *pap, int newdepth)
{
int d = newdepth + pap->pa_nest;
if ((pap->pa_flags & PA_SHOWHOLES) && !pap->pa_holes[d].hi_isunion) {
ulong_t end = pap->pa_holes[d + 1].hi_offset;
ulong_t expected = pap->pa_holes[d].hi_offset;
if (end < expected)
print_hole(pap, newdepth + 1, end, expected);
}
/* if the struct is an array element, print a comma after the } */
mdb_printf("%*s}%s\n", d * pap->pa_tab, "",
(newdepth == 0 && pap->pa_nest > 0)? "," : "");
}
static printarg_f *const printfuncs[] = {
print_int, /* CTF_K_INTEGER */
print_float, /* CTF_K_FLOAT */
print_ptr, /* CTF_K_POINTER */
print_array, /* CTF_K_ARRAY */
print_ptr, /* CTF_K_FUNCTION */
print_sou, /* CTF_K_STRUCT */
print_sou, /* CTF_K_UNION */
print_enum, /* CTF_K_ENUM */
print_tag /* CTF_K_FORWARD */
};
/*
* The elt_print function is used as the mdb_ctf_type_visit callback. For
* each element, we print an appropriate name prefix and then call the
* print subroutine for this type class in the array above.
*/
static int
elt_print(const char *name, mdb_ctf_id_t id, mdb_ctf_id_t base,
ulong_t off, int depth, void *data)
{
char type[MDB_SYM_NAMLEN + sizeof (" <<12345678...>>")];
int kind, rc, d;
printarg_t *pap = data;
for (d = pap->pa_depth - 1; d >= depth; d--) {
if (d < pap->pa_nooutdepth)
print_close_sou(pap, d);
}
/*
* Reset pa_nooutdepth if we've come back out of the structure we
* didn't want to print.
*/
if (depth <= pap->pa_nooutdepth)
pap->pa_nooutdepth = (uint_t)-1;
if (depth > pap->pa_maxdepth || depth > pap->pa_nooutdepth)
return (0);
if (!mdb_ctf_type_valid(base) ||
(kind = mdb_ctf_type_kind(base)) == -1)
return (-1); /* errno is set for us */
if (mdb_ctf_type_name(id, type, MDB_SYM_NAMLEN) == NULL)
(void) strcpy(type, "(?)");
if (pap->pa_flags & PA_SHOWBASETYPE) {
/*
* If basetype is different and informative, concatenate
* <<basetype>> (or <<baset...>> if it doesn't fit)
*
* We just use the end of the buffer to store the type name, and
* only connect it up if that's necessary.
*/
char *type_end = type + strlen(type);
char *basetype;
size_t sz;
(void) strlcat(type, " <<", sizeof (type));
basetype = type + strlen(type);
sz = sizeof (type) - (basetype - type);
*type_end = '\0'; /* restore the end of type for strcmp() */
if (mdb_ctf_type_name(base, basetype, sz) != NULL &&
strcmp(basetype, type) != 0 &&
strcmp(basetype, "struct ") != 0 &&
strcmp(basetype, "enum ") != 0 &&
strcmp(basetype, "union ") != 0) {
type_end[0] = ' '; /* reconnect */
if (strlcat(type, ">>", sizeof (type)) >= sizeof (type))
(void) strlcpy(
type + sizeof (type) - 6, "...>>", 6);
}
}
if (pap->pa_flags & PA_SHOWHOLES) {
ctf_encoding_t e;
ssize_t nsize;
ulong_t newoff;
holeinfo_t *hole;
int extra = IS_COMPOSITE(kind)? 1 : 0;
/*
* grow the hole array, if necessary
*/
if (pap->pa_nest + depth + extra >= pap->pa_nholes) {
int new = MAX(MAX(8, pap->pa_nholes * 2),
pap->pa_nest + depth + extra + 1);
holeinfo_t *nhi = mdb_zalloc(
sizeof (*nhi) * new, UM_NOSLEEP | UM_GC);
bcopy(pap->pa_holes, nhi,
pap->pa_nholes * sizeof (*nhi));
pap->pa_holes = nhi;
pap->pa_nholes = new;
}
hole = &pap->pa_holes[depth + pap->pa_nest];
if (depth != 0 && off > hole->hi_offset)
print_hole(pap, depth, hole->hi_offset, off);
/* compute the next expected offset */
if (kind == CTF_K_INTEGER &&
mdb_ctf_type_encoding(base, &e) == 0)
newoff = off + e.cte_bits;
else if ((nsize = mdb_ctf_type_size(base)) >= 0)
newoff = off + nsize * NBBY;
else {
/* something bad happened, disable hole checking */
newoff = -1UL; /* ULONG_MAX */
}
hole->hi_offset = newoff;
if (IS_COMPOSITE(kind)) {
hole->hi_isunion = (kind == CTF_K_UNION);
hole++;
hole->hi_offset = off;
}
}
if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR))
mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, "");
if (pap->pa_flags & PA_SHOWADDR) {
if (off % NBBY == 0)
mdb_printf("%llx ", pap->pa_addr + off / NBBY);
else
mdb_printf("%llx.%lx ",
pap->pa_addr + off / NBBY, off % NBBY);
}
if ((pap->pa_flags & PA_SHOWTYPE)) {
mdb_printf("%s", type);
/*
* We want to avoid printing a trailing space when
* dealing with pointers in a structure, so we end
* up with:
*
* label_t *t_onfault = 0
*
* If depth is zero, always print the trailing space unless
* we also have a prefix.
*/
if (type[strlen(type) - 1] != '*' ||
(depth == 0 && (!(pap->pa_flags & PA_SHOWNAME) ||
pap->pa_prefix == NULL)))
mdb_printf(" ");
}
if (pap->pa_flags & PA_SHOWNAME) {
if (pap->pa_prefix != NULL && depth <= 1)
mdb_printf("%s%s", pap->pa_prefix,
(depth == 0) ? "" : pap->pa_suffix);
mdb_printf("%s", name);
}
if ((pap->pa_flags & PA_SHOWTYPE) && kind == CTF_K_INTEGER) {
ctf_encoding_t e;
if (mdb_ctf_type_encoding(base, &e) == 0) {
ulong_t bits = e.cte_bits;
ulong_t size = bits / NBBY;
if (bits % NBBY != 0 ||
off % NBBY != 0 ||
size > 8 ||
size != mdb_ctf_type_size(base))
mdb_printf(" :%d", bits);
}
}
if (depth != 0 ||
((pap->pa_flags & PA_SHOWNAME) && pap->pa_prefix != NULL))
mdb_printf("%s ", pap->pa_flags & PA_SHOWVAL ? " =" : "");
if (depth == 0 && pap->pa_prefix != NULL)
name = pap->pa_prefix;
pap->pa_depth = depth;
if (kind <= CTF_K_UNKNOWN || kind >= CTF_K_TYPEDEF) {
mdb_warn("unknown ctf for %s type %s kind %d\n",
name, type, kind);
return (-1);
}
rc = printfuncs[kind - 1](type, name, id, base, off, pap);
if (rc != 0)
mdb_iob_discard(mdb.m_out);
else
mdb_iob_puts(mdb.m_out, pap->pa_delim);
return (rc);
}
/*
* Special semantics for pipelines.
*/
static int
pipe_print(mdb_ctf_id_t id, ulong_t off, void *data)
{
printarg_t *pap = data;
ssize_t size;
static const char *const fsp[] = { "%#r", "%#r", "%#r", "%#llr" };
uintptr_t value;
uintptr_t addr = pap->pa_addr + off / NBBY;
mdb_ctf_id_t base;
int enum_value;
ctf_encoding_t e;
union {
uint64_t i8;
uint32_t i4;
uint16_t i2;
uint8_t i1;
} u;
if (mdb_ctf_type_resolve(id, &base) == -1) {
mdb_warn("could not resolve type");
return (-1);
}
/*
* If the user gives -a, then always print out the address of the
* member.
*/
if ((pap->pa_flags & PA_SHOWADDR)) {
mdb_printf("%#lr\n", addr);
return (0);
}
again:
switch (mdb_ctf_type_kind(base)) {
case CTF_K_POINTER:
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
&value, sizeof (value), addr) != sizeof (value)) {
mdb_warn("failed to read pointer at %p", addr);
return (-1);
}
mdb_printf("%#lr\n", value);
break;
case CTF_K_ENUM:
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &enum_value,
sizeof (enum_value), addr) != sizeof (enum_value)) {
mdb_warn("failed to read enum at %llx", addr);
return (-1);
}
mdb_printf("%#r\n", enum_value);
break;
case CTF_K_INTEGER:
if (mdb_ctf_type_encoding(base, &e) != 0) {
mdb_warn("could not get type encoding\n");
return (-1);
}
/*
* For immediate values, we just print out the value.
*/
size = e.cte_bits / NBBY;
if (size > 8 || (e.cte_bits % NBBY) != 0 ||
(size & (size - 1)) != 0) {
return (print_bitfield(off, pap, &e));
}
if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size,
addr) != size) {
mdb_warn("failed to read %lu bytes at %p",
(ulong_t)size, pap->pa_addr);
return (-1);
}
switch (size) {
case sizeof (uint8_t):
mdb_printf(fsp[0], u.i1);
break;
case sizeof (uint16_t):
mdb_printf(fsp[1], u.i2);
break;
case sizeof (uint32_t):
mdb_printf(fsp[2], u.i4);
break;
case sizeof (uint64_t):
mdb_printf(fsp[3], u.i8);
break;
}
mdb_printf("\n");
break;
case CTF_K_FUNCTION:
case CTF_K_FLOAT:
case CTF_K_ARRAY:
case CTF_K_UNKNOWN:
case CTF_K_STRUCT:
case CTF_K_UNION:
case CTF_K_FORWARD:
/*
* For these types, always print the address of the member
*/
mdb_printf("%#lr\n", addr);
break;
default:
mdb_warn("unknown type %d", mdb_ctf_type_kind(base));
break;
}
return (0);
}
static int
parse_delimiter(char **strp)
{
switch (**strp) {
case '\0':
return (MEMBER_DELIM_DONE);
case '.':
*strp = *strp + 1;
return (MEMBER_DELIM_DOT);
case '[':
*strp = *strp + 1;
return (MEMBER_DELIM_LBR);
case '-':
*strp = *strp + 1;
if (**strp == '>') {
*strp = *strp + 1;
return (MEMBER_DELIM_PTR);
}
*strp = *strp - 1;
/*FALLTHROUGH*/
default:
return (MEMBER_DELIM_ERR);
}
}
static int
deref(printarg_t *pap, size_t size)
{
uint32_t a32;
mdb_tgt_as_t as = pap->pa_as;
mdb_tgt_addr_t *ap = &pap->pa_addr;
if (size == sizeof (mdb_tgt_addr_t)) {
if (mdb_tgt_aread(mdb.m_target, as, ap, size, *ap) == -1) {
mdb_warn("could not dereference pointer %llx\n", *ap);
return (-1);
}
} else {
if (mdb_tgt_aread(mdb.m_target, as, &a32, size, *ap) == -1) {
mdb_warn("could not dereference pointer %x\n", *ap);
return (-1);
}
*ap = (mdb_tgt_addr_t)a32;
}
/*
* We've dereferenced at least once, we must be on the real
* target. If we were in the immediate target, reset to the real
* target; it's reset as needed when we return to the print
* routines.
*/
if (pap->pa_tgt == pap->pa_immtgt)
pap->pa_tgt = pap->pa_realtgt;
return (0);
}
static int
parse_member(printarg_t *pap, const char *str, mdb_ctf_id_t id,
mdb_ctf_id_t *idp, ulong_t *offp, int *last_deref)
{
int delim;
char member[64];
char buf[128];
uint_t index;
char *start = (char *)str;
char *end;
ulong_t off = 0;
mdb_ctf_arinfo_t ar;
mdb_ctf_id_t rid;
int kind;
ssize_t size;
int non_array = FALSE;
/*
* id always has the unresolved type for printing error messages
* that include the type; rid always has the resolved type for
* use in mdb_ctf_* calls. It is possible for this command to fail,
* however, if the resolved type is in the parent and it is currently
* unavailable. Note that we also can't print out the name of the
* type, since that would also rely on looking up the resolved name.
*/
if (mdb_ctf_type_resolve(id, &rid) != 0) {
mdb_warn("failed to resolve type");
return (-1);
}
delim = parse_delimiter(&start);
/*
* If the user fails to specify an initial delimiter, guess -> for
* pointer types and . for non-pointer types.
*/
if (delim == MEMBER_DELIM_ERR)
delim = (mdb_ctf_type_kind(rid) == CTF_K_POINTER) ?
MEMBER_DELIM_PTR : MEMBER_DELIM_DOT;
*last_deref = FALSE;
while (delim != MEMBER_DELIM_DONE) {
switch (delim) {
case MEMBER_DELIM_PTR:
kind = mdb_ctf_type_kind(rid);
if (kind != CTF_K_POINTER) {
mdb_warn("%s is not a pointer type\n",
mdb_ctf_type_name(id, buf, sizeof (buf)));
return (-1);
}
size = mdb_ctf_type_size(id);
if (deref(pap, size) != 0)
return (-1);
(void) mdb_ctf_type_reference(rid, &id);
(void) mdb_ctf_type_resolve(id, &rid);
off = 0;
break;
case MEMBER_DELIM_DOT:
kind = mdb_ctf_type_kind(rid);
if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
mdb_warn("%s is not a struct or union type\n",
mdb_ctf_type_name(id, buf, sizeof (buf)));
return (-1);
}
break;
case MEMBER_DELIM_LBR:
end = strchr(start, ']');
if (end == NULL) {
mdb_warn("no trailing ']'\n");
return (-1);
}
(void) mdb_snprintf(member, end - start + 1, "%s",
start);
index = mdb_strtoull(member);
switch (mdb_ctf_type_kind(rid)) {
case CTF_K_POINTER:
size = mdb_ctf_type_size(rid);
if (deref(pap, size) != 0)
return (-1);
(void) mdb_ctf_type_reference(rid, &id);
(void) mdb_ctf_type_resolve(id, &rid);
size = mdb_ctf_type_size(id);
if (size <= 0) {
mdb_warn("cannot dereference void "
"type\n");
return (-1);
}
pap->pa_addr += index * size;
off = 0;
if (index == 0 && non_array)
*last_deref = TRUE;
break;
case CTF_K_ARRAY:
(void) mdb_ctf_array_info(rid, &ar);
if (index >= ar.mta_nelems) {
mdb_warn("index %r is outside of "
"array bounds [0 .. %r]\n",
index, ar.mta_nelems - 1);
}
id = ar.mta_contents;
(void) mdb_ctf_type_resolve(id, &rid);
size = mdb_ctf_type_size(id);
if (size <= 0) {
mdb_warn("cannot dereference void "
"type\n");
return (-1);
}
pap->pa_addr += index * size;
off = 0;
break;
default:
mdb_warn("cannot index into non-array, "
"non-pointer type\n");
return (-1);
}
start = end + 1;
delim = parse_delimiter(&start);
continue;
case MEMBER_DELIM_ERR:
default:
mdb_warn("'%c' is not a valid delimiter\n", *start);
return (-1);
}
*last_deref = FALSE;
non_array = TRUE;
/*
* Find the end of the member name; assume that a member
* name is at least one character long.
*/
for (end = start + 1; isalnum(*end) || *end == '_'; end++)
continue;
(void) mdb_snprintf(member, end - start + 1, "%s", start);
if (mdb_ctf_member_info(rid, member, &off, &id) != 0) {
mdb_warn("failed to find member %s of %s", member,
mdb_ctf_type_name(id, buf, sizeof (buf)));
return (-1);
}
(void) mdb_ctf_type_resolve(id, &rid);
pap->pa_addr += off / NBBY;
start = end;
delim = parse_delimiter(&start);
}
*idp = id;
*offp = off;
return (0);
}
static int
cmd_print_tab_common(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
const mdb_arg_t *argv)
{
char tn[MDB_SYM_NAMLEN];
char member[64];
int delim, kind;
int ret = 0;
mdb_ctf_id_t id, rid;
mdb_ctf_arinfo_t ar;
char *start, *end;
ulong_t dul;
if (argc == 0 && !(flags & DCMD_TAB_SPACE))
return (0);
if (argc == 0 && (flags & DCMD_TAB_SPACE))
return (mdb_tab_complete_type(mcp, NULL, MDB_TABC_NOPOINT |
MDB_TABC_NOARRAY));
if ((ret = mdb_tab_typename(&argc, &argv, tn, sizeof (tn))) < 0)
return (ret);
if (argc == 1 && (!(flags & DCMD_TAB_SPACE) || ret == 1))
return (mdb_tab_complete_type(mcp, tn, MDB_TABC_NOPOINT |
MDB_TABC_NOARRAY));
if (argc == 1 && (flags & DCMD_TAB_SPACE))
return (mdb_tab_complete_member(mcp, tn, NULL));
/*
* This is the reason that tab completion was created. We're going to go
* along and walk the delimiters until we find something a member that
* we don't recognize, at which point we'll try and tab complete it.
* Note that ::print takes multiple args, so this is going to operate on
* whatever the last arg that we have is.
*/
if (mdb_ctf_lookup_by_name(tn, &id) != 0)
return (1);
(void) mdb_ctf_type_resolve(id, &rid);
start = (char *)argv[argc-1].a_un.a_str;
delim = parse_delimiter(&start);
/*
* If we hit the case where we actually have no delimiters, than we need
* to make sure that we properly set up the fields the loops would.
*/
if (delim == MEMBER_DELIM_DONE)
(void) mdb_snprintf(member, sizeof (member), "%s", start);
while (delim != MEMBER_DELIM_DONE) {
switch (delim) {
case MEMBER_DELIM_PTR:
kind = mdb_ctf_type_kind(rid);
if (kind != CTF_K_POINTER)
return (1);
(void) mdb_ctf_type_reference(rid, &id);
(void) mdb_ctf_type_resolve(id, &rid);
break;
case MEMBER_DELIM_DOT:
kind = mdb_ctf_type_kind(rid);
if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
return (1);
break;
case MEMBER_DELIM_LBR:
end = strchr(start, ']');
/*
* We're not going to try and tab complete the indexes
* here. So for now, punt on it. Also, we're not going
* to try and validate you're within the bounds, just
* that you get the type you asked for.
*/
if (end == NULL)
return (1);
switch (mdb_ctf_type_kind(rid)) {
case CTF_K_POINTER:
(void) mdb_ctf_type_reference(rid, &id);
(void) mdb_ctf_type_resolve(id, &rid);
break;
case CTF_K_ARRAY:
(void) mdb_ctf_array_info(rid, &ar);
id = ar.mta_contents;
(void) mdb_ctf_type_resolve(id, &rid);
break;
default:
return (1);
}
start = end + 1;
delim = parse_delimiter(&start);
break;
case MEMBER_DELIM_ERR:
default:
break;
}
for (end = start + 1; isalnum(*end) || *end == '_'; end++)
continue;
(void) mdb_snprintf(member, end - start + 1, start);
/*
* We are going to try to resolve this name as a member. There
* are a few two different questions that we need to answer. The
* first is do we recognize this member. The second is are we at
* the end of the string. If we encounter a member that we don't
* recognize before the end, then we have to error out and can't
* complete it. But if there are no more delimiters then we can
* try and complete it.
*/
ret = mdb_ctf_member_info(rid, member, &dul, &id);
start = end;
delim = parse_delimiter(&start);
if (ret != 0 && errno == EMDB_CTFNOMEMB) {
if (delim != MEMBER_DELIM_DONE)
return (1);
continue;
} else if (ret != 0)
return (1);
if (delim == MEMBER_DELIM_DONE)
return (mdb_tab_complete_member_by_id(mcp, rid,
member));
(void) mdb_ctf_type_resolve(id, &rid);
}
/*
* If we've reached here, then we need to try and tab complete the last
* field, which is currently member, based on the ctf type id that we
* already have in rid.
*/
return (mdb_tab_complete_member_by_id(mcp, rid, member));
}
int
cmd_print_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
const mdb_arg_t *argv)
{
int i, dummy;
/*
* This getopts is only here to make the tab completion work better when
* including options in the ::print arguments. None of the values should
* be used. This should only be updated with additional arguments, if
* they are added to cmd_print.
*/
i = mdb_getopts(argc, argv,
'a', MDB_OPT_SETBITS, PA_SHOWADDR, &dummy,
'C', MDB_OPT_SETBITS, TRUE, &dummy,
'c', MDB_OPT_UINTPTR, &dummy,
'd', MDB_OPT_SETBITS, PA_INTDEC, &dummy,
'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &dummy,
'i', MDB_OPT_SETBITS, TRUE, &dummy,
'L', MDB_OPT_SETBITS, TRUE, &dummy,
'l', MDB_OPT_UINTPTR, &dummy,
'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &dummy,
'p', MDB_OPT_SETBITS, TRUE, &dummy,
's', MDB_OPT_UINTPTR, &dummy,
'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &dummy,
't', MDB_OPT_SETBITS, PA_SHOWTYPE, &dummy,
'x', MDB_OPT_SETBITS, PA_INTHEX, &dummy,
NULL);
argc -= i;
argv += i;
return (cmd_print_tab_common(mcp, flags, argc, argv));
}
/*
* Recursively descend a print a given data structure. We create a struct of
* the relevant print arguments and then call mdb_ctf_type_visit() to do the
* traversal, using elt_print() as the callback for each element.
*/
/*ARGSUSED*/
int
cmd_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
uintptr_t opt_c = MDB_ARR_NOLIMIT, opt_l = MDB_ARR_NOLIMIT;
uint_t opt_C = FALSE, opt_L = FALSE, opt_p = FALSE, opt_i = FALSE;
uintptr_t opt_s = (uintptr_t)-1ul;
int uflags = (flags & DCMD_ADDRSPEC) ? PA_SHOWVAL : 0;
mdb_ctf_id_t id;
int err = DCMD_OK;
mdb_tgt_t *t = mdb.m_target;
printarg_t pa;
int d, i;
char s_name[MDB_SYM_NAMLEN];
mdb_syminfo_t s_info;
GElf_Sym sym;
/*
* If a new option is added, make sure the getopts above in
* cmd_print_tab is also updated.
*/
i = mdb_getopts(argc, argv,
'a', MDB_OPT_SETBITS, PA_SHOWADDR, &uflags,
'C', MDB_OPT_SETBITS, TRUE, &opt_C,
'c', MDB_OPT_UINTPTR, &opt_c,
'd', MDB_OPT_SETBITS, PA_INTDEC, &uflags,
'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &uflags,
'i', MDB_OPT_SETBITS, TRUE, &opt_i,
'L', MDB_OPT_SETBITS, TRUE, &opt_L,
'l', MDB_OPT_UINTPTR, &opt_l,
'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &uflags,
'p', MDB_OPT_SETBITS, TRUE, &opt_p,
's', MDB_OPT_UINTPTR, &opt_s,
'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &uflags,
't', MDB_OPT_SETBITS, PA_SHOWTYPE, &uflags,
'x', MDB_OPT_SETBITS, PA_INTHEX, &uflags,
NULL);
if (uflags & PA_INTHEX)
uflags &= ~PA_INTDEC; /* -x and -d are mutually exclusive */
uflags |= PA_SHOWNAME;
if (opt_p && opt_i) {
mdb_warn("-p and -i options are incompatible\n");
return (DCMD_ERR);
}
argc -= i;
argv += i;
if (argc != 0 && argv->a_type == MDB_TYPE_STRING) {
const char *t_name = s_name;
int ret;
if (strchr("+-", argv->a_un.a_str[0]) != NULL)
return (DCMD_USAGE);
if ((ret = args_to_typename(&argc, &argv, s_name,
sizeof (s_name))) != 0)
return (ret);
if (mdb_ctf_lookup_by_name(t_name, &id) != 0) {
if (!(flags & DCMD_ADDRSPEC) || opt_i ||
addr_to_sym(t, addr, s_name, sizeof (s_name),
&sym, &s_info) == NULL ||
mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) {
mdb_warn("failed to look up type %s", t_name);
return (DCMD_ABORT);
}
} else {
argc--;
argv++;
}
} else if (!(flags & DCMD_ADDRSPEC) || opt_i) {
return (DCMD_USAGE);
} else if (addr_to_sym(t, addr, s_name, sizeof (s_name),
&sym, &s_info) == NULL) {
mdb_warn("no symbol information for %a", addr);
return (DCMD_ERR);
} else if (mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) {
mdb_warn("no type data available for %a [%u]", addr,
s_info.sym_id);
return (DCMD_ERR);
}
pa.pa_tgt = mdb.m_target;
pa.pa_realtgt = pa.pa_tgt;
pa.pa_immtgt = NULL;
pa.pa_as = opt_p ? MDB_TGT_AS_PHYS : MDB_TGT_AS_VIRT;
pa.pa_armemlim = mdb.m_armemlim;
pa.pa_arstrlim = mdb.m_arstrlim;
pa.pa_delim = "\n";
pa.pa_flags = uflags;
pa.pa_nest = 0;
pa.pa_tab = 4;
pa.pa_prefix = NULL;
pa.pa_suffix = NULL;
pa.pa_holes = NULL;
pa.pa_nholes = 0;
pa.pa_depth = 0;
pa.pa_maxdepth = opt_s;
pa.pa_nooutdepth = (uint_t)-1;
if ((flags & DCMD_ADDRSPEC) && !opt_i)
pa.pa_addr = opt_p ? mdb_get_dot() : addr;
else
pa.pa_addr = NULL;
if (opt_i) {
const char *vargv[2];
uintmax_t dot = mdb_get_dot();
size_t outsize = mdb_ctf_type_size(id);
vargv[0] = (const char *)&dot;
vargv[1] = (const char *)&outsize;
pa.pa_immtgt = mdb_tgt_create(mdb_value_tgt_create,
0, 2, vargv);
pa.pa_tgt = pa.pa_immtgt;
}
if (opt_c != MDB_ARR_NOLIMIT)
pa.pa_arstrlim = opt_c;
if (opt_C)
pa.pa_arstrlim = MDB_ARR_NOLIMIT;
if (opt_l != MDB_ARR_NOLIMIT)
pa.pa_armemlim = opt_l;
if (opt_L)
pa.pa_armemlim = MDB_ARR_NOLIMIT;
if (argc > 0) {
for (i = 0; i < argc; i++) {
mdb_ctf_id_t mid;
int last_deref;
ulong_t off;
int kind;
char buf[MDB_SYM_NAMLEN];
mdb_tgt_t *oldtgt = pa.pa_tgt;
mdb_tgt_as_t oldas = pa.pa_as;
mdb_tgt_addr_t oldaddr = pa.pa_addr;
if (argv->a_type == MDB_TYPE_STRING) {
const char *member = argv[i].a_un.a_str;
mdb_ctf_id_t rid;
if (parse_member(&pa, member, id, &mid,
&off, &last_deref) != 0) {
err = DCMD_ABORT;
goto out;
}
/*
* If the member string ends with a "[0]"
* (last_deref * is true) and the type is a
* structure or union, * print "->" rather
* than "[0]." in elt_print.
*/
(void) mdb_ctf_type_resolve(mid, &rid);
kind = mdb_ctf_type_kind(rid);
if (last_deref && IS_SOU(kind)) {
char *end;
(void) mdb_snprintf(buf, sizeof (buf),
"%s", member);
end = strrchr(buf, '[');
*end = '\0';
pa.pa_suffix = "->";
member = &buf[0];
} else if (IS_SOU(kind)) {
pa.pa_suffix = ".";
} else {
pa.pa_suffix = "";
}
pa.pa_prefix = member;
} else {
ulong_t moff;
moff = (ulong_t)argv[i].a_un.a_val;
if (mdb_ctf_offset_to_name(id, moff * NBBY,
buf, sizeof (buf), 0, &mid, &off) == -1) {
mdb_warn("invalid offset %lx\n", moff);
err = DCMD_ABORT;
goto out;
}
pa.pa_prefix = buf;
pa.pa_addr += moff - off / NBBY;
pa.pa_suffix = strlen(buf) == 0 ? "" : ".";
}
off %= NBBY;
if (flags & DCMD_PIPE_OUT) {
if (pipe_print(mid, off, &pa) != 0) {
mdb_warn("failed to print type");
err = DCMD_ERR;
goto out;
}
} else if (off != 0) {
mdb_ctf_id_t base;
(void) mdb_ctf_type_resolve(mid, &base);
if (elt_print("", mid, base, off, 0,
&pa) != 0) {
mdb_warn("failed to print type");
err = DCMD_ERR;
goto out;
}
} else {
if (mdb_ctf_type_visit(mid, elt_print,
&pa) == -1) {
mdb_warn("failed to print type");
err = DCMD_ERR;
goto out;
}
for (d = pa.pa_depth - 1; d >= 0; d--)
print_close_sou(&pa, d);
}
pa.pa_depth = 0;
pa.pa_tgt = oldtgt;
pa.pa_as = oldas;
pa.pa_addr = oldaddr;
pa.pa_delim = "\n";
}
} else if (flags & DCMD_PIPE_OUT) {
if (pipe_print(id, 0, &pa) != 0) {
mdb_warn("failed to print type");
err = DCMD_ERR;
goto out;
}
} else {
if (mdb_ctf_type_visit(id, elt_print, &pa) == -1) {
mdb_warn("failed to print type");
err = DCMD_ERR;
goto out;
}
for (d = pa.pa_depth - 1; d >= 0; d--)
print_close_sou(&pa, d);
}
mdb_set_dot(addr + mdb_ctf_type_size(id));
err = DCMD_OK;
out:
if (pa.pa_immtgt)
mdb_tgt_destroy(pa.pa_immtgt);
return (err);
}
void
print_help(void)
{
mdb_printf(
"-a show address of object\n"
"-C unlimit the length of character arrays\n"
"-c limit limit the length of character arrays\n"
"-d output values in decimal\n"
"-h print holes in structures\n"
"-i interpret address as data of the given type\n"
"-L unlimit the length of standard arrays\n"
"-l limit limit the length of standard arrays\n"
"-n don't print pointers as symbol offsets\n"
"-p interpret address as a physical memory address\n"
"-s depth limit the recursion depth\n"
"-T show type and <<base type>> of object\n"
"-t show type of object\n"
"-x output values in hexadecimal\n"
"\n"
"type may be omitted if the C type of addr can be inferred.\n"
"\n"
"Members may be specified with standard C syntax using the\n"
"array indexing operator \"[index]\", structure member\n"
"operator \".\", or structure pointer operator \"->\".\n"
"\n"
"Offsets must use the $[ expression ] syntax\n");
}
static int
printf_signed(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt,
boolean_t sign)
{
ssize_t size;
mdb_ctf_id_t base;
ctf_encoding_t e;
union {
uint64_t ui8;
uint32_t ui4;
uint16_t ui2;
uint8_t ui1;
int64_t i8;
int32_t i4;
int16_t i2;
int8_t i1;
} u;
if (mdb_ctf_type_resolve(id, &base) == -1) {
mdb_warn("could not resolve type");
return (DCMD_ABORT);
}
switch (mdb_ctf_type_kind(base)) {
case CTF_K_ENUM:
e.cte_format = CTF_INT_SIGNED;
e.cte_offset = 0;
e.cte_bits = mdb_ctf_type_size(id) * NBBY;
break;
case CTF_K_INTEGER:
if (mdb_ctf_type_encoding(base, &e) != 0) {
mdb_warn("could not get type encoding");
return (DCMD_ABORT);
}
break;
default:
mdb_warn("expected integer type\n");
return (DCMD_ABORT);
}
if (sign)
sign = e.cte_format & CTF_INT_SIGNED;
size = e.cte_bits / NBBY;
/*
* Check to see if our life has been complicated by the presence of
* a bitfield. If it has, we will print it using logic that is only
* slightly different than that found in print_bitfield(), above. (In
* particular, see the comments there for an explanation of the
* endianness differences in this code.)
*/
if (size > 8 || (e.cte_bits % NBBY) != 0 ||
(size & (size - 1)) != 0) {
uint64_t mask = (1ULL << e.cte_bits) - 1;
uint64_t value = 0;
uint8_t *buf = (uint8_t *)&value;
uint8_t shift;
/*
* Round our size up one byte.
*/
size = (e.cte_bits + (NBBY - 1)) / NBBY;
if (e.cte_bits > sizeof (value) * NBBY - 1) {
mdb_printf("invalid bitfield size %u", e.cte_bits);
return (DCMD_ABORT);
}
#ifdef _BIG_ENDIAN
buf += sizeof (value) - size;
off += e.cte_bits;
#endif
if (mdb_vread(buf, size, addr) == -1) {
mdb_warn("failed to read %lu bytes at %p", size, addr);
<