xref: /illumos-gate/usr/src/cmd/mdb/common/mdb/mdb_print.c (revision 7a58f538)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Copyright (c) 2012, 2014 by Delphix. All rights reserved.
28  * Copyright 2020 Joyent, Inc.
29  * Copyright (c) 2014 Nexenta Systems, Inc. All rights reserved.
30  * Copyright 2021 Oxide Computer Company
31  */
32 
33 #include <mdb/mdb_modapi.h>
34 #include <mdb/mdb_target.h>
35 #include <mdb/mdb_argvec.h>
36 #include <mdb/mdb_string.h>
37 #include <mdb/mdb_stdlib.h>
38 #include <mdb/mdb_err.h>
39 #include <mdb/mdb_debug.h>
40 #include <mdb/mdb_fmt.h>
41 #include <mdb/mdb_ctf.h>
42 #include <mdb/mdb_ctf_impl.h>
43 #include <mdb/mdb.h>
44 #include <mdb/mdb_tab.h>
45 
46 #include <sys/isa_defs.h>
47 #include <sys/param.h>
48 #include <sys/sysmacros.h>
49 #include <netinet/in.h>
50 #include <strings.h>
51 #include <libctf.h>
52 #include <ctype.h>
53 
54 typedef struct holeinfo {
55 	ulong_t hi_offset;		/* expected offset */
56 	uchar_t hi_isunion;		/* represents a union */
57 } holeinfo_t;
58 
59 typedef struct printarg {
60 	mdb_tgt_t *pa_tgt;		/* current target */
61 	mdb_tgt_t *pa_realtgt;		/* real target (for -i) */
62 	mdb_tgt_t *pa_immtgt;		/* immediate target (for -i) */
63 	mdb_tgt_as_t pa_as;		/* address space to use for i/o */
64 	mdb_tgt_addr_t pa_addr;		/* base address for i/o */
65 	ulong_t pa_armemlim;		/* limit on array elements to print */
66 	ulong_t pa_arstrlim;		/* limit on array chars to print */
67 	const char *pa_delim;		/* element delimiter string */
68 	const char *pa_prefix;		/* element prefix string */
69 	const char *pa_suffix;		/* element suffix string */
70 	holeinfo_t *pa_holes;		/* hole detection information */
71 	int pa_nholes;			/* size of holes array */
72 	int pa_flags;			/* formatting flags (see below) */
73 	int pa_depth;			/* previous depth */
74 	int pa_nest;			/* array nesting depth */
75 	int pa_tab;			/* tabstop width */
76 	uint_t pa_maxdepth;		/* Limit max depth */
77 	uint_t pa_nooutdepth;		/* don't print output past this depth */
78 } printarg_t;
79 
80 #define	PA_SHOWTYPE	0x001		/* print type name */
81 #define	PA_SHOWBASETYPE	0x002		/* print base type name */
82 #define	PA_SHOWNAME	0x004		/* print member name */
83 #define	PA_SHOWADDR	0x008		/* print address */
84 #define	PA_SHOWVAL	0x010		/* print value */
85 #define	PA_SHOWHOLES	0x020		/* print holes in structs */
86 #define	PA_INTHEX	0x040		/* print integer values in hex */
87 #define	PA_INTDEC	0x080		/* print integer values in decimal */
88 #define	PA_NOSYMBOLIC	0x100		/* don't print ptrs as func+offset */
89 
90 #define	IS_CHAR(e) \
91 	(((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == \
92 	(CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY)
93 
94 #define	COMPOSITE_MASK	((1 << CTF_K_STRUCT) | \
95 			(1 << CTF_K_UNION) | (1 << CTF_K_ARRAY))
96 #define	IS_COMPOSITE(k)	(((1 << k) & COMPOSITE_MASK) != 0)
97 
98 #define	SOU_MASK	((1 << CTF_K_STRUCT) | (1 << CTF_K_UNION))
99 #define	IS_SOU(k)	(((1 << k) & SOU_MASK) != 0)
100 
101 #define	MEMBER_DELIM_ERR	-1
102 #define	MEMBER_DELIM_DONE	0
103 #define	MEMBER_DELIM_PTR	1
104 #define	MEMBER_DELIM_DOT	2
105 #define	MEMBER_DELIM_LBR	3
106 
107 typedef int printarg_f(const char *, const char *,
108     mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, printarg_t *);
109 
110 static int elt_print(const char *, mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, int,
111     void *);
112 static void print_close_sou(printarg_t *, int);
113 
114 /*
115  * Given an address, look up the symbol ID of the specified symbol in its
116  * containing module.  We only support lookups for exact matches.
117  */
118 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)119 addr_to_sym(mdb_tgt_t *t, uintptr_t addr, char *name, size_t namelen,
120     GElf_Sym *symp, mdb_syminfo_t *sip)
121 {
122 	const mdb_map_t *mp;
123 	const char *p;
124 
125 	if (mdb_tgt_lookup_by_addr(t, addr, MDB_TGT_SYM_EXACT, name,
126 	    namelen, NULL, NULL) == -1)
127 		return (NULL); /* address does not exactly match a symbol */
128 
129 	if ((p = strrsplit(name, '`')) != NULL) {
130 		if (mdb_tgt_lookup_by_name(t, name, p, symp, sip) == -1)
131 			return (NULL);
132 		return (p);
133 	}
134 
135 	if ((mp = mdb_tgt_addr_to_map(t, addr)) == NULL)
136 		return (NULL); /* address does not fall within a mapping */
137 
138 	if (mdb_tgt_lookup_by_name(t, mp->map_name, name, symp, sip) == -1)
139 		return (NULL);
140 
141 	return (name);
142 }
143 
144 /*
145  * This lets dcmds be a little fancy with their processing of type arguments
146  * while still treating them more or less as a single argument.
147  * For example, if a command is invokes like this:
148  *
149  *   ::<dcmd> proc_t ...
150  *
151  * this function will just copy "proc_t" into the provided buffer. If the
152  * command is instead invoked like this:
153  *
154  *   ::<dcmd> struct proc ...
155  *
156  * this function will place the string "struct proc" into the provided buffer
157  * and increment the caller's argv and argc. This allows the caller to still
158  * treat the type argument logically as it would an other atomic argument.
159  */
160 int
args_to_typename(int * argcp,const mdb_arg_t ** argvp,char * buf,size_t len)161 args_to_typename(int *argcp, const mdb_arg_t **argvp, char *buf, size_t len)
162 {
163 	int argc = *argcp;
164 	const mdb_arg_t *argv = *argvp;
165 
166 	if (argc < 1 || argv->a_type != MDB_TYPE_STRING)
167 		return (DCMD_USAGE);
168 
169 	if (strcmp(argv->a_un.a_str, "struct") == 0 ||
170 	    strcmp(argv->a_un.a_str, "enum") == 0 ||
171 	    strcmp(argv->a_un.a_str, "union") == 0) {
172 		if (argc <= 1) {
173 			mdb_warn("%s is not a valid type\n", argv->a_un.a_str);
174 			return (DCMD_ABORT);
175 		}
176 
177 		if (argv[1].a_type != MDB_TYPE_STRING)
178 			return (DCMD_USAGE);
179 
180 		(void) mdb_snprintf(buf, len, "%s %s",
181 		    argv[0].a_un.a_str, argv[1].a_un.a_str);
182 
183 		*argcp = argc - 1;
184 		*argvp = argv + 1;
185 	} else {
186 		(void) mdb_snprintf(buf, len, "%s", argv[0].a_un.a_str);
187 	}
188 
189 	return (0);
190 }
191 
192 /*ARGSUSED*/
193 int
cmd_sizeof(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)194 cmd_sizeof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
195 {
196 	mdb_ctf_id_t id;
197 	char tn[MDB_SYM_NAMLEN];
198 	int ret;
199 
200 	if (flags & DCMD_ADDRSPEC)
201 		return (DCMD_USAGE);
202 
203 	if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0)
204 		return (ret);
205 
206 	if (argc != 1)
207 		return (DCMD_USAGE);
208 
209 	if (mdb_ctf_lookup_by_name(tn, &id) != 0) {
210 		mdb_warn("failed to look up type %s", tn);
211 		return (DCMD_ERR);
212 	}
213 
214 	if (flags & DCMD_PIPE_OUT)
215 		mdb_printf("%#lr\n", mdb_ctf_type_size(id));
216 	else
217 		mdb_printf("sizeof (%s) = %#lr\n", tn, mdb_ctf_type_size(id));
218 
219 	return (DCMD_OK);
220 }
221 
222 int
cmd_sizeof_tab(mdb_tab_cookie_t * mcp,uint_t flags,int argc,const mdb_arg_t * argv)223 cmd_sizeof_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
224     const mdb_arg_t *argv)
225 {
226 	char tn[MDB_SYM_NAMLEN];
227 	int ret;
228 
229 	if (argc == 0 && !(flags & DCMD_TAB_SPACE))
230 		return (0);
231 
232 	if (argc == 0 && (flags & DCMD_TAB_SPACE))
233 		return (mdb_tab_complete_type(mcp, NULL, MDB_TABC_NOPOINT));
234 
235 	if ((ret = mdb_tab_typename(&argc, &argv, tn, sizeof (tn))) < 0)
236 		return (ret);
237 
238 	if (argc == 1)
239 		return (mdb_tab_complete_type(mcp, tn, MDB_TABC_NOPOINT));
240 
241 	return (0);
242 }
243 
244 /*ARGSUSED*/
245 int
cmd_offsetof(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)246 cmd_offsetof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
247 {
248 	const char *member;
249 	mdb_ctf_id_t id;
250 	ulong_t off;
251 	char tn[MDB_SYM_NAMLEN];
252 	ssize_t sz;
253 	int ret;
254 
255 	if (flags & DCMD_ADDRSPEC)
256 		return (DCMD_USAGE);
257 
258 	if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0)
259 		return (ret);
260 
261 	if (argc != 2 || argv[1].a_type != MDB_TYPE_STRING)
262 		return (DCMD_USAGE);
263 
264 	if (mdb_ctf_lookup_by_name(tn, &id) != 0) {
265 		mdb_warn("failed to look up type %s", tn);
266 		return (DCMD_ERR);
267 	}
268 
269 	member = argv[1].a_un.a_str;
270 
271 	if (mdb_ctf_member_info(id, member, &off, &id) != 0) {
272 		mdb_warn("failed to find member %s of type %s", member, tn);
273 		return (DCMD_ERR);
274 	}
275 
276 	if (flags & DCMD_PIPE_OUT) {
277 		if (off % NBBY != 0) {
278 			mdb_warn("member %s of type %s is not byte-aligned\n",
279 			    member, tn);
280 			return (DCMD_ERR);
281 		}
282 		mdb_printf("%#lr", off / NBBY);
283 		return (DCMD_OK);
284 	}
285 
286 	mdb_printf("offsetof (%s, %s) = %#lr",
287 	    tn, member, off / NBBY);
288 	if (off % NBBY != 0)
289 		mdb_printf(".%lr", off % NBBY);
290 
291 	if ((sz = mdb_ctf_type_size(id)) > 0)
292 		mdb_printf(", sizeof (...->%s) = %#lr", member, sz);
293 
294 	mdb_printf("\n");
295 
296 	return (DCMD_OK);
297 }
298 
299 /*ARGSUSED*/
300 static int
enum_prefix_scan_cb(const char * name,int value,void * arg)301 enum_prefix_scan_cb(const char *name, int value, void *arg)
302 {
303 	char *str = arg;
304 
305 	/*
306 	 * This function is called with every name in the enum.  We make
307 	 * "arg" be the common prefix, if any.
308 	 */
309 	if (str[0] == 0) {
310 		if (strlcpy(arg, name, MDB_SYM_NAMLEN) >= MDB_SYM_NAMLEN)
311 			return (1);
312 		return (0);
313 	}
314 
315 	while (*name == *str) {
316 		if (*str == 0) {
317 			if (str != arg) {
318 				str--;	/* don't smother a name completely */
319 			}
320 			break;
321 		}
322 		name++;
323 		str++;
324 	}
325 	*str = 0;
326 
327 	return (str == arg);	/* only continue if prefix is non-empty */
328 }
329 
330 struct enum_p2_info {
331 	intmax_t e_value;	/* value we're processing */
332 	char	*e_buf;		/* buffer for holding names */
333 	size_t	e_size;		/* size of buffer */
334 	size_t	e_prefix;	/* length of initial prefix */
335 	uint_t	e_allprefix;	/* apply prefix to first guy, too */
336 	uint_t	e_bits;		/* bits seen */
337 	uint8_t	e_found;	/* have we seen anything? */
338 	uint8_t	e_first;	/* does buf contain the first one? */
339 	uint8_t	e_zero;		/* have we seen a zero value? */
340 };
341 
342 static int
enum_p2_cb(const char * name,int bit_arg,void * arg)343 enum_p2_cb(const char *name, int bit_arg, void *arg)
344 {
345 	struct enum_p2_info *eiip = arg;
346 	uintmax_t bit = bit_arg;
347 
348 	if (bit != 0 && !ISP2(bit))
349 		return (1);	/* non-power-of-2; abort processing */
350 
351 	if ((bit == 0 && eiip->e_zero) ||
352 	    (bit != 0 && (eiip->e_bits & bit) != 0)) {
353 		return (0);	/* already seen this value */
354 	}
355 
356 	if (bit == 0)
357 		eiip->e_zero = 1;
358 	else
359 		eiip->e_bits |= bit;
360 
361 	if (eiip->e_buf != NULL && (eiip->e_value & bit) != 0) {
362 		char *buf = eiip->e_buf;
363 		size_t prefix = eiip->e_prefix;
364 
365 		if (eiip->e_found) {
366 			(void) strlcat(buf, "|", eiip->e_size);
367 
368 			if (eiip->e_first && !eiip->e_allprefix && prefix > 0) {
369 				char c1 = buf[prefix];
370 				char c2 = buf[prefix + 1];
371 				buf[prefix] = '{';
372 				buf[prefix + 1] = 0;
373 				mdb_printf("%s", buf);
374 				buf[prefix] = c1;
375 				buf[prefix + 1] = c2;
376 				mdb_printf("%s", buf + prefix);
377 			} else {
378 				mdb_printf("%s", buf);
379 			}
380 
381 		}
382 		/* skip the common prefix as necessary */
383 		if ((eiip->e_found || eiip->e_allprefix) &&
384 		    strlen(name) > prefix)
385 			name += prefix;
386 
387 		(void) strlcpy(eiip->e_buf, name, eiip->e_size);
388 		eiip->e_first = !eiip->e_found;
389 		eiip->e_found = 1;
390 	}
391 	return (0);
392 }
393 
394 static int
enum_is_p2(mdb_ctf_id_t id)395 enum_is_p2(mdb_ctf_id_t id)
396 {
397 	struct enum_p2_info eii;
398 	bzero(&eii, sizeof (eii));
399 
400 	return (mdb_ctf_type_kind(id) == CTF_K_ENUM &&
401 	    mdb_ctf_enum_iter(id, enum_p2_cb, &eii) == 0 &&
402 	    eii.e_bits != 0);
403 }
404 
405 static int
enum_value_print_p2(mdb_ctf_id_t id,intmax_t value,uint_t allprefix)406 enum_value_print_p2(mdb_ctf_id_t id, intmax_t value, uint_t allprefix)
407 {
408 	struct enum_p2_info eii;
409 	char prefix[MDB_SYM_NAMLEN + 2];
410 	intmax_t missed;
411 
412 	bzero(&eii, sizeof (eii));
413 
414 	eii.e_value = value;
415 	eii.e_buf = prefix;
416 	eii.e_size = sizeof (prefix);
417 	eii.e_allprefix = allprefix;
418 
419 	prefix[0] = 0;
420 	if (mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0)
421 		eii.e_prefix = strlen(prefix);
422 
423 	if (mdb_ctf_enum_iter(id, enum_p2_cb, &eii) != 0 || eii.e_bits == 0)
424 		return (-1);
425 
426 	missed = (value & ~(intmax_t)eii.e_bits);
427 
428 	if (eii.e_found) {
429 		/* push out any final value, with a | if we missed anything */
430 		if (!eii.e_first)
431 			(void) strlcat(prefix, "}", sizeof (prefix));
432 		if (missed != 0)
433 			(void) strlcat(prefix, "|", sizeof (prefix));
434 
435 		mdb_printf("%s", prefix);
436 	}
437 
438 	if (!eii.e_found || missed) {
439 		mdb_printf("%#llx", missed);
440 	}
441 
442 	return (0);
443 }
444 
445 struct enum_cbinfo {
446 	uint_t		e_flags;
447 	const char	*e_string;	/* NULL for value searches */
448 	size_t		e_prefix;
449 	intmax_t	e_value;
450 	uint_t		e_found;
451 	mdb_ctf_id_t	e_id;
452 };
453 #define	E_PRETTY		0x01
454 #define	E_HEX			0x02
455 #define	E_SEARCH_STRING		0x04
456 #define	E_SEARCH_VALUE		0x08
457 #define	E_ELIDE_PREFIX		0x10
458 
459 static void
enum_print(struct enum_cbinfo * info,const char * name,int value)460 enum_print(struct enum_cbinfo *info, const char *name, int value)
461 {
462 	uint_t flags = info->e_flags;
463 	uint_t elide_prefix = (info->e_flags & E_ELIDE_PREFIX);
464 
465 	if (name != NULL && info->e_prefix && strlen(name) > info->e_prefix)
466 		name += info->e_prefix;
467 
468 	if (flags & E_PRETTY) {
469 		uint_t indent = 5 + ((flags & E_HEX) ? 8 : 11);
470 
471 		mdb_printf((flags & E_HEX)? "%8x " : "%11d ", value);
472 		(void) mdb_inc_indent(indent);
473 		if (name != NULL) {
474 			mdb_iob_puts(mdb.m_out, name);
475 		} else {
476 			(void) enum_value_print_p2(info->e_id, value,
477 			    elide_prefix);
478 		}
479 		(void) mdb_dec_indent(indent);
480 		mdb_printf("\n");
481 	} else {
482 		mdb_printf("%#r\n", value);
483 	}
484 }
485 
486 static int
enum_cb(const char * name,int value,void * arg)487 enum_cb(const char *name, int value, void *arg)
488 {
489 	struct enum_cbinfo *info = arg;
490 	uint_t flags = info->e_flags;
491 
492 	if (flags & E_SEARCH_STRING) {
493 		if (strcmp(name, info->e_string) != 0)
494 			return (0);
495 
496 	} else if (flags & E_SEARCH_VALUE) {
497 		if (value != info->e_value)
498 			return (0);
499 	}
500 
501 	enum_print(info, name, value);
502 
503 	info->e_found = 1;
504 	return (0);
505 }
506 
507 void
enum_help(void)508 enum_help(void)
509 {
510 	mdb_printf("%s",
511 "Without an address and name, print all values for the enumeration \"enum\".\n"
512 "With an address, look up a particular value in \"enum\".  With a name, look\n"
513 "up a particular name in \"enum\".\n");
514 
515 	(void) mdb_dec_indent(2);
516 	mdb_printf("\n%<b>OPTIONS%</b>\n");
517 	(void) mdb_inc_indent(2);
518 
519 	mdb_printf("%s",
520 "   -e    remove common prefixes from enum names\n"
521 "   -x    report enum values in hexadecimal\n");
522 }
523 
524 /*ARGSUSED*/
525 int
cmd_enum(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)526 cmd_enum(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
527 {
528 	struct enum_cbinfo info;
529 
530 	char type[MDB_SYM_NAMLEN + sizeof ("enum ")];
531 	char tn2[MDB_SYM_NAMLEN + sizeof ("enum ")];
532 	char prefix[MDB_SYM_NAMLEN];
533 	mdb_ctf_id_t id;
534 	mdb_ctf_id_t idr;
535 
536 	int i;
537 	intmax_t search = 0;
538 	uint_t isp2;
539 
540 	info.e_flags = (flags & DCMD_PIPE_OUT)? 0 : E_PRETTY;
541 	info.e_string = NULL;
542 	info.e_value = 0;
543 	info.e_found = 0;
544 
545 	i = mdb_getopts(argc, argv,
546 	    'e', MDB_OPT_SETBITS, E_ELIDE_PREFIX, &info.e_flags,
547 	    'x', MDB_OPT_SETBITS, E_HEX, &info.e_flags,
548 	    NULL);
549 
550 	argc -= i;
551 	argv += i;
552 
553 	if ((i = args_to_typename(&argc, &argv, type, MDB_SYM_NAMLEN)) != 0)
554 		return (i);
555 
556 	if (strchr(type, ' ') == NULL) {
557 		/*
558 		 * Check as an enumeration tag first, and fall back
559 		 * to checking for a typedef.  Yes, this means that
560 		 * anonymous enumerations whose typedefs conflict with
561 		 * an enum tag can't be accessed.  Don't do that.
562 		 */
563 		(void) mdb_snprintf(tn2, sizeof (tn2), "enum %s", type);
564 
565 		if (mdb_ctf_lookup_by_name(tn2, &id) == 0) {
566 			(void) strcpy(type, tn2);
567 		} else if (mdb_ctf_lookup_by_name(type, &id) != 0) {
568 			mdb_warn("types '%s', '%s'", tn2, type);
569 			return (DCMD_ERR);
570 		}
571 	} else {
572 		if (mdb_ctf_lookup_by_name(type, &id) != 0) {
573 			mdb_warn("'%s'", type);
574 			return (DCMD_ERR);
575 		}
576 	}
577 
578 	/* resolve it, and make sure we're looking at an enumeration */
579 	if (mdb_ctf_type_resolve(id, &idr) == -1) {
580 		mdb_warn("unable to resolve '%s'", type);
581 		return (DCMD_ERR);
582 	}
583 	if (mdb_ctf_type_kind(idr) != CTF_K_ENUM) {
584 		mdb_warn("'%s': not an enumeration\n", type);
585 		return (DCMD_ERR);
586 	}
587 
588 	info.e_id = idr;
589 
590 	if (argc > 2)
591 		return (DCMD_USAGE);
592 
593 	if (argc == 2) {
594 		if (flags & DCMD_ADDRSPEC) {
595 			mdb_warn("may only specify one of: name, address\n");
596 			return (DCMD_USAGE);
597 		}
598 
599 		if (argv[1].a_type == MDB_TYPE_STRING) {
600 			info.e_flags |= E_SEARCH_STRING;
601 			info.e_string = argv[1].a_un.a_str;
602 		} else if (argv[1].a_type == MDB_TYPE_IMMEDIATE) {
603 			info.e_flags |= E_SEARCH_VALUE;
604 			search = argv[1].a_un.a_val;
605 		} else {
606 			return (DCMD_USAGE);
607 		}
608 	}
609 
610 	if (flags & DCMD_ADDRSPEC) {
611 		info.e_flags |= E_SEARCH_VALUE;
612 		search = mdb_get_dot();
613 	}
614 
615 	if (info.e_flags & E_SEARCH_VALUE) {
616 		if ((int)search != search) {
617 			mdb_warn("value '%lld' out of enumeration range\n",
618 			    search);
619 		}
620 		info.e_value = search;
621 	}
622 
623 	isp2 = enum_is_p2(idr);
624 	if (isp2)
625 		info.e_flags |= E_HEX;
626 
627 	if (DCMD_HDRSPEC(flags) && (info.e_flags & E_PRETTY)) {
628 		if (info.e_flags & E_HEX)
629 			mdb_printf("%<u>%8s %-64s%</u>\n", "VALUE", "NAME");
630 		else
631 			mdb_printf("%<u>%11s %-64s%</u>\n", "VALUE", "NAME");
632 	}
633 
634 	/* if the enum is a power-of-two one, process it that way */
635 	if ((info.e_flags & E_SEARCH_VALUE) && isp2) {
636 		enum_print(&info, NULL, info.e_value);
637 		return (DCMD_OK);
638 	}
639 
640 	prefix[0] = 0;
641 	if ((info.e_flags & E_ELIDE_PREFIX) &&
642 	    mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0)
643 		info.e_prefix = strlen(prefix);
644 
645 	if (mdb_ctf_enum_iter(idr, enum_cb, &info) == -1) {
646 		mdb_warn("cannot walk '%s' as enum", type);
647 		return (DCMD_ERR);
648 	}
649 
650 	if (info.e_found == 0 &&
651 	    (info.e_flags & (E_SEARCH_STRING | E_SEARCH_VALUE)) != 0) {
652 		if (info.e_flags & E_SEARCH_STRING)
653 			mdb_warn("name \"%s\" not in '%s'\n", info.e_string,
654 			    type);
655 		else
656 			mdb_warn("value %#lld not in '%s'\n", info.e_value,
657 			    type);
658 
659 		return (DCMD_ERR);
660 	}
661 
662 	return (DCMD_OK);
663 }
664 
665 static int
setup_vcb(const char * name,uintptr_t addr)666 setup_vcb(const char *name, uintptr_t addr)
667 {
668 	const char *p;
669 	mdb_var_t *v;
670 
671 	if ((v = mdb_nv_lookup(&mdb.m_nv, name)) == NULL) {
672 		if ((p = strbadid(name)) != NULL) {
673 			mdb_warn("'%c' may not be used in a variable "
674 			    "name\n", *p);
675 			return (DCMD_ABORT);
676 		}
677 
678 		if ((v = mdb_nv_insert(&mdb.m_nv, name, NULL, addr, 0)) == NULL)
679 			return (DCMD_ERR);
680 	} else {
681 		if (v->v_flags & MDB_NV_RDONLY) {
682 			mdb_warn("variable %s is read-only\n", name);
683 			return (DCMD_ABORT);
684 		}
685 	}
686 
687 	/*
688 	 * If there already exists a vcb for this variable, we may be
689 	 * calling the dcmd in a loop.  We only create a vcb for this
690 	 * variable on the first invocation.
691 	 */
692 	if (mdb_vcb_find(v, mdb.m_frame) == NULL)
693 		mdb_vcb_insert(mdb_vcb_create(v), mdb.m_frame);
694 
695 	return (0);
696 }
697 
698 /*ARGSUSED*/
699 int
cmd_list(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)700 cmd_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
701 {
702 	int offset;
703 	uintptr_t a, tmp;
704 	int ret;
705 
706 	if (!(flags & DCMD_ADDRSPEC) || argc == 0)
707 		return (DCMD_USAGE);
708 
709 	if (argv->a_type != MDB_TYPE_STRING) {
710 		/*
711 		 * We are being given a raw offset in lieu of a type and
712 		 * member; confirm the number of arguments and argument
713 		 * type.
714 		 */
715 		if (argc != 1 || argv->a_type != MDB_TYPE_IMMEDIATE)
716 			return (DCMD_USAGE);
717 
718 		offset = argv->a_un.a_val;
719 
720 		argv++;
721 		argc--;
722 
723 		if (offset % sizeof (uintptr_t)) {
724 			mdb_warn("offset must fall on a word boundary\n");
725 			return (DCMD_ABORT);
726 		}
727 	} else {
728 		const char *member;
729 		char buf[MDB_SYM_NAMLEN];
730 		int ret;
731 
732 		ret = args_to_typename(&argc, &argv, buf, sizeof (buf));
733 		if (ret != 0)
734 			return (ret);
735 
736 		argv++;
737 		argc--;
738 
739 		/*
740 		 * If we make it here, we were provided a type name. We should
741 		 * only continue if we still have arguments left (e.g. member
742 		 * name and potentially a variable name).
743 		 */
744 		if (argc == 0)
745 			return (DCMD_USAGE);
746 
747 		member = argv->a_un.a_str;
748 		offset = mdb_ctf_offsetof_by_name(buf, member);
749 		if (offset == -1)
750 			return (DCMD_ABORT);
751 
752 		argv++;
753 		argc--;
754 
755 		if (offset % (sizeof (uintptr_t)) != 0) {
756 			mdb_warn("%s is not a word-aligned member\n", member);
757 			return (DCMD_ABORT);
758 		}
759 	}
760 
761 	/*
762 	 * If we have any unchewed arguments, a variable name must be present.
763 	 */
764 	if (argc == 1) {
765 		if (argv->a_type != MDB_TYPE_STRING)
766 			return (DCMD_USAGE);
767 
768 		if ((ret = setup_vcb(argv->a_un.a_str, addr)) != 0)
769 			return (ret);
770 
771 	} else if (argc != 0) {
772 		return (DCMD_USAGE);
773 	}
774 
775 	a = addr;
776 
777 	do {
778 		mdb_printf("%lr\n", a);
779 
780 		if (mdb_vread(&tmp, sizeof (tmp), a + offset) == -1) {
781 			mdb_warn("failed to read next pointer from object %p",
782 			    a);
783 			return (DCMD_ERR);
784 		}
785 
786 		a = tmp;
787 	} while (a != addr && a != 0);
788 
789 	return (DCMD_OK);
790 }
791 
792 int
cmd_array(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)793 cmd_array(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
794 {
795 	mdb_ctf_id_t id;
796 	ssize_t elemsize = 0;
797 	char tn[MDB_SYM_NAMLEN];
798 	int ret, nelem = -1;
799 
800 	mdb_tgt_t *t = mdb.m_target;
801 	GElf_Sym sym;
802 	mdb_ctf_arinfo_t ar;
803 	mdb_syminfo_t s_info;
804 
805 	if (!(flags & DCMD_ADDRSPEC))
806 		return (DCMD_USAGE);
807 
808 	if (argc >= 2) {
809 		ret = args_to_typename(&argc, &argv, tn, sizeof (tn));
810 		if (ret != 0)
811 			return (ret);
812 
813 		if (argc == 1)	/* unquoted compound type without count */
814 			return (DCMD_USAGE);
815 
816 		if (mdb_ctf_lookup_by_name(tn, &id) != 0) {
817 			mdb_warn("failed to look up type %s", tn);
818 			return (DCMD_ABORT);
819 		}
820 
821 		if (argv[1].a_type == MDB_TYPE_IMMEDIATE)
822 			nelem = argv[1].a_un.a_val;
823 		else
824 			nelem = mdb_strtoull(argv[1].a_un.a_str);
825 
826 		elemsize = mdb_ctf_type_size(id);
827 	} else if (addr_to_sym(t, addr, tn, sizeof (tn), &sym, &s_info)
828 	    != NULL && mdb_ctf_lookup_by_symbol(&sym, &s_info, &id)
829 	    == 0 && mdb_ctf_type_kind(id) == CTF_K_ARRAY &&
830 	    mdb_ctf_array_info(id, &ar) != -1) {
831 		elemsize = mdb_ctf_type_size(id) / ar.mta_nelems;
832 		nelem = ar.mta_nelems;
833 	} else {
834 		mdb_warn("no symbol information for %a", addr);
835 		return (DCMD_ERR);
836 	}
837 
838 	if (argc == 3 || argc == 1) {
839 		if (argv[argc - 1].a_type != MDB_TYPE_STRING)
840 			return (DCMD_USAGE);
841 
842 		if ((ret = setup_vcb(argv[argc - 1].a_un.a_str, addr)) != 0)
843 			return (ret);
844 
845 	} else if (argc > 3) {
846 		return (DCMD_USAGE);
847 	}
848 
849 	for (; nelem > 0; nelem--) {
850 		mdb_printf("%lr\n", addr);
851 		addr = addr + elemsize;
852 	}
853 
854 	return (DCMD_OK);
855 }
856 
857 /*
858  * Print an integer bitfield in hexadecimal by reading the enclosing byte(s)
859  * and then shifting and masking the data in the lower bits of a uint64_t.
860  */
861 static int
print_bitfield(ulong_t off,printarg_t * pap,ctf_encoding_t * ep)862 print_bitfield(ulong_t off, printarg_t *pap, ctf_encoding_t *ep)
863 {
864 	mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
865 	size_t size = (ep->cte_bits + (NBBY - 1)) / NBBY;
866 	uint64_t mask = (1ULL << ep->cte_bits) - 1;
867 	uint64_t value = 0;
868 	uint8_t *buf = (uint8_t *)&value;
869 	uint8_t shift;
870 
871 	const char *format;
872 
873 	if (!(pap->pa_flags & PA_SHOWVAL))
874 		return (0);
875 
876 	if (ep->cte_bits > sizeof (value) * NBBY - 1) {
877 		mdb_printf("??? (invalid bitfield size %u)", ep->cte_bits);
878 		return (0);
879 	}
880 
881 	/*
882 	 * Our bitfield may stradle a byte boundary, if so, the calculation of
883 	 * size may not correctly capture that. However, off is relative to the
884 	 * entire bitfield, so we first have to make that relative to the byte.
885 	 */
886 	if ((off % 8) + ep->cte_bits > NBBY * size) {
887 		size++;
888 	}
889 
890 	if (size > sizeof (value)) {
891 		mdb_printf("??? (total bitfield too large after alignment");
892 	}
893 
894 	/*
895 	 * On big-endian machines, we need to adjust the buf pointer to refer
896 	 * to the lowest 'size' bytes in 'value', and we need shift based on
897 	 * the offset from the end of the data, not the offset of the start.
898 	 */
899 #ifdef _BIG_ENDIAN
900 	buf += sizeof (value) - size;
901 	off += ep->cte_bits;
902 #endif
903 
904 	if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, buf, size, addr) != size) {
905 		mdb_warn("failed to read %lu bytes at %llx",
906 		    (ulong_t)size, addr);
907 		return (1);
908 	}
909 
910 	shift = off % NBBY;
911 
912 	/*
913 	 * Offsets are counted from opposite ends on little- and
914 	 * big-endian machines.
915 	 */
916 #ifdef _BIG_ENDIAN
917 	shift = NBBY - shift;
918 #endif
919 
920 	/*
921 	 * If the bits we want do not begin on a byte boundary, shift the data
922 	 * right so that the value is in the lowest 'cte_bits' of 'value'.
923 	 */
924 	if (off % NBBY != 0)
925 		value >>= shift;
926 	value &= mask;
927 
928 	/*
929 	 * We default to printing signed bitfields as decimals,
930 	 * and unsigned bitfields in hexadecimal.  If they specify
931 	 * hexadecimal, we treat the field as unsigned.
932 	 */
933 	if ((pap->pa_flags & PA_INTHEX) ||
934 	    !(ep->cte_format & CTF_INT_SIGNED)) {
935 		format = (pap->pa_flags & PA_INTDEC)? "%#llu" : "%#llx";
936 	} else {
937 		int sshift = sizeof (value) * NBBY - ep->cte_bits;
938 
939 		/* sign-extend value, and print as a signed decimal */
940 		value = ((int64_t)value << sshift) >> sshift;
941 		format = "%#lld";
942 	}
943 	mdb_printf(format, value);
944 
945 	return (0);
946 }
947 
948 /*
949  * We want to print an escaped char as e.g. '\0'. We don't use mdb_fmt_print()
950  * as it won't get auto-wrap right here (although even now, we don't include any
951  * trailing comma).
952  */
953 static int
print_char_val(mdb_tgt_addr_t addr,printarg_t * pap)954 print_char_val(mdb_tgt_addr_t addr, printarg_t *pap)
955 {
956 	char cval;
957 	char *s;
958 
959 	if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &cval, 1, addr) != 1)
960 		return (1);
961 
962 	if (mdb.m_flags & MDB_FL_ADB)
963 		s = strchr2adb(&cval, 1);
964 	else
965 		s = strchr2esc(&cval, 1);
966 
967 	mdb_printf("'%s'", s);
968 	strfree(s);
969 	return (0);
970 }
971 
972 /*
973  * Print out a character or integer value.  We use some simple heuristics,
974  * described below, to determine the appropriate radix to use for output.
975  */
976 static int
print_int_val(const char * type,ctf_encoding_t * ep,ulong_t off,printarg_t * pap)977 print_int_val(const char *type, ctf_encoding_t *ep, ulong_t off,
978     printarg_t *pap)
979 {
980 	static const char *const sformat[] = { "%#d", "%#d", "%#d", "%#lld" };
981 	static const char *const uformat[] = { "%#u", "%#u", "%#u", "%#llu" };
982 	static const char *const xformat[] = { "%#x", "%#x", "%#x", "%#llx" };
983 
984 	mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
985 	const char *const *fsp;
986 	size_t size;
987 
988 	union {
989 		uint64_t i8;
990 		uint32_t i4;
991 		uint16_t i2;
992 		uint8_t i1;
993 		time_t t;
994 		ipaddr_t I;
995 	} u;
996 
997 	if (!(pap->pa_flags & PA_SHOWVAL))
998 		return (0);
999 
1000 	if (ep->cte_format & CTF_INT_VARARGS) {
1001 		mdb_printf("...\n");
1002 		return (0);
1003 	}
1004 
1005 	/*
1006 	 * If the size is not a power-of-two number of bytes in the range 1-8 or
1007 	 * power-of-two number starts in the middle of a byte then we assume it
1008 	 * is a bitfield and print it as such.
1009 	 */
1010 	size = ep->cte_bits / NBBY;
1011 	if (size > 8 || (ep->cte_bits % NBBY) != 0 || (size & (size - 1) ||
1012 	    (off % NBBY) != 0) != 0) {
1013 		return (print_bitfield(off, pap, ep));
1014 	}
1015 
1016 	if (IS_CHAR(*ep))
1017 		return (print_char_val(addr, pap));
1018 
1019 	if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, addr) != size) {
1020 		mdb_warn("failed to read %lu bytes at %llx",
1021 		    (ulong_t)size, addr);
1022 		return (1);
1023 	}
1024 
1025 	/*
1026 	 * We pretty-print some integer based types.  time_t values are
1027 	 * printed as a calendar date and time, and IPv4 addresses as human
1028 	 * readable dotted quads.
1029 	 */
1030 	if (!(pap->pa_flags & (PA_INTHEX | PA_INTDEC))) {
1031 		if (strcmp(type, "time_t") == 0 && u.t != 0) {
1032 			mdb_printf("%Y", u.t);
1033 			return (0);
1034 		}
1035 		if (strcmp(type, "ipaddr_t") == 0 ||
1036 		    strcmp(type, "in_addr_t") == 0) {
1037 			mdb_printf("%I", u.I);
1038 			return (0);
1039 		}
1040 	}
1041 
1042 	/*
1043 	 * The default format is hexadecimal.
1044 	 */
1045 	if (!(pap->pa_flags & PA_INTDEC))
1046 		fsp = xformat;
1047 	else if (ep->cte_format & CTF_INT_SIGNED)
1048 		fsp = sformat;
1049 	else
1050 		fsp = uformat;
1051 
1052 	switch (size) {
1053 	case sizeof (uint8_t):
1054 		mdb_printf(fsp[0], u.i1);
1055 		break;
1056 	case sizeof (uint16_t):
1057 		mdb_printf(fsp[1], u.i2);
1058 		break;
1059 	case sizeof (uint32_t):
1060 		mdb_printf(fsp[2], u.i4);
1061 		break;
1062 	case sizeof (uint64_t):
1063 		mdb_printf(fsp[3], u.i8);
1064 		break;
1065 	}
1066 	return (0);
1067 }
1068 
1069 /*ARGSUSED*/
1070 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)1071 print_int(const char *type, const char *name, mdb_ctf_id_t id,
1072     mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1073 {
1074 	ctf_encoding_t e;
1075 
1076 	if (!(pap->pa_flags & PA_SHOWVAL))
1077 		return (0);
1078 
1079 	if (mdb_ctf_type_encoding(base, &e) != 0) {
1080 		mdb_printf("??? (%s)", mdb_strerror(errno));
1081 		return (0);
1082 	}
1083 
1084 	return (print_int_val(type, &e, off, pap));
1085 }
1086 
1087 /*
1088  * Print out a floating point value.  We only provide support for floats in
1089  * the ANSI-C float, double, and long double formats.
1090  */
1091 /*ARGSUSED*/
1092 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)1093 print_float(const char *type, const char *name, mdb_ctf_id_t id,
1094     mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1095 {
1096 #ifndef _KMDB
1097 	mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1098 	ctf_encoding_t e;
1099 
1100 	union {
1101 		float f;
1102 		double d;
1103 		long double ld;
1104 	} u;
1105 
1106 	if (!(pap->pa_flags & PA_SHOWVAL))
1107 		return (0);
1108 
1109 	if (mdb_ctf_type_encoding(base, &e) == 0) {
1110 		if (e.cte_format == CTF_FP_SINGLE &&
1111 		    e.cte_bits == sizeof (float) * NBBY) {
1112 			if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.f,
1113 			    sizeof (u.f), addr) != sizeof (u.f)) {
1114 				mdb_warn("failed to read float at %llx", addr);
1115 				return (1);
1116 			}
1117 			mdb_printf("%s", doubletos(u.f, 7, 'e'));
1118 
1119 		} else if (e.cte_format == CTF_FP_DOUBLE &&
1120 		    e.cte_bits == sizeof (double) * NBBY) {
1121 			if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.d,
1122 			    sizeof (u.d), addr) != sizeof (u.d)) {
1123 				mdb_warn("failed to read float at %llx", addr);
1124 				return (1);
1125 			}
1126 			mdb_printf("%s", doubletos(u.d, 7, 'e'));
1127 
1128 		} else if (e.cte_format == CTF_FP_LDOUBLE &&
1129 		    e.cte_bits == sizeof (long double) * NBBY) {
1130 			if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.ld,
1131 			    sizeof (u.ld), addr) != sizeof (u.ld)) {
1132 				mdb_warn("failed to read float at %llx", addr);
1133 				return (1);
1134 			}
1135 			mdb_printf("%s", longdoubletos(&u.ld, 16, 'e'));
1136 
1137 		} else {
1138 			mdb_printf("??? (unsupported FP format %u / %u bits\n",
1139 			    e.cte_format, e.cte_bits);
1140 		}
1141 	} else
1142 		mdb_printf("??? (%s)", mdb_strerror(errno));
1143 #else
1144 	mdb_printf("<FLOAT>");
1145 #endif
1146 	return (0);
1147 }
1148 
1149 
1150 /*
1151  * Print out a pointer value as a symbol name + offset or a hexadecimal value.
1152  * If the pointer itself is a char *, we attempt to read a bit of the data
1153  * referenced by the pointer and display it if it is a printable ASCII string.
1154  */
1155 /*ARGSUSED*/
1156 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)1157 print_ptr(const char *type, const char *name, mdb_ctf_id_t id,
1158     mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1159 {
1160 	mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1161 	ctf_encoding_t e;
1162 	uintptr_t value;
1163 	char buf[256];
1164 	ssize_t len;
1165 
1166 	if (!(pap->pa_flags & PA_SHOWVAL))
1167 		return (0);
1168 
1169 	if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
1170 	    &value, sizeof (value), addr) != sizeof (value)) {
1171 		mdb_warn("failed to read %s pointer at %llx", name, addr);
1172 		return (1);
1173 	}
1174 
1175 	if (pap->pa_flags & PA_NOSYMBOLIC) {
1176 		mdb_printf("%#lx", value);
1177 		return (0);
1178 	}
1179 
1180 	mdb_printf("%a", value);
1181 
1182 	if (value == 0 || strcmp(type, "caddr_t") == 0)
1183 		return (0);
1184 
1185 	if (mdb_ctf_type_kind(base) == CTF_K_POINTER &&
1186 	    mdb_ctf_type_reference(base, &base) != -1 &&
1187 	    mdb_ctf_type_resolve(base, &base) != -1 &&
1188 	    mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e)) {
1189 		if ((len = mdb_tgt_readstr(pap->pa_realtgt, pap->pa_as,
1190 		    buf, sizeof (buf), value)) >= 0 && strisprint(buf)) {
1191 			if (len == sizeof (buf))
1192 				(void) strabbr(buf, sizeof (buf));
1193 			mdb_printf(" \"%s\"", buf);
1194 		}
1195 	}
1196 
1197 	return (0);
1198 }
1199 
1200 
1201 /*
1202  * Print out a fixed-size array.  We special-case arrays of characters
1203  * and attempt to print them out as ASCII strings if possible.  For other
1204  * arrays, we iterate over a maximum of pa_armemlim members and call
1205  * mdb_ctf_type_visit() again on each element to print its value.
1206  */
1207 /*ARGSUSED*/
1208 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)1209 print_array(const char *type, const char *name, mdb_ctf_id_t id,
1210     mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1211 {
1212 	mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1213 	printarg_t pa = *pap;
1214 	ssize_t eltsize;
1215 	mdb_ctf_arinfo_t r;
1216 	ctf_encoding_t e;
1217 	uint_t i, kind, limit;
1218 	int d, sou;
1219 	char buf[8];
1220 	char *str;
1221 
1222 	if (!(pap->pa_flags & PA_SHOWVAL))
1223 		return (0);
1224 
1225 	if (pap->pa_depth == pap->pa_maxdepth) {
1226 		mdb_printf("[ ... ]");
1227 		return (0);
1228 	}
1229 
1230 	/*
1231 	 * Determine the base type and size of the array's content.  If this
1232 	 * fails, we cannot print anything and just give up.
1233 	 */
1234 	if (mdb_ctf_array_info(base, &r) == -1 ||
1235 	    mdb_ctf_type_resolve(r.mta_contents, &base) == -1 ||
1236 	    (eltsize = mdb_ctf_type_size(base)) == -1) {
1237 		mdb_printf("[ ??? ] (%s)", mdb_strerror(errno));
1238 		return (0);
1239 	}
1240 
1241 	/*
1242 	 * Read a few bytes and determine if the content appears to be
1243 	 * printable ASCII characters.  If so, read the entire array and
1244 	 * attempt to display it as a string if it is printable.
1245 	 */
1246 	if ((pap->pa_arstrlim == MDB_ARR_NOLIMIT ||
1247 	    r.mta_nelems <= pap->pa_arstrlim) &&
1248 	    mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e) &&
1249 	    mdb_tgt_readstr(pap->pa_tgt, pap->pa_as, buf,
1250 	    MIN(sizeof (buf), r.mta_nelems), addr) > 0 && strisprint(buf)) {
1251 
1252 		str = mdb_alloc(r.mta_nelems + 1, UM_SLEEP | UM_GC);
1253 		str[r.mta_nelems] = '\0';
1254 
1255 		if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, str,
1256 		    r.mta_nelems, addr) != r.mta_nelems) {
1257 			mdb_warn("failed to read char array at %llx", addr);
1258 			return (1);
1259 		}
1260 
1261 		if (strisprint(str)) {
1262 			mdb_printf("[ \"%s\" ]", str);
1263 			return (0);
1264 		}
1265 	}
1266 
1267 	if (pap->pa_armemlim != MDB_ARR_NOLIMIT)
1268 		limit = MIN(r.mta_nelems, pap->pa_armemlim);
1269 	else
1270 		limit = r.mta_nelems;
1271 
1272 	if (limit == 0) {
1273 		mdb_printf("[ ... ]");
1274 		return (0);
1275 	}
1276 
1277 	kind = mdb_ctf_type_kind(base);
1278 	sou = IS_COMPOSITE(kind);
1279 
1280 	pa.pa_addr = addr;		/* set base address to start of array */
1281 	pa.pa_maxdepth = pa.pa_maxdepth - pa.pa_depth - 1;
1282 	pa.pa_nest += pa.pa_depth + 1;	/* nesting level is current depth + 1 */
1283 	pa.pa_depth = 0;		/* reset depth to 0 for new scope */
1284 	pa.pa_prefix = NULL;
1285 
1286 	if (sou) {
1287 		pa.pa_delim = "\n";
1288 		mdb_printf("[\n");
1289 	} else {
1290 		pa.pa_flags &= ~(PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR);
1291 		pa.pa_delim = ", ";
1292 		mdb_printf("[ ");
1293 	}
1294 
1295 	for (i = 0; i < limit; i++, pa.pa_addr += eltsize) {
1296 		if (i == limit - 1 && !sou) {
1297 			if (limit < r.mta_nelems)
1298 				pa.pa_delim = ", ... ]";
1299 			else
1300 				pa.pa_delim = " ]";
1301 		}
1302 
1303 		if (mdb_ctf_type_visit(r.mta_contents, elt_print, &pa) == -1) {
1304 			mdb_warn("failed to print array data");
1305 			return (1);
1306 		}
1307 	}
1308 
1309 	if (sou) {
1310 		for (d = pa.pa_depth - 1; d >= 0; d--)
1311 			print_close_sou(&pa, d);
1312 
1313 		if (limit < r.mta_nelems) {
1314 			mdb_printf("%*s... ]",
1315 			    (pap->pa_depth + pap->pa_nest) * pap->pa_tab, "");
1316 		} else {
1317 			mdb_printf("%*s]",
1318 			    (pap->pa_depth + pap->pa_nest) * pap->pa_tab, "");
1319 		}
1320 	}
1321 
1322 	/* copy the hole array info, since it may have been grown */
1323 	pap->pa_holes = pa.pa_holes;
1324 	pap->pa_nholes = pa.pa_nholes;
1325 
1326 	return (0);
1327 }
1328 
1329 /*
1330  * Print out a struct or union header.  We need only print the open brace
1331  * because mdb_ctf_type_visit() itself will automatically recurse through
1332  * all members of the given struct or union.
1333  */
1334 /*ARGSUSED*/
1335 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)1336 print_sou(const char *type, const char *name, mdb_ctf_id_t id,
1337     mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1338 {
1339 	mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1340 
1341 	/*
1342 	 * We have pretty-printing for some structures where displaying
1343 	 * structure contents has no value.
1344 	 */
1345 	if (pap->pa_flags & PA_SHOWVAL) {
1346 		if (strcmp(type, "in6_addr_t") == 0 ||
1347 		    strcmp(type, "struct in6_addr") == 0) {
1348 			in6_addr_t in6addr;
1349 
1350 			if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &in6addr,
1351 			    sizeof (in6addr), addr) != sizeof (in6addr)) {
1352 				mdb_warn("failed to read %s pointer at %llx",
1353 				    name, addr);
1354 				return (1);
1355 			}
1356 			mdb_printf("%N", &in6addr);
1357 			/*
1358 			 * Don't print anything further down in the
1359 			 * structure.
1360 			 */
1361 			pap->pa_nooutdepth = pap->pa_depth;
1362 			return (0);
1363 		}
1364 		if (strcmp(type, "struct in_addr") == 0) {
1365 			in_addr_t inaddr;
1366 
1367 			if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &inaddr,
1368 			    sizeof (inaddr), addr) != sizeof (inaddr)) {
1369 				mdb_warn("failed to read %s pointer at %llx",
1370 				    name, addr);
1371 				return (1);
1372 			}
1373 			mdb_printf("%I", inaddr);
1374 			pap->pa_nooutdepth = pap->pa_depth;
1375 			return (0);
1376 		}
1377 	}
1378 
1379 	if (pap->pa_depth == pap->pa_maxdepth)
1380 		mdb_printf("{ ... }");
1381 	else
1382 		mdb_printf("{");
1383 	pap->pa_delim = "\n";
1384 	return (0);
1385 }
1386 
1387 /*
1388  * Print an enum value.  We attempt to convert the value to the corresponding
1389  * enum name and print that if possible.
1390  */
1391 /*ARGSUSED*/
1392 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)1393 print_enum(const char *type, const char *name, mdb_ctf_id_t id,
1394     mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1395 {
1396 	mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1397 	const char *ename;
1398 	int value;
1399 	int isp2 = enum_is_p2(base);
1400 	int flags = pap->pa_flags | (isp2 ? PA_INTHEX : 0);
1401 
1402 	if (!(flags & PA_SHOWVAL))
1403 		return (0);
1404 
1405 	if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
1406 	    &value, sizeof (value), addr) != sizeof (value)) {
1407 		mdb_warn("failed to read %s integer at %llx", name, addr);
1408 		return (1);
1409 	}
1410 
1411 	if (flags & PA_INTHEX)
1412 		mdb_printf("%#x", value);
1413 	else
1414 		mdb_printf("%#d", value);
1415 
1416 	(void) mdb_inc_indent(8);
1417 	mdb_printf(" (");
1418 
1419 	if (!isp2 || enum_value_print_p2(base, value, 0) != 0) {
1420 		ename = mdb_ctf_enum_name(base, value);
1421 		if (ename == NULL) {
1422 			ename = "???";
1423 		}
1424 		mdb_printf("%s", ename);
1425 	}
1426 	mdb_printf(")");
1427 	(void) mdb_dec_indent(8);
1428 
1429 	return (0);
1430 }
1431 
1432 /*
1433  * This will only get called if the structure isn't found in any available CTF
1434  * data.
1435  */
1436 /*ARGSUSED*/
1437 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)1438 print_tag(const char *type, const char *name, mdb_ctf_id_t id,
1439     mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1440 {
1441 	char basename[MDB_SYM_NAMLEN];
1442 
1443 	if (pap->pa_flags & PA_SHOWVAL)
1444 		mdb_printf("; ");
1445 
1446 	if (mdb_ctf_type_name(base, basename, sizeof (basename)) != NULL)
1447 		mdb_printf("<forward declaration of %s>", basename);
1448 	else
1449 		mdb_printf("<forward declaration of unknown type>");
1450 
1451 	return (0);
1452 }
1453 
1454 static void
print_hole(printarg_t * pap,int depth,ulong_t off,ulong_t endoff)1455 print_hole(printarg_t *pap, int depth, ulong_t off, ulong_t endoff)
1456 {
1457 	ulong_t bits = endoff - off;
1458 	ulong_t size = bits / NBBY;
1459 	ctf_encoding_t e;
1460 
1461 	static const char *const name = "<<HOLE>>";
1462 	char type[MDB_SYM_NAMLEN];
1463 
1464 	int bitfield =
1465 	    (off % NBBY != 0 ||
1466 	    bits % NBBY != 0 ||
1467 	    size > 8 ||
1468 	    (size & (size - 1)) != 0);
1469 
1470 	ASSERT(off < endoff);
1471 
1472 	if (bits > NBBY * sizeof (uint64_t)) {
1473 		ulong_t end;
1474 
1475 		/*
1476 		 * The hole is larger than the largest integer type.  To
1477 		 * handle this, we split up the hole at 8-byte-aligned
1478 		 * boundaries, recursing to print each subsection.  For
1479 		 * normal C structures, we'll loop at most twice.
1480 		 */
1481 		for (; off < endoff; off = end) {
1482 			end = P2END(off, NBBY * sizeof (uint64_t));
1483 			if (end > endoff)
1484 				end = endoff;
1485 
1486 			ASSERT((end - off) <= NBBY * sizeof (uint64_t));
1487 			print_hole(pap, depth, off, end);
1488 		}
1489 		ASSERT(end == endoff);
1490 
1491 		return;
1492 	}
1493 
1494 	if (bitfield)
1495 		(void) mdb_snprintf(type, sizeof (type), "unsigned");
1496 	else
1497 		(void) mdb_snprintf(type, sizeof (type), "uint%d_t", bits);
1498 
1499 	if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR))
1500 		mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, "");
1501 
1502 	if (pap->pa_flags & PA_SHOWADDR) {
1503 		if (off % NBBY == 0)
1504 			mdb_printf("%llx ", pap->pa_addr + off / NBBY);
1505 		else
1506 			mdb_printf("%llx.%lx ",
1507 			    pap->pa_addr + off / NBBY, off % NBBY);
1508 	}
1509 
1510 	if (pap->pa_flags & PA_SHOWTYPE)
1511 		mdb_printf("%s ", type);
1512 
1513 	if (pap->pa_flags & PA_SHOWNAME)
1514 		mdb_printf("%s", name);
1515 
1516 	if (bitfield && (pap->pa_flags & PA_SHOWTYPE))
1517 		mdb_printf(" :%d", bits);
1518 
1519 	mdb_printf("%s ", (pap->pa_flags & PA_SHOWVAL)? " =" : "");
1520 
1521 	/*
1522 	 * We fake up a ctf_encoding_t, and use print_int_val() to print
1523 	 * the value.  Holes are always processed as unsigned integers.
1524 	 */
1525 	bzero(&e, sizeof (e));
1526 	e.cte_format = 0;
1527 	e.cte_offset = 0;
1528 	e.cte_bits = bits;
1529 
1530 	if (print_int_val(type, &e, off, pap) != 0)
1531 		mdb_iob_discard(mdb.m_out);
1532 	else
1533 		mdb_iob_puts(mdb.m_out, pap->pa_delim);
1534 }
1535 
1536 /*
1537  * The print_close_sou() function is called for each structure or union
1538  * which has been completed.  For structures, we detect and print any holes
1539  * before printing the closing brace.
1540  */
1541 static void
print_close_sou(printarg_t * pap,int newdepth)1542 print_close_sou(printarg_t *pap, int newdepth)
1543 {
1544 	int d = newdepth + pap->pa_nest;
1545 
1546 	if ((pap->pa_flags & PA_SHOWHOLES) && !pap->pa_holes[d].hi_isunion) {
1547 		ulong_t end = pap->pa_holes[d + 1].hi_offset;
1548 		ulong_t expected = pap->pa_holes[d].hi_offset;
1549 
1550 		if (end < expected)
1551 			print_hole(pap, newdepth + 1, end, expected);
1552 	}
1553 	/* if the struct is an array element, print a comma after the } */
1554 	mdb_printf("%*s}%s\n", d * pap->pa_tab, "",
1555 	    (newdepth == 0 && pap->pa_nest > 0)? "," : "");
1556 }
1557 
1558 static printarg_f *const printfuncs[] = {
1559 	print_int,	/* CTF_K_INTEGER */
1560 	print_float,	/* CTF_K_FLOAT */
1561 	print_ptr,	/* CTF_K_POINTER */
1562 	print_array,	/* CTF_K_ARRAY */
1563 	print_ptr,	/* CTF_K_FUNCTION */
1564 	print_sou,	/* CTF_K_STRUCT */
1565 	print_sou,	/* CTF_K_UNION */
1566 	print_enum,	/* CTF_K_ENUM */
1567 	print_tag	/* CTF_K_FORWARD */
1568 };
1569 
1570 /*
1571  * The elt_print function is used as the mdb_ctf_type_visit callback.  For
1572  * each element, we print an appropriate name prefix and then call the
1573  * print subroutine for this type class in the array above.
1574  */
1575 static int
elt_print(const char * name,mdb_ctf_id_t id,mdb_ctf_id_t base,ulong_t off,int depth,void * data)1576 elt_print(const char *name, mdb_ctf_id_t id, mdb_ctf_id_t base,
1577     ulong_t off, int depth, void *data)
1578 {
1579 	char type[MDB_SYM_NAMLEN + sizeof (" <<12345678...>>")];
1580 	int kind, rc, d;
1581 	printarg_t *pap = data;
1582 
1583 	for (d = pap->pa_depth - 1; d >= depth; d--) {
1584 		if (d < pap->pa_nooutdepth)
1585 			print_close_sou(pap, d);
1586 	}
1587 
1588 	/*
1589 	 * Reset pa_nooutdepth if we've come back out of the structure we
1590 	 * didn't want to print.
1591 	 */
1592 	if (depth <= pap->pa_nooutdepth)
1593 		pap->pa_nooutdepth = (uint_t)-1;
1594 
1595 	if (depth > pap->pa_maxdepth || depth > pap->pa_nooutdepth)
1596 		return (0);
1597 
1598 	if (!mdb_ctf_type_valid(base) ||
1599 	    (kind = mdb_ctf_type_kind(base)) == -1)
1600 		return (-1); /* errno is set for us */
1601 
1602 	if (mdb_ctf_type_name(id, type, MDB_SYM_NAMLEN) == NULL)
1603 		(void) strcpy(type, "(?)");
1604 
1605 	if (pap->pa_flags & PA_SHOWBASETYPE) {
1606 		/*
1607 		 * If basetype is different and informative, concatenate
1608 		 * <<basetype>> (or <<baset...>> if it doesn't fit)
1609 		 *
1610 		 * We just use the end of the buffer to store the type name, and
1611 		 * only connect it up if that's necessary.
1612 		 */
1613 
1614 		char *type_end = type + strlen(type);
1615 		char *basetype;
1616 		size_t sz;
1617 
1618 		(void) strlcat(type, " <<", sizeof (type));
1619 
1620 		basetype = type + strlen(type);
1621 		sz = sizeof (type) - (basetype - type);
1622 
1623 		*type_end = '\0'; /* restore the end of type for strcmp() */
1624 
1625 		if (mdb_ctf_type_name(base, basetype, sz) != NULL &&
1626 		    strcmp(basetype, type) != 0 &&
1627 		    strcmp(basetype, "struct ") != 0 &&
1628 		    strcmp(basetype, "enum ") != 0 &&
1629 		    strcmp(basetype, "union ") != 0) {
1630 			type_end[0] = ' ';	/* reconnect */
1631 			if (strlcat(type, ">>", sizeof (type)) >= sizeof (type))
1632 				(void) strlcpy(
1633 				    type + sizeof (type) - 6, "...>>", 6);
1634 		}
1635 	}
1636 
1637 	if (pap->pa_flags & PA_SHOWHOLES) {
1638 		ctf_encoding_t e;
1639 		ssize_t nsize;
1640 		ulong_t newoff;
1641 		holeinfo_t *hole;
1642 		int extra = IS_COMPOSITE(kind)? 1 : 0;
1643 
1644 		/*
1645 		 * grow the hole array, if necessary
1646 		 */
1647 		if (pap->pa_nest + depth + extra >= pap->pa_nholes) {
1648 			int new = MAX(MAX(8, pap->pa_nholes * 2),
1649 			    pap->pa_nest + depth + extra + 1);
1650 
1651 			holeinfo_t *nhi = mdb_zalloc(
1652 			    sizeof (*nhi) * new, UM_NOSLEEP | UM_GC);
1653 
1654 			bcopy(pap->pa_holes, nhi,
1655 			    pap->pa_nholes * sizeof (*nhi));
1656 
1657 			pap->pa_holes = nhi;
1658 			pap->pa_nholes = new;
1659 		}
1660 
1661 		hole = &pap->pa_holes[depth + pap->pa_nest];
1662 
1663 		if (depth != 0 && off > hole->hi_offset)
1664 			print_hole(pap, depth, hole->hi_offset, off);
1665 
1666 		/* compute the next expected offset */
1667 		if (kind == CTF_K_INTEGER &&
1668 		    mdb_ctf_type_encoding(base, &e) == 0)
1669 			newoff = off + e.cte_bits;
1670 		else if ((nsize = mdb_ctf_type_size(base)) >= 0)
1671 			newoff = off + nsize * NBBY;
1672 		else {
1673 			/* something bad happened, disable hole checking */
1674 			newoff = -1UL;		/* ULONG_MAX */
1675 		}
1676 
1677 		hole->hi_offset = newoff;
1678 
1679 		if (IS_COMPOSITE(kind)) {
1680 			hole->hi_isunion = (kind == CTF_K_UNION);
1681 			hole++;
1682 			hole->hi_offset = off;
1683 		}
1684 	}
1685 
1686 	if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR))
1687 		mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, "");
1688 
1689 	if (pap->pa_flags & PA_SHOWADDR) {
1690 		if (off % NBBY == 0)
1691 			mdb_printf("%llx ", pap->pa_addr + off / NBBY);
1692 		else
1693 			mdb_printf("%llx.%lx ",
1694 			    pap->pa_addr + off / NBBY, off % NBBY);
1695 	}
1696 
1697 	if ((pap->pa_flags & PA_SHOWTYPE)) {
1698 		mdb_printf("%s", type);
1699 		/*
1700 		 * We want to avoid printing a trailing space when
1701 		 * dealing with pointers in a structure, so we end
1702 		 * up with:
1703 		 *
1704 		 *	label_t *t_onfault = 0
1705 		 *
1706 		 * If depth is zero, always print the trailing space unless
1707 		 * we also have a prefix.
1708 		 */
1709 		if (type[strlen(type) - 1] != '*' ||
1710 		    (depth == 0 && (!(pap->pa_flags & PA_SHOWNAME) ||
1711 		    pap->pa_prefix == NULL)))
1712 			mdb_printf(" ");
1713 	}
1714 
1715 	if (pap->pa_flags & PA_SHOWNAME) {
1716 		if (pap->pa_prefix != NULL && depth <= 1)
1717 			mdb_printf("%s%s", pap->pa_prefix,
1718 			    (depth == 0) ? "" : pap->pa_suffix);
1719 		mdb_printf("%s", name);
1720 	}
1721 
1722 	if ((pap->pa_flags & PA_SHOWTYPE) && kind == CTF_K_INTEGER) {
1723 		ctf_encoding_t e;
1724 
1725 		if (mdb_ctf_type_encoding(base, &e) == 0) {
1726 			ulong_t bits = e.cte_bits;
1727 			ulong_t size = bits / NBBY;
1728 
1729 			if (bits % NBBY != 0 ||
1730 			    off % NBBY != 0 ||
1731 			    size > 8 ||
1732 			    size != mdb_ctf_type_size(base))
1733 				mdb_printf(" :%d", bits);
1734 		}
1735 	}
1736 
1737 	if (depth != 0 ||
1738 	    ((pap->pa_flags & PA_SHOWNAME) && pap->pa_prefix != NULL))
1739 		mdb_printf("%s ", pap->pa_flags & PA_SHOWVAL ? " =" : "");
1740 
1741 	if (depth == 0 && pap->pa_prefix != NULL)
1742 		name = pap->pa_prefix;
1743 
1744 	pap->pa_depth = depth;
1745 	if (kind <= CTF_K_UNKNOWN || kind >= CTF_K_TYPEDEF) {
1746 		mdb_warn("unknown ctf for %s type %s kind %d\n",
1747 		    name, type, kind);
1748 		return (-1);
1749 	}
1750 	rc = printfuncs[kind - 1](type, name, id, base, off, pap);
1751 
1752 	if (rc != 0)
1753 		mdb_iob_discard(mdb.m_out);
1754 	else
1755 		mdb_iob_puts(mdb.m_out, pap->pa_delim);
1756 
1757 	return (rc);
1758 }
1759 
1760 /*
1761  * Special semantics for pipelines.
1762  */
1763 static int
pipe_print(mdb_ctf_id_t id,ulong_t off,void * data)1764 pipe_print(mdb_ctf_id_t id, ulong_t off, void *data)
1765 {
1766 	printarg_t *pap = data;
1767 	ssize_t size;
1768 	static const char *const fsp[] = { "%#r", "%#r", "%#r", "%#llr" };
1769 	uintptr_t value;
1770 	uintptr_t addr = pap->pa_addr + off / NBBY;
1771 	mdb_ctf_id_t base;
1772 	int enum_value;
1773 	ctf_encoding_t e;
1774 
1775 	union {
1776 		uint64_t i8;
1777 		uint32_t i4;
1778 		uint16_t i2;
1779 		uint8_t i1;
1780 	} u;
1781 
1782 	if (mdb_ctf_type_resolve(id, &base) == -1) {
1783 		mdb_warn("could not resolve type");
1784 		return (-1);
1785 	}
1786 
1787 	/*
1788 	 * If the user gives -a, then always print out the address of the
1789 	 * member.
1790 	 */
1791 	if ((pap->pa_flags & PA_SHOWADDR)) {
1792 		mdb_printf("%#lr\n", addr);
1793 		return (0);
1794 	}
1795 
1796 again:
1797 	switch (mdb_ctf_type_kind(base)) {
1798 	case CTF_K_POINTER:
1799 		if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
1800 		    &value, sizeof (value), addr) != sizeof (value)) {
1801 			mdb_warn("failed to read pointer at %p", addr);
1802 			return (-1);
1803 		}
1804 		mdb_printf("%#lr\n", value);
1805 		break;
1806 
1807 	case CTF_K_ENUM:
1808 		if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &enum_value,
1809 		    sizeof (enum_value), addr) != sizeof (enum_value)) {
1810 			mdb_warn("failed to read enum at %llx", addr);
1811 			return (-1);
1812 		}
1813 		mdb_printf("%#r\n", enum_value);
1814 		break;
1815 
1816 	case CTF_K_INTEGER:
1817 		if (mdb_ctf_type_encoding(base, &e) != 0) {
1818 			mdb_warn("could not get type encoding\n");
1819 			return (-1);
1820 		}
1821 
1822 		/*
1823 		 * For immediate values, we just print out the value.
1824 		 */
1825 		size = e.cte_bits / NBBY;
1826 		if (size > 8 || (e.cte_bits % NBBY) != 0 ||
1827 		    (size & (size - 1)) != 0) {
1828 			return (print_bitfield(off, pap, &e));
1829 		}
1830 
1831 		if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size,
1832 		    addr) != size) {
1833 			mdb_warn("failed to read %lu bytes at %p",
1834 			    (ulong_t)size, pap->pa_addr);
1835 			return (-1);
1836 		}
1837 
1838 		switch (size) {
1839 		case sizeof (uint8_t):
1840 			mdb_printf(fsp[0], u.i1);
1841 			break;
1842 		case sizeof (uint16_t):
1843 			mdb_printf(fsp[1], u.i2);
1844 			break;
1845 		case sizeof (uint32_t):
1846 			mdb_printf(fsp[2], u.i4);
1847 			break;
1848 		case sizeof (uint64_t):
1849 			mdb_printf(fsp[3], u.i8);
1850 			break;
1851 		}
1852 		mdb_printf("\n");
1853 		break;
1854 
1855 	case CTF_K_FUNCTION:
1856 	case CTF_K_FLOAT:
1857 	case CTF_K_ARRAY:
1858 	case CTF_K_UNKNOWN:
1859 	case CTF_K_STRUCT:
1860 	case CTF_K_UNION:
1861 	case CTF_K_FORWARD:
1862 		/*
1863 		 * For these types, always print the address of the member
1864 		 */
1865 		mdb_printf("%#lr\n", addr);
1866 		break;
1867 
1868 	default:
1869 		mdb_warn("unknown type %d", mdb_ctf_type_kind(base));
1870 		break;
1871 	}
1872 
1873 	return (0);
1874 }
1875 
1876 static int
parse_delimiter(char ** strp)1877 parse_delimiter(char **strp)
1878 {
1879 	switch (**strp) {
1880 	case '\0':
1881 		return (MEMBER_DELIM_DONE);
1882 
1883 	case '.':
1884 		*strp = *strp + 1;
1885 		return (MEMBER_DELIM_DOT);
1886 
1887 	case '[':
1888 		*strp = *strp + 1;
1889 		return (MEMBER_DELIM_LBR);
1890 
1891 	case '-':
1892 		*strp = *strp + 1;
1893 		if (**strp == '>') {
1894 			*strp = *strp + 1;
1895 			return (MEMBER_DELIM_PTR);
1896 		}
1897 		*strp = *strp - 1;
1898 		/*FALLTHROUGH*/
1899 	default:
1900 		return (MEMBER_DELIM_ERR);
1901 	}
1902 }
1903 
1904 static int
deref(printarg_t * pap,size_t size)1905 deref(printarg_t *pap, size_t size)
1906 {
1907 	uint32_t a32;
1908 	mdb_tgt_as_t as = pap->pa_as;
1909 	mdb_tgt_addr_t *ap = &pap->pa_addr;
1910 
1911 	if (size == sizeof (mdb_tgt_addr_t)) {
1912 		if (mdb_tgt_aread(mdb.m_target, as, ap, size, *ap) == -1) {
1913 			mdb_warn("could not dereference pointer %llx\n", *ap);
1914 			return (-1);
1915 		}
1916 	} else {
1917 		if (mdb_tgt_aread(mdb.m_target, as, &a32, size, *ap) == -1) {
1918 			mdb_warn("could not dereference pointer %x\n", *ap);
1919 			return (-1);
1920 		}
1921 
1922 		*ap = (mdb_tgt_addr_t)a32;
1923 	}
1924 
1925 	/*
1926 	 * We've dereferenced at least once, we must be on the real
1927 	 * target. If we were in the immediate target, reset to the real
1928 	 * target; it's reset as needed when we return to the print
1929 	 * routines.
1930 	 */
1931 	if (pap->pa_tgt == pap->pa_immtgt)
1932 		pap->pa_tgt = pap->pa_realtgt;
1933 
1934 	return (0);
1935 }
1936 
1937 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)1938 parse_member(printarg_t *pap, const char *str, mdb_ctf_id_t id,
1939     mdb_ctf_id_t *idp, ulong_t *offp, int *last_deref)
1940 {
1941 	int delim;
1942 	char member[64];
1943 	char buf[128];
1944 	uint_t index;
1945 	char *start = (char *)str;
1946 	char *end;
1947 	ulong_t off = 0;
1948 	mdb_ctf_arinfo_t ar;
1949 	mdb_ctf_id_t rid;
1950 	int kind;
1951 	ssize_t size;
1952 	int non_array = FALSE;
1953 
1954 	/*
1955 	 * id always has the unresolved type for printing error messages
1956 	 * that include the type; rid always has the resolved type for
1957 	 * use in mdb_ctf_* calls.  It is possible for this command to fail,
1958 	 * however, if the resolved type is in the parent and it is currently
1959 	 * unavailable.  Note that we also can't print out the name of the
1960 	 * type, since that would also rely on looking up the resolved name.
1961 	 */
1962 	if (mdb_ctf_type_resolve(id, &rid) != 0) {
1963 		mdb_warn("failed to resolve type");
1964 		return (-1);
1965 	}
1966 
1967 	delim = parse_delimiter(&start);
1968 	/*
1969 	 * If the user fails to specify an initial delimiter, guess -> for
1970 	 * pointer types and . for non-pointer types.
1971 	 */
1972 	if (delim == MEMBER_DELIM_ERR)
1973 		delim = (mdb_ctf_type_kind(rid) == CTF_K_POINTER) ?
1974 		    MEMBER_DELIM_PTR : MEMBER_DELIM_DOT;
1975 
1976 	*last_deref = FALSE;
1977 
1978 	while (delim != MEMBER_DELIM_DONE) {
1979 		switch (delim) {
1980 		case MEMBER_DELIM_PTR:
1981 			kind = mdb_ctf_type_kind(rid);
1982 			if (kind != CTF_K_POINTER) {
1983 				mdb_warn("%s is not a pointer type\n",
1984 				    mdb_ctf_type_name(id, buf, sizeof (buf)));
1985 				return (-1);
1986 			}
1987 
1988 			size = mdb_ctf_type_size(id);
1989 			if (deref(pap, size) != 0)
1990 				return (-1);
1991 
1992 			(void) mdb_ctf_type_reference(rid, &id);
1993 			(void) mdb_ctf_type_resolve(id, &rid);
1994 
1995 			off = 0;
1996 			break;
1997 
1998 		case MEMBER_DELIM_DOT:
1999 			kind = mdb_ctf_type_kind(rid);
2000 			if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
2001 				mdb_warn("%s is not a struct or union type\n",
2002 				    mdb_ctf_type_name(id, buf, sizeof (buf)));
2003 				return (-1);
2004 			}
2005 			break;
2006 
2007 		case MEMBER_DELIM_LBR:
2008 			end = strchr(start, ']');
2009 			if (end == NULL) {
2010 				mdb_warn("no trailing ']'\n");
2011 				return (-1);
2012 			}
2013 
2014 			(void) mdb_snprintf(member, end - start + 1, "%s",
2015 			    start);
2016 
2017 			index = mdb_strtoull(member);
2018 
2019 			switch (mdb_ctf_type_kind(rid)) {
2020 			case CTF_K_POINTER:
2021 				size = mdb_ctf_type_size(rid);
2022 
2023 				if (deref(pap, size) != 0)
2024 					return (-1);
2025 
2026 				(void) mdb_ctf_type_reference(rid, &id);
2027 				(void) mdb_ctf_type_resolve(id, &rid);
2028 
2029 				size = mdb_ctf_type_size(id);
2030 				if (size <= 0) {
2031 					mdb_warn("cannot dereference void "
2032 					    "type\n");
2033 					return (-1);
2034 				}
2035 
2036 				pap->pa_addr += index * size;
2037 				off = 0;
2038 
2039 				if (index == 0 && non_array)
2040 					*last_deref = TRUE;
2041 				break;
2042 
2043 			case CTF_K_ARRAY:
2044 				(void) mdb_ctf_array_info(rid, &ar);
2045 
2046 				if (index >= ar.mta_nelems) {
2047 					mdb_warn("index %r is outside of "
2048 					    "array bounds [0 .. %r]\n",
2049 					    index, ar.mta_nelems - 1);
2050 				}
2051 
2052 				id = ar.mta_contents;
2053 				(void) mdb_ctf_type_resolve(id, &rid);
2054 
2055 				size = mdb_ctf_type_size(id);
2056 				if (size <= 0) {
2057 					mdb_warn("cannot dereference void "
2058 					    "type\n");
2059 					return (-1);
2060 				}
2061 
2062 				pap->pa_addr += index * size;
2063 				off = 0;
2064 				break;
2065 
2066 			default:
2067 				mdb_warn("cannot index into non-array, "
2068 				    "non-pointer type\n");
2069 				return (-1);
2070 			}
2071 
2072 			start = end + 1;
2073 			delim = parse_delimiter(&start);
2074 			continue;
2075 
2076 		case MEMBER_DELIM_ERR:
2077 		default:
2078 			mdb_warn("'%c' is not a valid delimiter\n", *start);
2079 			return (-1);
2080 		}
2081 
2082 		*last_deref = FALSE;
2083 		non_array = TRUE;
2084 
2085 		/*
2086 		 * Find the end of the member name; assume that a member
2087 		 * name is at least one character long.
2088 		 */
2089 		for (end = start + 1; isalnum(*end) || *end == '_'; end++)
2090 			continue;
2091 
2092 		(void) mdb_snprintf(member, end - start + 1, "%s", start);
2093 
2094 		if (mdb_ctf_member_info(rid, member, &off, &id) != 0) {
2095 			mdb_warn("failed to find member %s of %s", member,
2096 			    mdb_ctf_type_name(id, buf, sizeof (buf)));
2097 			return (-1);
2098 		}
2099 		(void) mdb_ctf_type_resolve(id, &rid);
2100 
2101 		pap->pa_addr += off / NBBY;
2102 
2103 		start = end;
2104 		delim = parse_delimiter(&start);
2105 	}
2106 
2107 	*idp = id;
2108 	*offp = off;
2109 
2110 	return (0);
2111 }
2112 
2113 static int
cmd_print_tab_common(mdb_tab_cookie_t * mcp,uint_t flags,int argc,const mdb_arg_t * argv)2114 cmd_print_tab_common(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
2115     const mdb_arg_t *argv)
2116 {
2117 	char tn[MDB_SYM_NAMLEN];
2118 	char member[64];
2119 	int delim, kind;
2120 	int ret = 0;
2121 	mdb_ctf_id_t id, rid;
2122 	mdb_ctf_arinfo_t ar;
2123 	char *start, *end;
2124 	ulong_t dul;
2125 
2126 	if (argc == 0 && !(flags & DCMD_TAB_SPACE))
2127 		return (0);
2128 
2129 	if (argc == 0 && (flags & DCMD_TAB_SPACE))
2130 		return (mdb_tab_complete_type(mcp, NULL, MDB_TABC_NOPOINT |
2131 		    MDB_TABC_NOARRAY));
2132 
2133 	if ((ret = mdb_tab_typename(&argc, &argv, tn, sizeof (tn))) < 0)
2134 		return (ret);
2135 
2136 	if (argc == 1 && (!(flags & DCMD_TAB_SPACE) || ret == 1))
2137 		return (mdb_tab_complete_type(mcp, tn, MDB_TABC_NOPOINT |
2138 		    MDB_TABC_NOARRAY));
2139 
2140 	if (argc == 1 && (flags & DCMD_TAB_SPACE))
2141 		return (mdb_tab_complete_member(mcp, tn, NULL));
2142 
2143 	/*
2144 	 * This is the reason that tab completion was created. We're going to go
2145 	 * along and walk the delimiters until we find something a member that
2146 	 * we don't recognize, at which point we'll try and tab complete it.
2147 	 * Note that ::print takes multiple args, so this is going to operate on
2148 	 * whatever the last arg that we have is.
2149 	 */
2150 	if (mdb_ctf_lookup_by_name(tn, &id) != 0)
2151 		return (1);
2152 
2153 	(void) mdb_ctf_type_resolve(id, &rid);
2154 	start = (char *)argv[argc-1].a_un.a_str;
2155 	delim = parse_delimiter(&start);
2156 
2157 	/*
2158 	 * If we hit the case where we actually have no delimiters, than we need
2159 	 * to make sure that we properly set up the fields the loops would.
2160 	 */
2161 	if (delim == MEMBER_DELIM_DONE)
2162 		(void) mdb_snprintf(member, sizeof (member), "%s", start);
2163 
2164 	while (delim != MEMBER_DELIM_DONE) {
2165 		switch (delim) {
2166 		case MEMBER_DELIM_PTR:
2167 			kind = mdb_ctf_type_kind(rid);
2168 			if (kind != CTF_K_POINTER)
2169 				return (1);
2170 
2171 			(void) mdb_ctf_type_reference(rid, &id);
2172 			(void) mdb_ctf_type_resolve(id, &rid);
2173 			break;
2174 		case MEMBER_DELIM_DOT:
2175 			kind = mdb_ctf_type_kind(rid);
2176 			if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
2177 				return (1);
2178 			break;
2179 		case MEMBER_DELIM_LBR:
2180 			end = strchr(start, ']');
2181 			/*
2182 			 * We're not going to try and tab complete the indexes
2183 			 * here. So for now, punt on it. Also, we're not going
2184 			 * to try and validate you're within the bounds, just
2185 			 * that you get the type you asked for.
2186 			 */
2187 			if (end == NULL)
2188 				return (1);
2189 
2190 			switch (mdb_ctf_type_kind(rid)) {
2191 			case CTF_K_POINTER:
2192 				(void) mdb_ctf_type_reference(rid, &id);
2193 				(void) mdb_ctf_type_resolve(id, &rid);
2194 				break;
2195 			case CTF_K_ARRAY:
2196 				(void) mdb_ctf_array_info(rid, &ar);
2197 				id = ar.mta_contents;
2198 				(void) mdb_ctf_type_resolve(id, &rid);
2199 				break;
2200 			default:
2201 				return (1);
2202 			}
2203 
2204 			start = end + 1;
2205 			delim = parse_delimiter(&start);
2206 			break;
2207 		case MEMBER_DELIM_ERR:
2208 		default:
2209 			break;
2210 		}
2211 
2212 		for (end = start + 1; isalnum(*end) || *end == '_'; end++)
2213 			continue;
2214 
2215 		(void) mdb_snprintf(member, end - start + 1, start);
2216 
2217 		/*
2218 		 * We are going to try to resolve this name as a member. There
2219 		 * are a few two different questions that we need to answer. The
2220 		 * first is do we recognize this member. The second is are we at
2221 		 * the end of the string. If we encounter a member that we don't
2222 		 * recognize before the end, then we have to error out and can't
2223 		 * complete it. But if there are no more delimiters then we can
2224 		 * try and complete it.
2225 		 */
2226 		ret = mdb_ctf_member_info(rid, member, &dul, &id);
2227 		start = end;
2228 		delim = parse_delimiter(&start);
2229 		if (ret != 0 && errno == EMDB_CTFNOMEMB) {
2230 			if (delim != MEMBER_DELIM_DONE)
2231 				return (1);
2232 			continue;
2233 		} else if (ret != 0)
2234 			return (1);
2235 
2236 		if (delim == MEMBER_DELIM_DONE)
2237 			return (mdb_tab_complete_member_by_id(mcp, rid,
2238 			    member));
2239 
2240 		(void) mdb_ctf_type_resolve(id, &rid);
2241 	}
2242 
2243 	/*
2244 	 * If we've reached here, then we need to try and tab complete the last
2245 	 * field, which is currently member, based on the ctf type id that we
2246 	 * already have in rid.
2247 	 */
2248 	return (mdb_tab_complete_member_by_id(mcp, rid, member));
2249 }
2250 
2251 int
cmd_print_tab(mdb_tab_cookie_t * mcp,uint_t flags,int argc,const mdb_arg_t * argv)2252 cmd_print_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
2253     const mdb_arg_t *argv)
2254 {
2255 	int i, dummy;
2256 
2257 	/*
2258 	 * This getopts is only here to make the tab completion work better when
2259 	 * including options in the ::print arguments. None of the values should
2260 	 * be used. This should only be updated with additional arguments, if
2261 	 * they are added to cmd_print.
2262 	 */
2263 	i = mdb_getopts(argc, argv,
2264 	    'a', MDB_OPT_SETBITS, PA_SHOWADDR, &dummy,
2265 	    'C', MDB_OPT_SETBITS, TRUE, &dummy,
2266 	    'c', MDB_OPT_UINTPTR, &dummy,
2267 	    'd', MDB_OPT_SETBITS, PA_INTDEC, &dummy,
2268 	    'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &dummy,
2269 	    'i', MDB_OPT_SETBITS, TRUE, &dummy,
2270 	    'L', MDB_OPT_SETBITS, TRUE, &dummy,
2271 	    'l', MDB_OPT_UINTPTR, &dummy,
2272 	    'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &dummy,
2273 	    'p', MDB_OPT_SETBITS, TRUE, &dummy,
2274 	    's', MDB_OPT_UINTPTR, &dummy,
2275 	    'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &dummy,
2276 	    't', MDB_OPT_SETBITS, PA_SHOWTYPE, &dummy,
2277 	    'x', MDB_OPT_SETBITS, PA_INTHEX, &dummy,
2278 	    NULL);
2279 
2280 	argc -= i;
2281 	argv += i;
2282 
2283 	return (cmd_print_tab_common(mcp, flags, argc, argv));
2284 }
2285 
2286 /*
2287  * Recursively descend a print a given data structure.  We create a struct of
2288  * the relevant print arguments and then call mdb_ctf_type_visit() to do the
2289  * traversal, using elt_print() as the callback for each element.
2290  */
2291 /*ARGSUSED*/
2292 int
cmd_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2293 cmd_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2294 {
2295 	uintptr_t opt_c = MDB_ARR_NOLIMIT, opt_l = MDB_ARR_NOLIMIT;
2296 	uint_t opt_C = FALSE, opt_L = FALSE, opt_p = FALSE, opt_i = FALSE;
2297 	uintptr_t opt_s = (uintptr_t)-1ul;
2298 	int uflags = (flags & DCMD_ADDRSPEC) ? PA_SHOWVAL : 0;
2299 	mdb_ctf_id_t id;
2300 	int err = DCMD_OK;
2301 
2302 	mdb_tgt_t *t = mdb.m_target;
2303 	printarg_t pa;
2304 	int d, i;
2305 
2306 	char s_name[MDB_SYM_NAMLEN];
2307 	mdb_syminfo_t s_info;
2308 	GElf_Sym sym;
2309 
2310 	/*
2311 	 * If a new option is added, make sure the getopts above in
2312 	 * cmd_print_tab is also updated.
2313 	 */
2314 	i = mdb_getopts(argc, argv,
2315 	    'a', MDB_OPT_SETBITS, PA_SHOWADDR, &uflags,
2316 	    'C', MDB_OPT_SETBITS, TRUE, &opt_C,
2317 	    'c', MDB_OPT_UINTPTR, &opt_c,
2318 	    'd', MDB_OPT_SETBITS, PA_INTDEC, &uflags,
2319 	    'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &uflags,
2320 	    'i', MDB_OPT_SETBITS, TRUE, &opt_i,
2321 	    'L', MDB_OPT_SETBITS, TRUE, &opt_L,
2322 	    'l', MDB_OPT_UINTPTR, &opt_l,
2323 	    'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &uflags,
2324 	    'p', MDB_OPT_SETBITS, TRUE, &opt_p,
2325 	    's', MDB_OPT_UINTPTR, &opt_s,
2326 	    'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &uflags,
2327 	    't', MDB_OPT_SETBITS, PA_SHOWTYPE, &uflags,
2328 	    'x', MDB_OPT_SETBITS, PA_INTHEX, &uflags,
2329 	    NULL);
2330 
2331 	if (uflags & PA_INTHEX)
2332 		uflags &= ~PA_INTDEC;	/* -x and -d are mutually exclusive */
2333 
2334 	uflags |= PA_SHOWNAME;
2335 
2336 	if (opt_p && opt_i) {
2337 		mdb_warn("-p and -i options are incompatible\n");
2338 		return (DCMD_ERR);
2339 	}
2340 
2341 	argc -= i;
2342 	argv += i;
2343 
2344 	if (argc != 0 && argv->a_type == MDB_TYPE_STRING) {
2345 		const char *t_name = s_name;
2346 		int ret;
2347 
2348 		if (strchr("+-", argv->a_un.a_str[0]) != NULL)
2349 			return (DCMD_USAGE);
2350 
2351 		if ((ret = args_to_typename(&argc, &argv, s_name,
2352 		    sizeof (s_name))) != 0)
2353 			return (ret);
2354 
2355 		if (mdb_ctf_lookup_by_name(t_name, &id) != 0) {
2356 			if (!(flags & DCMD_ADDRSPEC) || opt_i ||
2357 			    addr_to_sym(t, addr, s_name, sizeof (s_name),
2358 			    &sym, &s_info) == NULL ||
2359 			    mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) {
2360 
2361 				mdb_warn("failed to look up type %s", t_name);
2362 				return (DCMD_ABORT);
2363 			}
2364 		} else {
2365 			argc--;
2366 			argv++;
2367 		}
2368 
2369 	} else if (!(flags & DCMD_ADDRSPEC) || opt_i) {
2370 		return (DCMD_USAGE);
2371 
2372 	} else if (addr_to_sym(t, addr, s_name, sizeof (s_name),
2373 	    &sym, &s_info) == NULL) {
2374 		mdb_warn("no symbol information for %a", addr);
2375 		return (DCMD_ERR);
2376 
2377 	} else if (mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) {
2378 		mdb_warn("no type data available for %a [%u]", addr,
2379 		    s_info.sym_id);
2380 		return (DCMD_ERR);
2381 	}
2382 
2383 	pa.pa_tgt = mdb.m_target;
2384 	pa.pa_realtgt = pa.pa_tgt;
2385 	pa.pa_immtgt = NULL;
2386 	pa.pa_as = opt_p ? MDB_TGT_AS_PHYS : MDB_TGT_AS_VIRT;
2387 	pa.pa_armemlim = mdb.m_armemlim;
2388 	pa.pa_arstrlim = mdb.m_arstrlim;
2389 	pa.pa_delim = "\n";
2390 	pa.pa_flags = uflags;
2391 	pa.pa_nest = 0;
2392 	pa.pa_tab = 4;
2393 	pa.pa_prefix = NULL;
2394 	pa.pa_suffix = NULL;
2395 	pa.pa_holes = NULL;
2396 	pa.pa_nholes = 0;
2397 	pa.pa_depth = 0;
2398 	pa.pa_maxdepth = opt_s;
2399 	pa.pa_nooutdepth = (uint_t)-1;
2400 
2401 	if ((flags & DCMD_ADDRSPEC) && !opt_i)
2402 		pa.pa_addr = opt_p ? mdb_get_dot() : addr;
2403 	else
2404 		pa.pa_addr = 0;
2405 
2406 	if (opt_i) {
2407 		const char *vargv[2];
2408 		uintmax_t dot = mdb_get_dot();
2409 		size_t outsize = mdb_ctf_type_size(id);
2410 		vargv[0] = (const char *)&dot;
2411 		vargv[1] = (const char *)&outsize;
2412 		pa.pa_immtgt = mdb_tgt_create(mdb_value_tgt_create,
2413 		    0, 2, vargv);
2414 		pa.pa_tgt = pa.pa_immtgt;
2415 	}
2416 
2417 	if (opt_c != MDB_ARR_NOLIMIT)
2418 		pa.pa_arstrlim = opt_c;
2419 	if (opt_C)
2420 		pa.pa_arstrlim = MDB_ARR_NOLIMIT;
2421 	if (opt_l != MDB_ARR_NOLIMIT)
2422 		pa.pa_armemlim = opt_l;
2423 	if (opt_L)
2424 		pa.pa_armemlim = MDB_ARR_NOLIMIT;
2425 
2426 	if (argc > 0) {
2427 		for (i = 0; i < argc; i++) {
2428 			mdb_ctf_id_t mid;
2429 			int last_deref;
2430 			ulong_t off;
2431 			int kind;
2432 			char buf[MDB_SYM_NAMLEN];
2433 
2434 			mdb_tgt_t *oldtgt = pa.pa_tgt;
2435 			mdb_tgt_as_t oldas = pa.pa_as;
2436 			mdb_tgt_addr_t oldaddr = pa.pa_addr;
2437 
2438 			if (argv->a_type == MDB_TYPE_STRING) {
2439 				const char *member = argv[i].a_un.a_str;
2440 				mdb_ctf_id_t rid;
2441 
2442 				if (parse_member(&pa, member, id, &mid,
2443 				    &off, &last_deref) != 0) {
2444 					err = DCMD_ABORT;
2445 					goto out;
2446 				}
2447 
2448 				/*
2449 				 * If the member string ends with a "[0]"
2450 				 * (last_deref * is true) and the type is a
2451 				 * structure or union, * print "->" rather
2452 				 * than "[0]." in elt_print.
2453 				 */
2454 				(void) mdb_ctf_type_resolve(mid, &rid);
2455 				kind = mdb_ctf_type_kind(rid);
2456 				if (last_deref && IS_SOU(kind)) {
2457 					char *end;
2458 					(void) mdb_snprintf(buf, sizeof (buf),
2459 					    "%s", member);
2460 					end = strrchr(buf, '[');
2461 					*end = '\0';
2462 					pa.pa_suffix = "->";
2463 					member = &buf[0];
2464 				} else if (IS_SOU(kind)) {
2465 					pa.pa_suffix = ".";
2466 				} else {
2467 					pa.pa_suffix = "";
2468 				}
2469 
2470 				pa.pa_prefix = member;
2471 			} else {
2472 				ulong_t moff;
2473 
2474 				moff = (ulong_t)argv[i].a_un.a_val;
2475 
2476 				if (mdb_ctf_offset_to_name(id, moff * NBBY,
2477 				    buf, sizeof (buf), 0, &mid, &off) == -1) {
2478 					mdb_warn("invalid offset %lx\n", moff);
2479 					err = DCMD_ABORT;
2480 					goto out;
2481 				}
2482 
2483 				pa.pa_prefix = buf;
2484 				pa.pa_addr += moff - off / NBBY;
2485 				pa.pa_suffix = strlen(buf) == 0 ? "" : ".";
2486 			}
2487 
2488 			off %= NBBY;
2489 			if (flags & DCMD_PIPE_OUT) {
2490 				if (pipe_print(mid, off, &pa) != 0) {
2491 					mdb_warn("failed to print type");
2492 					err = DCMD_ERR;
2493 					goto out;
2494 				}
2495 			} else if (off != 0) {
2496 				mdb_ctf_id_t base;
2497 				(void) mdb_ctf_type_resolve(mid, &base);
2498 
2499 				if (elt_print("", mid, base, off, 0,
2500 				    &pa) != 0) {
2501 					mdb_warn("failed to print type");
2502 					err = DCMD_ERR;
2503 					goto out;
2504 				}
2505 			} else {
2506 				if (mdb_ctf_type_visit(mid, elt_print,
2507 				    &pa) == -1) {
2508 					mdb_warn("failed to print type");
2509 					err = DCMD_ERR;
2510 					goto out;
2511 				}
2512 
2513 				for (d = pa.pa_depth - 1; d >= 0; d--)
2514 					print_close_sou(&pa, d);
2515 			}
2516 
2517 			pa.pa_depth = 0;
2518 			pa.pa_tgt = oldtgt;
2519 			pa.pa_as = oldas;
2520 			pa.pa_addr = oldaddr;
2521 			pa.pa_delim = "\n";
2522 		}
2523 
2524 	} else if (flags & DCMD_PIPE_OUT) {
2525 		if (pipe_print(id, 0, &pa) != 0) {
2526 			mdb_warn("failed to print type");
2527 			err = DCMD_ERR;
2528 			goto out;
2529 		}
2530 	} else {
2531 		if (mdb_ctf_type_visit(id, elt_print, &pa) == -1) {
2532 			mdb_warn("failed to print type");
2533 			err = DCMD_ERR;
2534 			goto out;
2535 		}
2536 
2537 		for (d = pa.pa_depth - 1; d >= 0; d--)
2538 			print_close_sou(&pa, d);
2539 	}
2540 
2541 	mdb_set_dot(addr + mdb_ctf_type_size(id));
2542 	err = DCMD_OK;
2543 out:
2544 	if (pa.pa_immtgt)
2545 		mdb_tgt_destroy(pa.pa_immtgt);
2546 	return (err);
2547 }
2548 
2549 void
print_help(void)2550 print_help(void)
2551 {
2552 	mdb_printf(
2553 	    "-a         show address of object\n"
2554 	    "-C         unlimit the length of character arrays\n"
2555 	    "-c limit   limit the length of character arrays\n"
2556 	    "-d         output values in decimal\n"
2557 	    "-h         print holes in structures\n"
2558 	    "-i         interpret address as data of the given type\n"
2559 	    "-L         unlimit the length of standard arrays\n"
2560 	    "-l limit   limit the length of standard arrays\n"
2561 	    "-n         don't print pointers as symbol offsets\n"
2562 	    "-p         interpret address as a physical memory address\n"
2563 	    "-s depth   limit the recursion depth\n"
2564 	    "-T         show type and <<base type>> of object\n"
2565 	    "-t         show type of object\n"
2566 	    "-x         output values in hexadecimal\n"
2567 	    "\n"
2568 	    "type may be omitted if the C type of addr can be inferred.\n"
2569 	    "\n"
2570 	    "Members may be specified with standard C syntax using the\n"
2571 	    "array indexing operator \"[index]\", structure member\n"
2572 	    "operator \".\", or structure pointer operator \"->\".\n"
2573 	    "\n"
2574 	    "Offsets must use the $[ expression ] syntax\n");
2575 }
2576 
2577 static int
printf_signed(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt,boolean_t sign)2578 printf_signed(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt,
2579     boolean_t sign)
2580 {
2581 	ssize_t size;
2582 	mdb_ctf_id_t base;
2583 	ctf_encoding_t e;
2584 
2585 	union {
2586 		uint64_t ui8;
2587 		uint32_t ui4;
2588 		uint16_t ui2;
2589 		uint8_t ui1;
2590 		int64_t i8;
2591 		int32_t i4;
2592 		int16_t i2;
2593 		int8_t i1;
2594 	} u;
2595 
2596 	if (mdb_ctf_type_resolve(id, &base) == -1) {
2597 		mdb_warn("could not resolve type");
2598 		return (DCMD_ABORT);
2599 	}
2600 
2601 	switch (mdb_ctf_type_kind(base)) {
2602 		case CTF_K_ENUM:
2603 			e.cte_format = CTF_INT_SIGNED;
2604 			e.cte_offset = 0;
2605 			e.cte_bits = mdb_ctf_type_size(id) * NBBY;
2606 			break;
2607 		case CTF_K_INTEGER:
2608 			if (mdb_ctf_type_encoding(base, &e) != 0) {
2609 				mdb_warn("could not get type encoding");
2610 				return (DCMD_ABORT);
2611 			}
2612 			break;
2613 		default:
2614 			mdb_warn("expected integer type\n");
2615 			return (DCMD_ABORT);
2616 	}
2617 
2618 	if (sign)
2619 		sign = e.cte_format & CTF_INT_SIGNED;
2620 
2621 	size = e.cte_bits / NBBY;
2622 
2623 	/*
2624 	 * Check to see if our life has been complicated by the presence of
2625 	 * a bitfield.  If it has, we will print it using logic that is only
2626 	 * slightly different than that found in print_bitfield(), above.  (In
2627 	 * particular, see the comments there for an explanation of the
2628 	 * endianness differences in this code.)
2629 	 */
2630 	if (size > 8 || (e.cte_bits % NBBY) != 0 ||
2631 	    (size & (size - 1)) != 0) {
2632 		uint64_t mask = (1ULL << e.cte_bits) - 1;
2633 		uint64_t value = 0;
2634 		uint8_t *buf = (uint8_t *)&value;
2635 		uint8_t shift;
2636 
2637 		/*
2638 		 * Round our size up one byte.
2639 		 */
2640 		size = (e.cte_bits + (NBBY - 1)) / NBBY;
2641 
2642 		if (e.cte_bits > sizeof (value) * NBBY - 1) {
2643 			mdb_printf("invalid bitfield size %u", e.cte_bits);
2644 			return (DCMD_ABORT);
2645 		}
2646 
2647 #ifdef _BIG_ENDIAN
2648 		buf += sizeof (value) - size;
2649 		off += e.cte_bits;
2650 #endif
2651 
2652 		if (mdb_vread(buf, size, addr) == -1) {
2653 			mdb_warn("failed to read %lu bytes at %p", size, addr);
2654 			return (DCMD_ERR);
2655 		}
2656 
2657 		shift = off % NBBY;
2658 #ifdef _BIG_ENDIAN
2659 		shift = NBBY - shift;
2660 #endif
2661 
2662 		/*
2663 		 * If we have a bit offset within the byte, shift it down.
2664 		 */
2665 		if (off % NBBY != 0)
2666 			value >>= shift;
2667 		value &= mask;
2668 
2669 		if (sign) {
2670 			int sshift = sizeof (value) * NBBY - e.cte_bits;
2671 			value = ((int64_t)value << sshift) >> sshift;
2672 		}
2673 
2674 		mdb_printf(fmt, value);
2675 		return (0);
2676 	}
2677 
2678 	if (mdb_vread(&u.i8, size, addr) == -1) {
2679 		mdb_warn("failed to read %lu bytes at %p", (ulong_t)size, addr);
2680 		return (DCMD_ERR);
2681 	}
2682 
2683 	switch (size) {
2684 	case sizeof (uint8_t):
2685 		mdb_printf(fmt, (uint64_t)(sign ? u.i1 : u.ui1));
2686 		break;
2687 	case sizeof (uint16_t):
2688 		mdb_printf(fmt, (uint64_t)(sign ? u.i2 : u.ui2));
2689 		break;
2690 	case sizeof (uint32_t):
2691 		mdb_printf(fmt, (uint64_t)(sign ? u.i4 : u.ui4));
2692 		break;
2693 	case sizeof (uint64_t):
2694 		mdb_printf(fmt, (uint64_t)(sign ? u.i8 : u.ui8));
2695 		break;
2696 	}
2697 
2698 	return (0);
2699 }
2700 
2701 static int
printf_int(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2702 printf_int(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2703 {
2704 	return (printf_signed(id, addr, off, fmt, B_TRUE));
2705 }
2706 
2707 static int
printf_uint(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2708 printf_uint(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2709 {
2710 	return (printf_signed(id, addr, off, fmt, B_FALSE));
2711 }
2712 
2713 /*ARGSUSED*/
2714 static int
printf_uint32(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2715 printf_uint32(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2716 {
2717 	mdb_ctf_id_t base;
2718 	ctf_encoding_t e;
2719 	uint32_t value;
2720 
2721 	if (mdb_ctf_type_resolve(id, &base) == -1) {
2722 		mdb_warn("could not resolve type\n");
2723 		return (DCMD_ABORT);
2724 	}
2725 
2726 	if (mdb_ctf_type_kind(base) != CTF_K_INTEGER ||
2727 	    mdb_ctf_type_encoding(base, &e) != 0 ||
2728 	    e.cte_bits / NBBY != sizeof (value)) {
2729 		mdb_warn("expected 32-bit integer type\n");
2730 		return (DCMD_ABORT);
2731 	}
2732 
2733 	if (mdb_vread(&value, sizeof (value), addr) == -1) {
2734 		mdb_warn("failed to read 32-bit value at %p", addr);
2735 		return (DCMD_ERR);
2736 	}
2737 
2738 	mdb_printf(fmt, value);
2739 
2740 	return (0);
2741 }
2742 
2743 /*ARGSUSED*/
2744 static int
printf_ptr(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2745 printf_ptr(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2746 {
2747 	uintptr_t value;
2748 	mdb_ctf_id_t base;
2749 
2750 	if (mdb_ctf_type_resolve(id, &base) == -1) {
2751 		mdb_warn("could not resolve type\n");
2752 		return (DCMD_ABORT);
2753 	}
2754 
2755 	if (mdb_ctf_type_kind(base) != CTF_K_POINTER) {
2756 		mdb_warn("expected pointer type\n");
2757 		return (DCMD_ABORT);
2758 	}
2759 
2760 	if (mdb_vread(&value, sizeof (value), addr) == -1) {
2761 		mdb_warn("failed to read pointer at %llx", addr);
2762 		return (DCMD_ERR);
2763 	}
2764 
2765 	mdb_printf(fmt, value);
2766 
2767 	return (0);
2768 }
2769 
2770 /*ARGSUSED*/
2771 static int
printf_string(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2772 printf_string(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2773 {
2774 	mdb_ctf_id_t base;
2775 	mdb_ctf_arinfo_t r;
2776 	char buf[1024];
2777 	ssize_t size;
2778 
2779 	if (mdb_ctf_type_resolve(id, &base) == -1) {
2780 		mdb_warn("could not resolve type");
2781 		return (DCMD_ABORT);
2782 	}
2783 
2784 	if (mdb_ctf_type_kind(base) == CTF_K_POINTER) {
2785 		uintptr_t value;
2786 
2787 		if (mdb_vread(&value, sizeof (value), addr) == -1) {
2788 			mdb_warn("failed to read pointer at %llx", addr);
2789 			return (DCMD_ERR);
2790 		}
2791 
2792 		if (mdb_readstr(buf, sizeof (buf) - 1, value) < 0) {
2793 			mdb_warn("failed to read string at %llx", value);
2794 			return (DCMD_ERR);
2795 		}
2796 
2797 		mdb_printf(fmt, buf);
2798 		return (0);
2799 	}
2800 
2801 	if (mdb_ctf_type_kind(base) == CTF_K_ENUM) {
2802 		const char *strval;
2803 		int value;
2804 
2805 		if (mdb_vread(&value, sizeof (value), addr) == -1) {
2806 			mdb_warn("failed to read pointer at %llx", addr);
2807 			return (DCMD_ERR);
2808 		}
2809 
2810 		if ((strval = mdb_ctf_enum_name(id, value))) {
2811 			mdb_printf(fmt, strval);
2812 		} else {
2813 			(void) mdb_snprintf(buf, sizeof (buf), "<%d>", value);
2814 			mdb_printf(fmt, buf);
2815 		}
2816 
2817 		return (0);
2818 	}
2819 
2820 	if (mdb_ctf_type_kind(base) != CTF_K_ARRAY) {
2821 		mdb_warn("exepected pointer or array type\n");
2822 		return (DCMD_ABORT);
2823 	}
2824 
2825 	if (mdb_ctf_array_info(base, &r) == -1 ||
2826 	    mdb_ctf_type_resolve(r.mta_contents, &base) == -1 ||
2827 	    (size = mdb_ctf_type_size(base)) == -1) {
2828 		mdb_warn("can't determine array type");
2829 		return (DCMD_ABORT);
2830 	}
2831 
2832 	if (size != 1) {
2833 		mdb_warn("string format specifier requires "
2834 		    "an array of characters\n");
2835 		return (DCMD_ABORT);
2836 	}
2837 
2838 	bzero(buf, sizeof (buf));
2839 
2840 	if (mdb_vread(buf, MIN(r.mta_nelems, sizeof (buf) - 1), addr) == -1) {
2841 		mdb_warn("failed to read array at %p", addr);
2842 		return (DCMD_ERR);
2843 	}
2844 
2845 	mdb_printf(fmt, buf);
2846 
2847 	return (0);
2848 }
2849 
2850 /*ARGSUSED*/
2851 static int
printf_ipv6(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2852 printf_ipv6(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2853 {
2854 	mdb_ctf_id_t base;
2855 	mdb_ctf_id_t ipv6_type, ipv6_base;
2856 	in6_addr_t ipv6;
2857 
2858 	if (mdb_ctf_lookup_by_name("in6_addr_t", &ipv6_type) == -1) {
2859 		mdb_warn("could not resolve in6_addr_t type\n");
2860 		return (DCMD_ABORT);
2861 	}
2862 
2863 	if (mdb_ctf_type_resolve(id, &base) == -1) {
2864 		mdb_warn("could not resolve type\n");
2865 		return (DCMD_ABORT);
2866 	}
2867 
2868 	if (mdb_ctf_type_resolve(ipv6_type, &ipv6_base) == -1) {
2869 		mdb_warn("could not resolve in6_addr_t type\n");
2870 		return (DCMD_ABORT);
2871 	}
2872 
2873 	if (mdb_ctf_type_cmp(base, ipv6_base) != 0) {
2874 		mdb_warn("requires argument of type in6_addr_t\n");
2875 		return (DCMD_ABORT);
2876 	}
2877 
2878 	if (mdb_vread(&ipv6, sizeof (ipv6), addr) == -1) {
2879 		mdb_warn("couldn't read in6_addr_t at %p", addr);
2880 		return (DCMD_ERR);
2881 	}
2882 
2883 	mdb_printf(fmt, &ipv6);
2884 
2885 	return (0);
2886 }
2887 
2888 /*
2889  * To validate the format string specified to ::printf, we run the format
2890  * string through a very simple state machine that restricts us to a subset
2891  * of mdb_printf() functionality.
2892  */
2893 enum {
2894 	PRINTF_NOFMT = 1,		/* no current format specifier */
2895 	PRINTF_PERC,			/* processed '%' */
2896 	PRINTF_FMT,			/* processing format specifier */
2897 	PRINTF_LEFT,			/* processed '-', expecting width */
2898 	PRINTF_WIDTH,			/* processing width */
2899 	PRINTF_QUES			/* processed '?', expecting format */
2900 };
2901 
2902 int
cmd_printf_tab(mdb_tab_cookie_t * mcp,uint_t flags,int argc,const mdb_arg_t * argv)2903 cmd_printf_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
2904     const mdb_arg_t *argv)
2905 {
2906 	int ii;
2907 	char *f;
2908 
2909 	/*
2910 	 * If argc doesn't have more than what should be the format string,
2911 	 * ignore it.
2912 	 */
2913 	if (argc <= 1)
2914 		return (0);
2915 
2916 	/*
2917 	 * Because we aren't leveraging the lex and yacc engine, we have to
2918 	 * manually walk the arguments to find both the first and last
2919 	 * open/close quote of the format string.
2920 	 */
2921 	f = strchr(argv[0].a_un.a_str, '"');
2922 	if (f == NULL)
2923 		return (0);
2924 
2925 	f = strchr(f + 1, '"');
2926 	if (f != NULL) {
2927 		ii = 0;
2928 	} else {
2929 		for (ii = 1; ii < argc; ii++) {
2930 			if (argv[ii].a_type != MDB_TYPE_STRING)
2931 				continue;
2932 			f = strchr(argv[ii].a_un.a_str, '"');
2933 			if (f != NULL)
2934 				break;
2935 		}
2936 		/* Never found */
2937 		if (ii == argc)
2938 			return (0);
2939 	}
2940 
2941 	ii++;
2942 	argc -= ii;
2943 	argv += ii;
2944 
2945 	return (cmd_print_tab_common(mcp, flags, argc, argv));
2946 }
2947 
2948 int
cmd_printf(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2949 cmd_printf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2950 {
2951 	char type[MDB_SYM_NAMLEN];
2952 	int i, nfmts = 0, ret;
2953 	mdb_ctf_id_t id;
2954 	const char *fmt, *member;
2955 	char **fmts, *last, *dest, f;
2956 	int (**funcs)(mdb_ctf_id_t, uintptr_t, ulong_t, char *);
2957 	int state = PRINTF_NOFMT;
2958 	printarg_t pa;
2959 
2960 	if (!(flags & DCMD_ADDRSPEC))
2961 		return (DCMD_USAGE);
2962 
2963 	bzero(&pa, sizeof (pa));
2964 	pa.pa_as = MDB_TGT_AS_VIRT;
2965 	pa.pa_realtgt = pa.pa_tgt = mdb.m_target;
2966 
2967 	if (argc == 0 || argv[0].a_type != MDB_TYPE_STRING) {
2968 		mdb_warn("expected a format string\n");
2969 		return (DCMD_USAGE);
2970 	}
2971 
2972 	/*
2973 	 * Our first argument is a format string; rip it apart and run it
2974 	 * through our state machine to validate that our input is within the
2975 	 * subset of mdb_printf() format strings that we allow.
2976 	 */
2977 	fmt = argv[0].a_un.a_str;
2978 	/*
2979 	 * 'dest' must be large enough to hold a copy of the format string,
2980 	 * plus a NUL and up to 2 additional characters for each conversion
2981 	 * in the format string.  This gives us a bloat factor of 5/2 ~= 3.
2982 	 *   e.g. "%d" (strlen of 2) --> "%lld\0" (need 5 bytes)
2983 	 */
2984 	dest = mdb_zalloc(strlen(fmt) * 3, UM_SLEEP | UM_GC);
2985 	fmts = mdb_zalloc(strlen(fmt) * sizeof (char *), UM_SLEEP | UM_GC);
2986 	funcs = mdb_zalloc(strlen(fmt) * sizeof (void *), UM_SLEEP | UM_GC);
2987 	last = dest;
2988 
2989 	for (i = 0; fmt[i] != '\0'; i++) {
2990 		*dest++ = f = fmt[i];
2991 
2992 		switch (state) {
2993 		case PRINTF_NOFMT:
2994 			state = f == '%' ? PRINTF_PERC : PRINTF_NOFMT;
2995 			break;
2996 
2997 		case PRINTF_PERC:
2998 			state = f == '-' ? PRINTF_LEFT :
2999 			    f >= '0' && f <= '9' ? PRINTF_WIDTH :
3000 			    f == '?' ? PRINTF_QUES :
3001 			    f == '%' ? PRINTF_NOFMT : PRINTF_FMT;
3002 			break;
3003 
3004 		case PRINTF_LEFT:
3005 			state = f >= '0' && f <= '9' ? PRINTF_WIDTH :
3006 			    f == '?' ? PRINTF_QUES : PRINTF_FMT;
3007 			break;
3008 
3009 		case PRINTF_WIDTH:
3010 			state = f >= '0' && f <= '9' ? PRINTF_WIDTH :
3011 			    PRINTF_FMT;
3012 			break;
3013 
3014 		case PRINTF_QUES:
3015 			state = PRINTF_FMT;
3016 			break;
3017 		}
3018 
3019 		if (state != PRINTF_FMT)
3020 			continue;
3021 
3022 		dest--;
3023 
3024 		/*
3025 		 * Now check that we have one of our valid format characters.
3026 		 */
3027 		switch (f) {
3028 		case 'a':
3029 		case 'A':
3030 		case 'p':
3031 			funcs[nfmts] = printf_ptr;
3032 			break;
3033 
3034 		case 'd':
3035 		case 'q':
3036 		case 'R':
3037 			funcs[nfmts] = printf_int;
3038 			*dest++ = 'l';
3039 			*dest++ = 'l';
3040 			break;
3041 
3042 		case 'I':
3043 			funcs[nfmts] = printf_uint32;
3044 			break;
3045 
3046 		case 'N':
3047 			funcs[nfmts] = printf_ipv6;
3048 			break;
3049 
3050 		case 'H':
3051 		case 'o':
3052 		case 'r':
3053 		case 'u':
3054 		case 'x':
3055 		case 'X':
3056 			funcs[nfmts] = printf_uint;
3057 			*dest++ = 'l';
3058 			*dest++ = 'l';
3059 			break;
3060 
3061 		case 's':
3062 			funcs[nfmts] = printf_string;
3063 			break;
3064 
3065 		case 'Y':
3066 			funcs[nfmts] = sizeof (time_t) == sizeof (int) ?
3067 			    printf_uint32 : printf_uint;
3068 			break;
3069 
3070 		default:
3071 			mdb_warn("illegal format string at or near "
3072 			    "'%c' (position %d)\n", f, i + 1);
3073 			return (DCMD_ABORT);
3074 		}
3075 
3076 		*dest++ = f;
3077 		*dest++ = '\0';
3078 		fmts[nfmts++] = last;
3079 		last = dest;
3080 		state = PRINTF_NOFMT;
3081 	}
3082 
3083 	argc--;
3084 	argv++;
3085 
3086 	/*
3087 	 * Now we expect a type name.
3088 	 */
3089 	if ((ret = args_to_typename(&argc, &argv, type, sizeof (type))) != 0)
3090 		return (ret);
3091 
3092 	argv++;
3093 	argc--;
3094 
3095 	if (mdb_ctf_lookup_by_name(type, &id) != 0) {
3096 		mdb_warn("failed to look up type %s", type);
3097 		return (DCMD_ABORT);
3098 	}
3099 
3100 	if (argc == 0) {
3101 		mdb_warn("at least one member must be specified\n");
3102 		return (DCMD_USAGE);
3103 	}
3104 
3105 	if (argc != nfmts) {
3106 		mdb_warn("%s format specifiers (found %d, expected %d)\n",
3107 		    argc > nfmts ? "missing" : "extra", nfmts, argc);
3108 		return (DCMD_ABORT);
3109 	}
3110 
3111 	for (i = 0; i < argc; i++) {
3112 		mdb_ctf_id_t mid;
3113 		ulong_t off;
3114 		int ignored;
3115 
3116 		if (argv[i].a_type != MDB_TYPE_STRING) {
3117 			mdb_warn("expected only type member arguments\n");
3118 			return (DCMD_ABORT);
3119 		}
3120 
3121 		if (strcmp((member = argv[i].a_un.a_str), ".") == 0) {
3122 			/*
3123 			 * We allow "." to be specified to denote the current
3124 			 * value of dot.
3125 			 */
3126 			if (funcs[i] != printf_ptr && funcs[i] != printf_uint &&
3127 			    funcs[i] != printf_int) {
3128 				mdb_warn("expected integer or pointer format "
3129 				    "specifier for '.'\n");
3130 				return (DCMD_ABORT);
3131 			}
3132 
3133 			mdb_printf(fmts[i], mdb_get_dot());
3134 			continue;
3135 		}
3136 
3137 		pa.pa_addr = addr;
3138 
3139 		if (parse_member(&pa, member, id, &mid, &off, &ignored) != 0)
3140 			return (DCMD_ABORT);
3141 
3142 		if ((ret = funcs[i](mid, pa.pa_addr, off, fmts[i])) != 0) {
3143 			mdb_warn("failed to print member '%s'\n", member);
3144 			return (ret);
3145 		}
3146 	}
3147 
3148 	mdb_printf("%s", last);
3149 	mdb_set_dot(addr + mdb_ctf_type_size(id));
3150 
3151 	return (DCMD_OK);
3152 }
3153 
3154 static char _mdb_printf_help[] =
3155 "The format string argument is a printf(3C)-like format string that is a\n"
3156 "subset of the format strings supported by mdb_printf().  The type argument\n"
3157 "is the name of a type to be used to interpret the memory referenced by dot.\n"
3158 "The member should either be a field in the specified structure, or the\n"
3159 "special member '.', denoting the value of dot (and treated as a pointer).\n"
3160 "The number of members must match the number of format specifiers in the\n"
3161 "format string.\n"
3162 "\n"
3163 "The following format specifiers are recognized by ::printf:\n"
3164 "\n"
3165 "  %%    Prints the '%' symbol.\n"
3166 "  %a    Prints the member in symbolic form.\n"
3167 "  %d    Prints the member as a decimal integer.  If the member is a signed\n"
3168 "        integer type, the output will be signed.\n"
3169 "  %H    Prints the member as a human-readable size.\n"
3170 "  %I    Prints the member as an IPv4 address (must be 32-bit integer type).\n"
3171 "  %N    Prints the member as an IPv6 address (must be of type in6_addr_t).\n"
3172 "  %o    Prints the member as an unsigned octal integer.\n"
3173 "  %p    Prints the member as a pointer, in hexadecimal.\n"
3174 "  %q    Prints the member in signed octal.  Honk if you ever use this!\n"
3175 "  %r    Prints the member as an unsigned value in the current output radix.\n"
3176 "  %R    Prints the member as a signed value in the current output radix.\n"
3177 "  %s    Prints the member as a string (requires a pointer or an array of\n"
3178 "        characters).\n"
3179 "  %u    Prints the member as an unsigned decimal integer.\n"
3180 "  %x    Prints the member in hexadecimal.\n"
3181 "  %X    Prints the member in hexadecimal, using the characters A-F as the\n"
3182 "        digits for the values 10-15.\n"
3183 "  %Y    Prints the member as a time_t as the string "
3184 	    "'year month day HH:MM:SS'.\n"
3185 "\n"
3186 "The following field width specifiers are recognized by ::printf:\n"
3187 "\n"
3188 "  %n    Field width is set to the specified decimal value.\n"
3189 "  %?    Field width is set to the maximum width of a hexadecimal pointer\n"
3190 "        value.  This is 8 in an ILP32 environment, and 16 in an LP64\n"
3191 "        environment.\n"
3192 "\n"
3193 "The following flag specifers are recognized by ::printf:\n"
3194 "\n"
3195 "  %-    Left-justify the output within the specified field width.  If the\n"
3196 "        width of the output is less than the specified field width, the\n"
3197 "        output will be padded with blanks on the right-hand side.  Without\n"
3198 "        %-, values are right-justified by default.\n"
3199 "\n"
3200 "  %0    Zero-fill the output field if the output is right-justified and the\n"
3201 "        width of the output is less than the specified field width.  Without\n"
3202 "        %0, right-justified values are prepended with blanks in order to\n"
3203 "        fill the field.\n"
3204 "\n"
3205 "Examples: \n"
3206 "\n"
3207 "  ::walk proc | "
3208 	"::printf \"%-6d %s\\n\" proc_t p_pidp->pid_id p_user.u_psargs\n"
3209 "  ::walk thread | "
3210 	"::printf \"%?p %3d %a\\n\" kthread_t . t_pri t_startpc\n"
3211 "  ::walk zone | "
3212 	"::printf \"%-40s %20s\\n\" zone_t zone_name zone_nodename\n"
3213 "  ::walk ire | "
3214 	"::printf \"%Y %I\\n\" ire_t ire_create_time ire_u.ire4_u.ire4_addr\n"
3215 "\n";
3216 
3217 void
printf_help(void)3218 printf_help(void)
3219 {
3220 	mdb_printf("%s", _mdb_printf_help);
3221 }
3222