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 2025 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 nelem = (int)mdb_argtoull(&argv[1]);
822
823 elemsize = mdb_ctf_type_size(id);
824 } else if (addr_to_sym(t, addr, tn, sizeof (tn), &sym, &s_info)
825 != NULL &&
826 mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) == 0 &&
827 mdb_ctf_type_kind(id) == CTF_K_ARRAY &&
828 mdb_ctf_array_info(id, &ar) != -1) {
829 if (ar.mta_nelems == 0) {
830 mdb_warn("array has 0 elements\n");
831 return (DCMD_ERR);
832 }
833 elemsize = mdb_ctf_type_size(id) / ar.mta_nelems;
834 nelem = ar.mta_nelems;
835 } else {
836 mdb_warn("no symbol information for %a", addr);
837 return (DCMD_ERR);
838 }
839
840 if (argc == 3 || argc == 1) {
841 if (argv[argc - 1].a_type != MDB_TYPE_STRING)
842 return (DCMD_USAGE);
843
844 if ((ret = setup_vcb(argv[argc - 1].a_un.a_str, addr)) != 0)
845 return (ret);
846
847 } else if (argc > 3) {
848 return (DCMD_USAGE);
849 }
850
851 for (; nelem > 0; nelem--) {
852 mdb_printf("%lr\n", addr);
853 addr = addr + elemsize;
854 }
855
856 return (DCMD_OK);
857 }
858
859 /*
860 * This is a shared implementation to determine if we should treat a type as a
861 * bitfield. The parameters are the CTF encoding and the bit offset of the
862 * integer. This also exists in mdb_print.c. We consider something a bitfield
863 * if:
864 *
865 * o The type is more than 8 bytes. This is a bit of a historical choice from
866 * mdb and is a stranger one. The normal integer handling code generally
867 * doesn't handle integers more than 64-bits in size. Of course neither does
868 * the bitfield code...
869 * o The bit count is not a multiple of 8.
870 * o The size in bytes is not a power of 2.
871 * o The offset is not a multiple of 8.
872 */
873 boolean_t
is_bitfield(const ctf_encoding_t * ep,ulong_t off)874 is_bitfield(const ctf_encoding_t *ep, ulong_t off)
875 {
876 size_t bsize = ep->cte_bits / NBBY;
877 return (bsize > 8 || (ep->cte_bits % NBBY) != 0 ||
878 (bsize & (bsize - 1)) != 0 || (off % NBBY) != 0);
879 }
880
881 /*
882 * Print an integer bitfield in hexadecimal by reading the enclosing byte(s)
883 * and then shifting and masking the data in the lower bits of a uint64_t.
884 */
885 static int
print_bitfield(ulong_t off,printarg_t * pap,ctf_encoding_t * ep)886 print_bitfield(ulong_t off, printarg_t *pap, ctf_encoding_t *ep)
887 {
888 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
889 uint64_t mask = (1ULL << ep->cte_bits) - 1;
890 uint64_t value = 0;
891 uint8_t *buf = (uint8_t *)&value;
892 uint8_t shift;
893 const char *format;
894
895 /*
896 * Our bitfield may straddle a byte boundary. We explicitly take the
897 * offset of the bitfield within its byte into account when determining
898 * the overall amount of data to copy and mask off from the underlying
899 * data.
900 */
901 uint_t nbits = ep->cte_bits + (off % NBBY);
902 size_t size = P2ROUNDUP(nbits, NBBY) / NBBY;
903
904 if (!(pap->pa_flags & PA_SHOWVAL))
905 return (0);
906
907 if (ep->cte_bits > sizeof (value) * NBBY - 1) {
908 mdb_printf("??? (invalid bitfield size %u)", ep->cte_bits);
909 return (0);
910 }
911
912 if (size > sizeof (value)) {
913 mdb_printf("??? (total bitfield too large after alignment");
914 return (0);
915 }
916
917 /*
918 * On big-endian machines, we need to adjust the buf pointer to refer
919 * to the lowest 'size' bytes in 'value', and we need shift based on
920 * the offset from the end of the data, not the offset of the start.
921 */
922 #ifdef _BIG_ENDIAN
923 buf += sizeof (value) - size;
924 off += ep->cte_bits;
925 #endif
926
927 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, buf, size, addr) != size) {
928 mdb_warn("failed to read %lu bytes at %llx",
929 (ulong_t)size, addr);
930 return (1);
931 }
932
933 shift = off % NBBY;
934
935 /*
936 * Offsets are counted from opposite ends on little- and
937 * big-endian machines.
938 */
939 #ifdef _BIG_ENDIAN
940 shift = NBBY - shift;
941 #endif
942
943 /*
944 * If the bits we want do not begin on a byte boundary, shift the data
945 * right so that the value is in the lowest 'cte_bits' of 'value'.
946 */
947 if (off % NBBY != 0)
948 value >>= shift;
949 value &= mask;
950
951 /*
952 * We default to printing signed bitfields as decimals,
953 * and unsigned bitfields in hexadecimal. If they specify
954 * hexadecimal, we treat the field as unsigned.
955 */
956 if ((pap->pa_flags & PA_INTHEX) ||
957 !(ep->cte_format & CTF_INT_SIGNED)) {
958 format = (pap->pa_flags & PA_INTDEC)? "%#llu" : "%#llx";
959 } else {
960 int sshift = sizeof (value) * NBBY - ep->cte_bits;
961
962 /* sign-extend value, and print as a signed decimal */
963 value = ((int64_t)value << sshift) >> sshift;
964 format = "%#lld";
965 }
966 mdb_printf(format, value);
967
968 return (0);
969 }
970
971 /*
972 * We want to print an escaped char as e.g. '\0'. We don't use mdb_fmt_print()
973 * as it won't get auto-wrap right here (although even now, we don't include any
974 * trailing comma).
975 */
976 static int
print_char_val(mdb_tgt_addr_t addr,printarg_t * pap)977 print_char_val(mdb_tgt_addr_t addr, printarg_t *pap)
978 {
979 char cval;
980 char *s;
981
982 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &cval, 1, addr) != 1)
983 return (1);
984
985 if (mdb.m_flags & MDB_FL_ADB)
986 s = strchr2adb(&cval, 1);
987 else
988 s = strchr2esc(&cval, 1);
989
990 mdb_printf("'%s'", s);
991 strfree(s);
992 return (0);
993 }
994
995 /*
996 * Print out a character or integer value. We use some simple heuristics,
997 * described below, to determine the appropriate radix to use for output.
998 */
999 static int
print_int_val(const char * type,ctf_encoding_t * ep,ulong_t off,printarg_t * pap)1000 print_int_val(const char *type, ctf_encoding_t *ep, ulong_t off,
1001 printarg_t *pap)
1002 {
1003 static const char *const sformat[] = { "%#d", "%#d", "%#d", "%#lld" };
1004 static const char *const uformat[] = { "%#u", "%#u", "%#u", "%#llu" };
1005 static const char *const xformat[] = { "%#x", "%#x", "%#x", "%#llx" };
1006
1007 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1008 const char *const *fsp;
1009 size_t size;
1010
1011 union {
1012 uint64_t i8;
1013 uint32_t i4;
1014 uint16_t i2;
1015 uint8_t i1;
1016 time_t t;
1017 ipaddr_t I;
1018 } u;
1019
1020 if (!(pap->pa_flags & PA_SHOWVAL))
1021 return (0);
1022
1023 if (ep->cte_format & CTF_INT_VARARGS) {
1024 mdb_printf("...\n");
1025 return (0);
1026 }
1027
1028 size = ep->cte_bits / NBBY;
1029 if (is_bitfield(ep, off)) {
1030 return (print_bitfield(off, pap, ep));
1031 }
1032
1033 if (IS_CHAR(*ep))
1034 return (print_char_val(addr, pap));
1035
1036 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, addr) != size) {
1037 mdb_warn("failed to read %lu bytes at %llx",
1038 (ulong_t)size, addr);
1039 return (1);
1040 }
1041
1042 /*
1043 * We pretty-print some integer based types. time_t values are
1044 * printed as a calendar date and time, and IPv4 addresses as human
1045 * readable dotted quads.
1046 */
1047 if (!(pap->pa_flags & (PA_INTHEX | PA_INTDEC))) {
1048 if (strcmp(type, "time_t") == 0 && u.t != 0) {
1049 mdb_printf("%Y", u.t);
1050 return (0);
1051 }
1052 if (strcmp(type, "ipaddr_t") == 0 ||
1053 strcmp(type, "in_addr_t") == 0) {
1054 mdb_printf("%I", u.I);
1055 return (0);
1056 }
1057 }
1058
1059 /*
1060 * The default format is hexadecimal.
1061 */
1062 if (!(pap->pa_flags & PA_INTDEC))
1063 fsp = xformat;
1064 else if (ep->cte_format & CTF_INT_SIGNED)
1065 fsp = sformat;
1066 else
1067 fsp = uformat;
1068
1069 switch (size) {
1070 case sizeof (uint8_t):
1071 mdb_printf(fsp[0], u.i1);
1072 break;
1073 case sizeof (uint16_t):
1074 mdb_printf(fsp[1], u.i2);
1075 break;
1076 case sizeof (uint32_t):
1077 mdb_printf(fsp[2], u.i4);
1078 break;
1079 case sizeof (uint64_t):
1080 mdb_printf(fsp[3], u.i8);
1081 break;
1082 }
1083 return (0);
1084 }
1085
1086 /*ARGSUSED*/
1087 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)1088 print_int(const char *type, const char *name, mdb_ctf_id_t id,
1089 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1090 {
1091 ctf_encoding_t e;
1092
1093 if (!(pap->pa_flags & PA_SHOWVAL))
1094 return (0);
1095
1096 if (mdb_ctf_type_encoding(base, &e) != 0) {
1097 mdb_printf("??? (%s)", mdb_strerror(errno));
1098 return (0);
1099 }
1100
1101 return (print_int_val(type, &e, off, pap));
1102 }
1103
1104 /*
1105 * Print out a floating point value. We only provide support for floats in
1106 * the ANSI-C float, double, and long double formats.
1107 */
1108 /*ARGSUSED*/
1109 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)1110 print_float(const char *type, const char *name, mdb_ctf_id_t id,
1111 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1112 {
1113 #ifndef _KMDB
1114 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1115 ctf_encoding_t e;
1116
1117 union {
1118 float f;
1119 double d;
1120 long double ld;
1121 } u;
1122
1123 if (!(pap->pa_flags & PA_SHOWVAL))
1124 return (0);
1125
1126 if (mdb_ctf_type_encoding(base, &e) == 0) {
1127 if (e.cte_format == CTF_FP_SINGLE &&
1128 e.cte_bits == sizeof (float) * NBBY) {
1129 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.f,
1130 sizeof (u.f), addr) != sizeof (u.f)) {
1131 mdb_warn("failed to read float at %llx", addr);
1132 return (1);
1133 }
1134 mdb_printf("%s", doubletos(u.f, 7, 'e'));
1135
1136 } else if (e.cte_format == CTF_FP_DOUBLE &&
1137 e.cte_bits == sizeof (double) * NBBY) {
1138 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.d,
1139 sizeof (u.d), addr) != sizeof (u.d)) {
1140 mdb_warn("failed to read float at %llx", addr);
1141 return (1);
1142 }
1143 mdb_printf("%s", doubletos(u.d, 7, 'e'));
1144
1145 } else if (e.cte_format == CTF_FP_LDOUBLE &&
1146 e.cte_bits == sizeof (long double) * NBBY) {
1147 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.ld,
1148 sizeof (u.ld), addr) != sizeof (u.ld)) {
1149 mdb_warn("failed to read float at %llx", addr);
1150 return (1);
1151 }
1152 mdb_printf("%s", longdoubletos(&u.ld, 16, 'e'));
1153
1154 } else {
1155 mdb_printf("??? (unsupported FP format %u / %u bits\n",
1156 e.cte_format, e.cte_bits);
1157 }
1158 } else
1159 mdb_printf("??? (%s)", mdb_strerror(errno));
1160 #else
1161 mdb_printf("<FLOAT>");
1162 #endif
1163 return (0);
1164 }
1165
1166
1167 /*
1168 * Print out a pointer value as a symbol name + offset or a hexadecimal value.
1169 * If the pointer itself is a char *, we attempt to read a bit of the data
1170 * referenced by the pointer and display it if it is a printable ASCII string.
1171 */
1172 /*ARGSUSED*/
1173 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)1174 print_ptr(const char *type, const char *name, mdb_ctf_id_t id,
1175 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1176 {
1177 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1178 ctf_encoding_t e;
1179 uintptr_t value;
1180 char buf[256];
1181 ssize_t len;
1182
1183 if (!(pap->pa_flags & PA_SHOWVAL))
1184 return (0);
1185
1186 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
1187 &value, sizeof (value), addr) != sizeof (value)) {
1188 mdb_warn("failed to read %s pointer at %llx", name, addr);
1189 return (1);
1190 }
1191
1192 if (pap->pa_flags & PA_NOSYMBOLIC) {
1193 mdb_printf("%#lx", value);
1194 return (0);
1195 }
1196
1197 mdb_printf("%a", value);
1198
1199 if (value == 0 || strcmp(type, "caddr_t") == 0)
1200 return (0);
1201
1202 if (mdb_ctf_type_kind(base) == CTF_K_POINTER &&
1203 mdb_ctf_type_reference(base, &base) != -1 &&
1204 mdb_ctf_type_resolve(base, &base) != -1 &&
1205 mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e)) {
1206 if ((len = mdb_tgt_readstr(pap->pa_realtgt, pap->pa_as,
1207 buf, sizeof (buf), value)) >= 0 && strisprint(buf)) {
1208 if (len == sizeof (buf))
1209 (void) strabbr(buf, sizeof (buf));
1210 mdb_printf(" \"%s\"", buf);
1211 }
1212 }
1213
1214 return (0);
1215 }
1216
1217
1218 /*
1219 * Print out a fixed-size array. We special-case arrays of characters
1220 * and attempt to print them out as ASCII strings if possible. For other
1221 * arrays, we iterate over a maximum of pa_armemlim members and call
1222 * mdb_ctf_type_visit() again on each element to print its value.
1223 */
1224 /*ARGSUSED*/
1225 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)1226 print_array(const char *type, const char *name, mdb_ctf_id_t id,
1227 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1228 {
1229 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1230 printarg_t pa = *pap;
1231 ssize_t eltsize;
1232 mdb_ctf_arinfo_t r;
1233 ctf_encoding_t e;
1234 uint_t i, kind, limit;
1235 int d, sou;
1236 char buf[8];
1237 char *str;
1238
1239 if (!(pap->pa_flags & PA_SHOWVAL))
1240 return (0);
1241
1242 if (pap->pa_depth == pap->pa_maxdepth) {
1243 mdb_printf("[ ... ]");
1244 return (0);
1245 }
1246
1247 /*
1248 * Determine the base type and size of the array's content. If this
1249 * fails, we cannot print anything and just give up.
1250 */
1251 if (mdb_ctf_array_info(base, &r) == -1 ||
1252 mdb_ctf_type_resolve(r.mta_contents, &base) == -1 ||
1253 (eltsize = mdb_ctf_type_size(base)) == -1) {
1254 mdb_printf("[ ??? ] (%s)", mdb_strerror(errno));
1255 return (0);
1256 }
1257
1258 /*
1259 * Read a few bytes and determine if the content appears to be
1260 * printable ASCII characters. If so, read the entire array and
1261 * attempt to display it as a string if it is printable.
1262 */
1263 if ((pap->pa_arstrlim == MDB_ARR_NOLIMIT ||
1264 r.mta_nelems <= pap->pa_arstrlim) &&
1265 mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e) &&
1266 mdb_tgt_readstr(pap->pa_tgt, pap->pa_as, buf,
1267 MIN(sizeof (buf), r.mta_nelems), addr) > 0 && strisprint(buf)) {
1268
1269 str = mdb_alloc(r.mta_nelems + 1, UM_SLEEP | UM_GC);
1270 str[r.mta_nelems] = '\0';
1271
1272 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, str,
1273 r.mta_nelems, addr) != r.mta_nelems) {
1274 mdb_warn("failed to read char array at %llx", addr);
1275 return (1);
1276 }
1277
1278 if (strisprint(str)) {
1279 mdb_printf("[ \"%s\" ]", str);
1280 return (0);
1281 }
1282 }
1283
1284 if (pap->pa_armemlim != MDB_ARR_NOLIMIT)
1285 limit = MIN(r.mta_nelems, pap->pa_armemlim);
1286 else
1287 limit = r.mta_nelems;
1288
1289 if (limit == 0) {
1290 mdb_printf("[ ... ]");
1291 return (0);
1292 }
1293
1294 kind = mdb_ctf_type_kind(base);
1295 sou = IS_COMPOSITE(kind);
1296
1297 pa.pa_addr = addr; /* set base address to start of array */
1298 pa.pa_maxdepth = pa.pa_maxdepth - pa.pa_depth - 1;
1299 pa.pa_nest += pa.pa_depth + 1; /* nesting level is current depth + 1 */
1300 pa.pa_depth = 0; /* reset depth to 0 for new scope */
1301 pa.pa_prefix = NULL;
1302
1303 if (sou) {
1304 pa.pa_delim = "\n";
1305 mdb_printf("[\n");
1306 } else {
1307 pa.pa_flags &= ~(PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR);
1308 pa.pa_delim = ", ";
1309 mdb_printf("[ ");
1310 }
1311
1312 for (i = 0; i < limit; i++, pa.pa_addr += eltsize) {
1313 if (i == limit - 1 && !sou) {
1314 if (limit < r.mta_nelems)
1315 pa.pa_delim = ", ... ]";
1316 else
1317 pa.pa_delim = " ]";
1318 }
1319
1320 if (mdb_ctf_type_visit(r.mta_contents, elt_print, &pa) == -1) {
1321 mdb_warn("failed to print array data");
1322 return (1);
1323 }
1324 }
1325
1326 if (sou) {
1327 for (d = pa.pa_depth - 1; d >= 0; d--)
1328 print_close_sou(&pa, d);
1329
1330 if (limit < r.mta_nelems) {
1331 mdb_printf("%*s... ]",
1332 (pap->pa_depth + pap->pa_nest) * pap->pa_tab, "");
1333 } else {
1334 mdb_printf("%*s]",
1335 (pap->pa_depth + pap->pa_nest) * pap->pa_tab, "");
1336 }
1337 }
1338
1339 /* copy the hole array info, since it may have been grown */
1340 pap->pa_holes = pa.pa_holes;
1341 pap->pa_nholes = pa.pa_nholes;
1342
1343 return (0);
1344 }
1345
1346 /*
1347 * Print out a struct or union header. We need only print the open brace
1348 * because mdb_ctf_type_visit() itself will automatically recurse through
1349 * all members of the given struct or union.
1350 */
1351 /*ARGSUSED*/
1352 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)1353 print_sou(const char *type, const char *name, mdb_ctf_id_t id,
1354 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1355 {
1356 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1357
1358 /*
1359 * We have pretty-printing for some structures where displaying
1360 * structure contents has no value.
1361 */
1362 if (pap->pa_flags & PA_SHOWVAL) {
1363 if (strcmp(type, "in6_addr_t") == 0 ||
1364 strcmp(type, "struct in6_addr") == 0) {
1365 in6_addr_t in6addr;
1366
1367 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &in6addr,
1368 sizeof (in6addr), addr) != sizeof (in6addr)) {
1369 mdb_warn("failed to read %s pointer at %llx",
1370 name, addr);
1371 return (1);
1372 }
1373 mdb_printf("%N", &in6addr);
1374 /*
1375 * Don't print anything further down in the
1376 * structure.
1377 */
1378 pap->pa_nooutdepth = pap->pa_depth;
1379 return (0);
1380 }
1381 if (strcmp(type, "struct in_addr") == 0) {
1382 in_addr_t inaddr;
1383
1384 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &inaddr,
1385 sizeof (inaddr), addr) != sizeof (inaddr)) {
1386 mdb_warn("failed to read %s pointer at %llx",
1387 name, addr);
1388 return (1);
1389 }
1390 mdb_printf("%I", inaddr);
1391 pap->pa_nooutdepth = pap->pa_depth;
1392 return (0);
1393 }
1394 }
1395
1396 if (pap->pa_depth == pap->pa_maxdepth)
1397 mdb_printf("{ ... }");
1398 else
1399 mdb_printf("{");
1400 pap->pa_delim = "\n";
1401 return (0);
1402 }
1403
1404 /*
1405 * Print an enum value. We attempt to convert the value to the corresponding
1406 * enum name and print that if possible.
1407 */
1408 /*ARGSUSED*/
1409 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)1410 print_enum(const char *type, const char *name, mdb_ctf_id_t id,
1411 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1412 {
1413 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1414 const char *ename;
1415 int value;
1416 int isp2 = enum_is_p2(base);
1417 int flags = pap->pa_flags | (isp2 ? PA_INTHEX : 0);
1418
1419 if (!(flags & PA_SHOWVAL))
1420 return (0);
1421
1422 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
1423 &value, sizeof (value), addr) != sizeof (value)) {
1424 mdb_warn("failed to read %s integer at %llx", name, addr);
1425 return (1);
1426 }
1427
1428 if (flags & PA_INTHEX)
1429 mdb_printf("%#x", value);
1430 else
1431 mdb_printf("%#d", value);
1432
1433 (void) mdb_inc_indent(8);
1434 mdb_printf(" (");
1435
1436 if (!isp2 || enum_value_print_p2(base, value, 0) != 0) {
1437 ename = mdb_ctf_enum_name(base, value);
1438 if (ename == NULL) {
1439 ename = "???";
1440 }
1441 mdb_printf("%s", ename);
1442 }
1443 mdb_printf(")");
1444 (void) mdb_dec_indent(8);
1445
1446 return (0);
1447 }
1448
1449 /*
1450 * This will only get called if the structure isn't found in any available CTF
1451 * data.
1452 */
1453 /*ARGSUSED*/
1454 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)1455 print_tag(const char *type, const char *name, mdb_ctf_id_t id,
1456 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1457 {
1458 char basename[MDB_SYM_NAMLEN];
1459
1460 if (pap->pa_flags & PA_SHOWVAL)
1461 mdb_printf("; ");
1462
1463 if (mdb_ctf_type_name(base, basename, sizeof (basename)) != NULL)
1464 mdb_printf("<forward declaration of %s>", basename);
1465 else
1466 mdb_printf("<forward declaration of unknown type>");
1467
1468 return (0);
1469 }
1470
1471 static void
print_hole(printarg_t * pap,int depth,ulong_t off,ulong_t endoff)1472 print_hole(printarg_t *pap, int depth, ulong_t off, ulong_t endoff)
1473 {
1474 ulong_t bits = endoff - off;
1475 ulong_t size = bits / NBBY;
1476 ctf_encoding_t e;
1477
1478 static const char *const name = "<<HOLE>>";
1479 char type[MDB_SYM_NAMLEN];
1480
1481 int bitfield =
1482 (off % NBBY != 0 ||
1483 bits % NBBY != 0 ||
1484 size > 8 ||
1485 (size & (size - 1)) != 0);
1486
1487 ASSERT(off < endoff);
1488
1489 if (bits > NBBY * sizeof (uint64_t)) {
1490 ulong_t end;
1491
1492 /*
1493 * The hole is larger than the largest integer type. To
1494 * handle this, we split up the hole at 8-byte-aligned
1495 * boundaries, recursing to print each subsection. For
1496 * normal C structures, we'll loop at most twice.
1497 */
1498 for (; off < endoff; off = end) {
1499 end = P2END(off, NBBY * sizeof (uint64_t));
1500 if (end > endoff)
1501 end = endoff;
1502
1503 ASSERT((end - off) <= NBBY * sizeof (uint64_t));
1504 print_hole(pap, depth, off, end);
1505 }
1506 ASSERT(end == endoff);
1507
1508 return;
1509 }
1510
1511 if (bitfield)
1512 (void) mdb_snprintf(type, sizeof (type), "unsigned");
1513 else
1514 (void) mdb_snprintf(type, sizeof (type), "uint%d_t", bits);
1515
1516 if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR))
1517 mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, "");
1518
1519 if (pap->pa_flags & PA_SHOWADDR) {
1520 if (off % NBBY == 0)
1521 mdb_printf("%llx ", pap->pa_addr + off / NBBY);
1522 else
1523 mdb_printf("%llx.%lx ",
1524 pap->pa_addr + off / NBBY, off % NBBY);
1525 }
1526
1527 if (pap->pa_flags & PA_SHOWTYPE)
1528 mdb_printf("%s ", type);
1529
1530 if (pap->pa_flags & PA_SHOWNAME)
1531 mdb_printf("%s", name);
1532
1533 if (bitfield && (pap->pa_flags & PA_SHOWTYPE))
1534 mdb_printf(" :%d", bits);
1535
1536 mdb_printf("%s ", (pap->pa_flags & PA_SHOWVAL)? " =" : "");
1537
1538 /*
1539 * We fake up a ctf_encoding_t, and use print_int_val() to print
1540 * the value. Holes are always processed as unsigned integers.
1541 */
1542 bzero(&e, sizeof (e));
1543 e.cte_format = 0;
1544 e.cte_offset = 0;
1545 e.cte_bits = bits;
1546
1547 if (print_int_val(type, &e, off, pap) != 0)
1548 mdb_iob_discard(mdb.m_out);
1549 else
1550 mdb_iob_puts(mdb.m_out, pap->pa_delim);
1551 }
1552
1553 /*
1554 * The print_close_sou() function is called for each structure or union
1555 * which has been completed. For structures, we detect and print any holes
1556 * before printing the closing brace.
1557 */
1558 static void
print_close_sou(printarg_t * pap,int newdepth)1559 print_close_sou(printarg_t *pap, int newdepth)
1560 {
1561 int d = newdepth + pap->pa_nest;
1562
1563 if ((pap->pa_flags & PA_SHOWHOLES) && !pap->pa_holes[d].hi_isunion) {
1564 ulong_t end = pap->pa_holes[d + 1].hi_offset;
1565 ulong_t expected = pap->pa_holes[d].hi_offset;
1566
1567 if (end < expected)
1568 print_hole(pap, newdepth + 1, end, expected);
1569 }
1570 /* if the struct is an array element, print a comma after the } */
1571 mdb_printf("%*s}%s\n", d * pap->pa_tab, "",
1572 (newdepth == 0 && pap->pa_nest > 0)? "," : "");
1573 }
1574
1575 static printarg_f *const printfuncs[] = {
1576 print_int, /* CTF_K_INTEGER */
1577 print_float, /* CTF_K_FLOAT */
1578 print_ptr, /* CTF_K_POINTER */
1579 print_array, /* CTF_K_ARRAY */
1580 print_ptr, /* CTF_K_FUNCTION */
1581 print_sou, /* CTF_K_STRUCT */
1582 print_sou, /* CTF_K_UNION */
1583 print_enum, /* CTF_K_ENUM */
1584 print_tag /* CTF_K_FORWARD */
1585 };
1586
1587 /*
1588 * The elt_print function is used as the mdb_ctf_type_visit callback. For
1589 * each element, we print an appropriate name prefix and then call the
1590 * print subroutine for this type class in the array above.
1591 */
1592 static int
elt_print(const char * name,mdb_ctf_id_t id,mdb_ctf_id_t base,ulong_t off,int depth,void * data)1593 elt_print(const char *name, mdb_ctf_id_t id, mdb_ctf_id_t base,
1594 ulong_t off, int depth, void *data)
1595 {
1596 char type[MDB_SYM_NAMLEN + sizeof (" <<12345678...>>")];
1597 int kind, rc, d;
1598 printarg_t *pap = data;
1599
1600 for (d = pap->pa_depth - 1; d >= depth; d--) {
1601 if (d < pap->pa_nooutdepth)
1602 print_close_sou(pap, d);
1603 }
1604
1605 /*
1606 * Reset pa_nooutdepth if we've come back out of the structure we
1607 * didn't want to print.
1608 */
1609 if (depth <= pap->pa_nooutdepth)
1610 pap->pa_nooutdepth = (uint_t)-1;
1611
1612 if (depth > pap->pa_maxdepth || depth > pap->pa_nooutdepth)
1613 return (0);
1614
1615 if (!mdb_ctf_type_valid(base) ||
1616 (kind = mdb_ctf_type_kind(base)) == -1)
1617 return (-1); /* errno is set for us */
1618
1619 if (mdb_ctf_type_name(id, type, MDB_SYM_NAMLEN) == NULL)
1620 (void) strcpy(type, "(?)");
1621
1622 if (pap->pa_flags & PA_SHOWBASETYPE) {
1623 /*
1624 * If basetype is different and informative, concatenate
1625 * <<basetype>> (or <<baset...>> if it doesn't fit)
1626 *
1627 * We just use the end of the buffer to store the type name, and
1628 * only connect it up if that's necessary.
1629 */
1630
1631 char *type_end = type + strlen(type);
1632 char *basetype;
1633 size_t sz;
1634
1635 (void) strlcat(type, " <<", sizeof (type));
1636
1637 basetype = type + strlen(type);
1638 sz = sizeof (type) - (basetype - type);
1639
1640 *type_end = '\0'; /* restore the end of type for strcmp() */
1641
1642 if (mdb_ctf_type_name(base, basetype, sz) != NULL &&
1643 strcmp(basetype, type) != 0 &&
1644 strcmp(basetype, "struct ") != 0 &&
1645 strcmp(basetype, "enum ") != 0 &&
1646 strcmp(basetype, "union ") != 0) {
1647 type_end[0] = ' '; /* reconnect */
1648 if (strlcat(type, ">>", sizeof (type)) >= sizeof (type))
1649 (void) strlcpy(
1650 type + sizeof (type) - 6, "...>>", 6);
1651 }
1652 }
1653
1654 if (pap->pa_flags & PA_SHOWHOLES) {
1655 ctf_encoding_t e;
1656 ssize_t nsize;
1657 ulong_t newoff;
1658 holeinfo_t *hole;
1659 int extra = IS_COMPOSITE(kind)? 1 : 0;
1660
1661 /*
1662 * grow the hole array, if necessary
1663 */
1664 if (pap->pa_nest + depth + extra >= pap->pa_nholes) {
1665 int new = MAX(MAX(8, pap->pa_nholes * 2),
1666 pap->pa_nest + depth + extra + 1);
1667
1668 holeinfo_t *nhi = mdb_zalloc(
1669 sizeof (*nhi) * new, UM_NOSLEEP | UM_GC);
1670
1671 bcopy(pap->pa_holes, nhi,
1672 pap->pa_nholes * sizeof (*nhi));
1673
1674 pap->pa_holes = nhi;
1675 pap->pa_nholes = new;
1676 }
1677
1678 hole = &pap->pa_holes[depth + pap->pa_nest];
1679
1680 if (depth != 0 && off > hole->hi_offset)
1681 print_hole(pap, depth, hole->hi_offset, off);
1682
1683 /* compute the next expected offset */
1684 if (kind == CTF_K_INTEGER &&
1685 mdb_ctf_type_encoding(base, &e) == 0)
1686 newoff = off + e.cte_bits;
1687 else if ((nsize = mdb_ctf_type_size(base)) >= 0)
1688 newoff = off + nsize * NBBY;
1689 else {
1690 /* something bad happened, disable hole checking */
1691 newoff = -1UL; /* ULONG_MAX */
1692 }
1693
1694 hole->hi_offset = newoff;
1695
1696 if (IS_COMPOSITE(kind)) {
1697 hole->hi_isunion = (kind == CTF_K_UNION);
1698 hole++;
1699 hole->hi_offset = off;
1700 }
1701 }
1702
1703 if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR))
1704 mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, "");
1705
1706 if (pap->pa_flags & PA_SHOWADDR) {
1707 if (off % NBBY == 0)
1708 mdb_printf("%llx ", pap->pa_addr + off / NBBY);
1709 else
1710 mdb_printf("%llx.%lx ",
1711 pap->pa_addr + off / NBBY, off % NBBY);
1712 }
1713
1714 if ((pap->pa_flags & PA_SHOWTYPE)) {
1715 mdb_printf("%s", type);
1716 /*
1717 * We want to avoid printing a trailing space when
1718 * dealing with pointers in a structure, so we end
1719 * up with:
1720 *
1721 * label_t *t_onfault = 0
1722 *
1723 * If depth is zero, always print the trailing space unless
1724 * we also have a prefix.
1725 */
1726 if (type[strlen(type) - 1] != '*' ||
1727 (depth == 0 && (!(pap->pa_flags & PA_SHOWNAME) ||
1728 pap->pa_prefix == NULL)))
1729 mdb_printf(" ");
1730 }
1731
1732 if (pap->pa_flags & PA_SHOWNAME) {
1733 if (pap->pa_prefix != NULL && depth <= 1)
1734 mdb_printf("%s%s", pap->pa_prefix,
1735 (depth == 0) ? "" : pap->pa_suffix);
1736
1737 /*
1738 * Figure out if we're printing an anonymous struct or union. If
1739 * so, indicate that this is anonymous.
1740 */
1741 if (depth != 0 && *name == '\0' && (kind == CTF_K_STRUCT ||
1742 kind == CTF_K_UNION)) {
1743 name = "<anon>";
1744 }
1745
1746 mdb_printf("%s", name);
1747 }
1748
1749 if ((pap->pa_flags & PA_SHOWTYPE) && kind == CTF_K_INTEGER) {
1750 ctf_encoding_t e;
1751
1752 if (mdb_ctf_type_encoding(base, &e) == 0) {
1753 ulong_t bits = e.cte_bits;
1754 ulong_t size = bits / NBBY;
1755
1756 if (bits % NBBY != 0 ||
1757 off % NBBY != 0 ||
1758 size > 8 ||
1759 size != mdb_ctf_type_size(base))
1760 mdb_printf(" :%d", bits);
1761 }
1762 }
1763
1764 if (depth != 0 ||
1765 ((pap->pa_flags & PA_SHOWNAME) && pap->pa_prefix != NULL))
1766 mdb_printf("%s ", pap->pa_flags & PA_SHOWVAL ? " =" : "");
1767
1768 if (depth == 0 && pap->pa_prefix != NULL)
1769 name = pap->pa_prefix;
1770
1771 pap->pa_depth = depth;
1772 if (kind <= CTF_K_UNKNOWN || kind >= CTF_K_TYPEDEF) {
1773 mdb_warn("unknown ctf for %s type %s kind %d\n",
1774 name, type, kind);
1775 return (-1);
1776 }
1777 rc = printfuncs[kind - 1](type, name, id, base, off, pap);
1778
1779 if (rc != 0)
1780 mdb_iob_discard(mdb.m_out);
1781 else
1782 mdb_iob_puts(mdb.m_out, pap->pa_delim);
1783
1784 return (rc);
1785 }
1786
1787 /*
1788 * Special semantics for pipelines.
1789 */
1790 static int
pipe_print(mdb_ctf_id_t id,ulong_t off,void * data)1791 pipe_print(mdb_ctf_id_t id, ulong_t off, void *data)
1792 {
1793 printarg_t *pap = data;
1794 size_t size;
1795 static const char *const fsp[] = { "%#r", "%#r", "%#r", "%#llr" };
1796 uintptr_t value;
1797 uintptr_t addr = pap->pa_addr + off / NBBY;
1798 mdb_ctf_id_t base;
1799 int enum_value;
1800 ctf_encoding_t e;
1801
1802 union {
1803 uint64_t i8;
1804 uint32_t i4;
1805 uint16_t i2;
1806 uint8_t i1;
1807 } u;
1808
1809 if (mdb_ctf_type_resolve(id, &base) == -1) {
1810 mdb_warn("could not resolve type");
1811 return (-1);
1812 }
1813
1814 /*
1815 * If the user gives -a, then always print out the address of the
1816 * member.
1817 */
1818 if ((pap->pa_flags & PA_SHOWADDR)) {
1819 mdb_printf("%#lr\n", addr);
1820 return (0);
1821 }
1822
1823 again:
1824 switch (mdb_ctf_type_kind(base)) {
1825 case CTF_K_POINTER:
1826 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
1827 &value, sizeof (value), addr) != sizeof (value)) {
1828 mdb_warn("failed to read pointer at %p", addr);
1829 return (-1);
1830 }
1831 mdb_printf("%#lr\n", value);
1832 break;
1833
1834 case CTF_K_ENUM:
1835 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &enum_value,
1836 sizeof (enum_value), addr) != sizeof (enum_value)) {
1837 mdb_warn("failed to read enum at %llx", addr);
1838 return (-1);
1839 }
1840 mdb_printf("%#r\n", enum_value);
1841 break;
1842
1843 case CTF_K_INTEGER:
1844 if (mdb_ctf_type_encoding(base, &e) != 0) {
1845 mdb_warn("could not get type encoding\n");
1846 return (-1);
1847 }
1848
1849 /*
1850 * For immediate values, we just print out the value.
1851 */
1852 size = e.cte_bits / NBBY;
1853 if (is_bitfield(&e, off)) {
1854 return (print_bitfield(off, pap, &e));
1855 }
1856
1857 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size,
1858 addr) != (size_t)size) {
1859 mdb_warn("failed to read %lu bytes at %p",
1860 (ulong_t)size, pap->pa_addr);
1861 return (-1);
1862 }
1863
1864 switch (size) {
1865 case sizeof (uint8_t):
1866 mdb_printf(fsp[0], u.i1);
1867 break;
1868 case sizeof (uint16_t):
1869 mdb_printf(fsp[1], u.i2);
1870 break;
1871 case sizeof (uint32_t):
1872 mdb_printf(fsp[2], u.i4);
1873 break;
1874 case sizeof (uint64_t):
1875 mdb_printf(fsp[3], u.i8);
1876 break;
1877 }
1878 mdb_printf("\n");
1879 break;
1880
1881 case CTF_K_FUNCTION:
1882 case CTF_K_FLOAT:
1883 case CTF_K_ARRAY:
1884 case CTF_K_UNKNOWN:
1885 case CTF_K_STRUCT:
1886 case CTF_K_UNION:
1887 case CTF_K_FORWARD:
1888 /*
1889 * For these types, always print the address of the member
1890 */
1891 mdb_printf("%#lr\n", addr);
1892 break;
1893
1894 default:
1895 mdb_warn("unknown type %d", mdb_ctf_type_kind(base));
1896 break;
1897 }
1898
1899 return (0);
1900 }
1901
1902 static int
parse_delimiter(char ** strp)1903 parse_delimiter(char **strp)
1904 {
1905 switch (**strp) {
1906 case '\0':
1907 return (MEMBER_DELIM_DONE);
1908
1909 case '.':
1910 *strp = *strp + 1;
1911 return (MEMBER_DELIM_DOT);
1912
1913 case '[':
1914 *strp = *strp + 1;
1915 return (MEMBER_DELIM_LBR);
1916
1917 case '-':
1918 *strp = *strp + 1;
1919 if (**strp == '>') {
1920 *strp = *strp + 1;
1921 return (MEMBER_DELIM_PTR);
1922 }
1923 *strp = *strp - 1;
1924 /*FALLTHROUGH*/
1925 default:
1926 return (MEMBER_DELIM_ERR);
1927 }
1928 }
1929
1930 static int
deref(printarg_t * pap,size_t size)1931 deref(printarg_t *pap, size_t size)
1932 {
1933 uint32_t a32;
1934 mdb_tgt_as_t as = pap->pa_as;
1935 mdb_tgt_addr_t *ap = &pap->pa_addr;
1936
1937 if (size == sizeof (mdb_tgt_addr_t)) {
1938 if (mdb_tgt_aread(mdb.m_target, as, ap, size, *ap) == -1) {
1939 mdb_warn("could not dereference pointer %llx\n", *ap);
1940 return (-1);
1941 }
1942 } else {
1943 if (mdb_tgt_aread(mdb.m_target, as, &a32, size, *ap) == -1) {
1944 mdb_warn("could not dereference pointer %x\n", *ap);
1945 return (-1);
1946 }
1947
1948 *ap = (mdb_tgt_addr_t)a32;
1949 }
1950
1951 /*
1952 * We've dereferenced at least once, we must be on the real
1953 * target. If we were in the immediate target, reset to the real
1954 * target; it's reset as needed when we return to the print
1955 * routines.
1956 */
1957 if (pap->pa_tgt == pap->pa_immtgt)
1958 pap->pa_tgt = pap->pa_realtgt;
1959
1960 return (0);
1961 }
1962
1963 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)1964 parse_member(printarg_t *pap, const char *str, mdb_ctf_id_t id,
1965 mdb_ctf_id_t *idp, ulong_t *offp, int *last_deref)
1966 {
1967 int delim;
1968 char member[64];
1969 char buf[128];
1970 uint_t index;
1971 char *start = (char *)str;
1972 char *end;
1973 ulong_t off = 0;
1974 mdb_ctf_arinfo_t ar;
1975 mdb_ctf_id_t rid;
1976 int kind;
1977 ssize_t size;
1978 int non_array = FALSE;
1979
1980 /*
1981 * id always has the unresolved type for printing error messages
1982 * that include the type; rid always has the resolved type for
1983 * use in mdb_ctf_* calls. It is possible for this command to fail,
1984 * however, if the resolved type is in the parent and it is currently
1985 * unavailable. Note that we also can't print out the name of the
1986 * type, since that would also rely on looking up the resolved name.
1987 */
1988 if (mdb_ctf_type_resolve(id, &rid) != 0) {
1989 mdb_warn("failed to resolve type");
1990 return (-1);
1991 }
1992
1993 delim = parse_delimiter(&start);
1994 /*
1995 * If the user fails to specify an initial delimiter, guess -> for
1996 * pointer types and . for non-pointer types.
1997 */
1998 if (delim == MEMBER_DELIM_ERR)
1999 delim = (mdb_ctf_type_kind(rid) == CTF_K_POINTER) ?
2000 MEMBER_DELIM_PTR : MEMBER_DELIM_DOT;
2001
2002 *last_deref = FALSE;
2003
2004 while (delim != MEMBER_DELIM_DONE) {
2005 switch (delim) {
2006 case MEMBER_DELIM_PTR:
2007 kind = mdb_ctf_type_kind(rid);
2008 if (kind != CTF_K_POINTER) {
2009 mdb_warn("%s is not a pointer type\n",
2010 mdb_ctf_type_name(id, buf, sizeof (buf)));
2011 return (-1);
2012 }
2013
2014 size = mdb_ctf_type_size(id);
2015 if (deref(pap, size) != 0)
2016 return (-1);
2017
2018 (void) mdb_ctf_type_reference(rid, &id);
2019 (void) mdb_ctf_type_resolve(id, &rid);
2020
2021 off = 0;
2022 break;
2023
2024 case MEMBER_DELIM_DOT:
2025 kind = mdb_ctf_type_kind(rid);
2026 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
2027 mdb_warn("%s is not a struct or union type\n",
2028 mdb_ctf_type_name(id, buf, sizeof (buf)));
2029 return (-1);
2030 }
2031 break;
2032
2033 case MEMBER_DELIM_LBR:
2034 end = strchr(start, ']');
2035 if (end == NULL) {
2036 mdb_warn("no trailing ']'\n");
2037 return (-1);
2038 }
2039
2040 (void) mdb_snprintf(member, end - start + 1, "%s",
2041 start);
2042
2043 index = mdb_strtoull(member);
2044
2045 switch (mdb_ctf_type_kind(rid)) {
2046 case CTF_K_POINTER:
2047 size = mdb_ctf_type_size(rid);
2048
2049 if (deref(pap, size) != 0)
2050 return (-1);
2051
2052 (void) mdb_ctf_type_reference(rid, &id);
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
2065 if (index == 0 && non_array)
2066 *last_deref = TRUE;
2067 break;
2068
2069 case CTF_K_ARRAY:
2070 (void) mdb_ctf_array_info(rid, &ar);
2071
2072 if (index >= ar.mta_nelems) {
2073 mdb_warn("index %r is outside of "
2074 "array bounds [0 .. %r]\n",
2075 index, ar.mta_nelems - 1);
2076 }
2077
2078 id = ar.mta_contents;
2079 (void) mdb_ctf_type_resolve(id, &rid);
2080
2081 size = mdb_ctf_type_size(id);
2082 if (size <= 0) {
2083 mdb_warn("cannot dereference void "
2084 "type\n");
2085 return (-1);
2086 }
2087
2088 pap->pa_addr += index * size;
2089 off = 0;
2090 break;
2091
2092 default:
2093 mdb_warn("cannot index into non-array, "
2094 "non-pointer type\n");
2095 return (-1);
2096 }
2097
2098 start = end + 1;
2099 delim = parse_delimiter(&start);
2100 continue;
2101
2102 case MEMBER_DELIM_ERR:
2103 default:
2104 mdb_warn("'%c' is not a valid delimiter\n", *start);
2105 return (-1);
2106 }
2107
2108 *last_deref = FALSE;
2109 non_array = TRUE;
2110
2111 /*
2112 * Find the end of the member name; assume that a member
2113 * name is at least one character long.
2114 */
2115 for (end = start + 1; isalnum(*end) || *end == '_'; end++)
2116 continue;
2117
2118 (void) mdb_snprintf(member, end - start + 1, "%s", start);
2119
2120 if (mdb_ctf_member_info(rid, member, &off, &id) != 0) {
2121 mdb_warn("failed to find member %s of %s", member,
2122 mdb_ctf_type_name(id, buf, sizeof (buf)));
2123 return (-1);
2124 }
2125 (void) mdb_ctf_type_resolve(id, &rid);
2126
2127 pap->pa_addr += off / NBBY;
2128
2129 start = end;
2130 delim = parse_delimiter(&start);
2131 }
2132
2133 *idp = id;
2134 *offp = off;
2135
2136 return (0);
2137 }
2138
2139 static int
cmd_print_tab_common(mdb_tab_cookie_t * mcp,uint_t flags,int argc,const mdb_arg_t * argv)2140 cmd_print_tab_common(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
2141 const mdb_arg_t *argv)
2142 {
2143 char tn[MDB_SYM_NAMLEN];
2144 char member[64];
2145 int delim, kind;
2146 int ret = 0;
2147 mdb_ctf_id_t id, rid;
2148 mdb_ctf_arinfo_t ar;
2149 char *start, *end;
2150 ulong_t dul;
2151
2152 if (argc == 0 && !(flags & DCMD_TAB_SPACE))
2153 return (0);
2154
2155 if (argc == 0 && (flags & DCMD_TAB_SPACE))
2156 return (mdb_tab_complete_type(mcp, NULL, MDB_TABC_NOPOINT |
2157 MDB_TABC_NOARRAY));
2158
2159 if ((ret = mdb_tab_typename(&argc, &argv, tn, sizeof (tn))) < 0)
2160 return (ret);
2161
2162 if (argc == 1 && (!(flags & DCMD_TAB_SPACE) || ret == 1))
2163 return (mdb_tab_complete_type(mcp, tn, MDB_TABC_NOPOINT |
2164 MDB_TABC_NOARRAY));
2165
2166 if (argc == 1 && (flags & DCMD_TAB_SPACE))
2167 return (mdb_tab_complete_member(mcp, tn, NULL));
2168
2169 /*
2170 * This is the reason that tab completion was created. We're going to go
2171 * along and walk the delimiters until we find something a member that
2172 * we don't recognize, at which point we'll try and tab complete it.
2173 * Note that ::print takes multiple args, so this is going to operate on
2174 * whatever the last arg that we have is.
2175 */
2176 if (mdb_ctf_lookup_by_name(tn, &id) != 0)
2177 return (1);
2178
2179 (void) mdb_ctf_type_resolve(id, &rid);
2180 start = (char *)argv[argc-1].a_un.a_str;
2181 delim = parse_delimiter(&start);
2182
2183 /*
2184 * If we hit the case where we actually have no delimiters, than we need
2185 * to make sure that we properly set up the fields the loops would.
2186 */
2187 if (delim == MEMBER_DELIM_DONE)
2188 (void) mdb_snprintf(member, sizeof (member), "%s", start);
2189
2190 while (delim != MEMBER_DELIM_DONE) {
2191 switch (delim) {
2192 case MEMBER_DELIM_PTR:
2193 kind = mdb_ctf_type_kind(rid);
2194 if (kind != CTF_K_POINTER)
2195 return (1);
2196
2197 (void) mdb_ctf_type_reference(rid, &id);
2198 (void) mdb_ctf_type_resolve(id, &rid);
2199 break;
2200 case MEMBER_DELIM_DOT:
2201 kind = mdb_ctf_type_kind(rid);
2202 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
2203 return (1);
2204 break;
2205 case MEMBER_DELIM_LBR:
2206 end = strchr(start, ']');
2207 /*
2208 * We're not going to try and tab complete the indexes
2209 * here. So for now, punt on it. Also, we're not going
2210 * to try and validate you're within the bounds, just
2211 * that you get the type you asked for.
2212 */
2213 if (end == NULL)
2214 return (1);
2215
2216 switch (mdb_ctf_type_kind(rid)) {
2217 case CTF_K_POINTER:
2218 (void) mdb_ctf_type_reference(rid, &id);
2219 (void) mdb_ctf_type_resolve(id, &rid);
2220 break;
2221 case CTF_K_ARRAY:
2222 (void) mdb_ctf_array_info(rid, &ar);
2223 id = ar.mta_contents;
2224 (void) mdb_ctf_type_resolve(id, &rid);
2225 break;
2226 default:
2227 return (1);
2228 }
2229
2230 start = end + 1;
2231 delim = parse_delimiter(&start);
2232 break;
2233 case MEMBER_DELIM_ERR:
2234 default:
2235 break;
2236 }
2237
2238 for (end = start + 1; isalnum(*end) || *end == '_'; end++)
2239 continue;
2240
2241 (void) mdb_snprintf(member, end - start + 1, start);
2242
2243 /*
2244 * We are going to try to resolve this name as a member. There
2245 * are a few two different questions that we need to answer. The
2246 * first is do we recognize this member. The second is are we at
2247 * the end of the string. If we encounter a member that we don't
2248 * recognize before the end, then we have to error out and can't
2249 * complete it. But if there are no more delimiters then we can
2250 * try and complete it.
2251 */
2252 ret = mdb_ctf_member_info(rid, member, &dul, &id);
2253 start = end;
2254 delim = parse_delimiter(&start);
2255 if (ret != 0 && errno == EMDB_CTFNOMEMB) {
2256 if (delim != MEMBER_DELIM_DONE)
2257 return (1);
2258 continue;
2259 } else if (ret != 0)
2260 return (1);
2261
2262 if (delim == MEMBER_DELIM_DONE)
2263 return (mdb_tab_complete_member_by_id(mcp, rid,
2264 member));
2265
2266 (void) mdb_ctf_type_resolve(id, &rid);
2267 }
2268
2269 /*
2270 * If we've reached here, then we need to try and tab complete the last
2271 * field, which is currently member, based on the ctf type id that we
2272 * already have in rid.
2273 */
2274 return (mdb_tab_complete_member_by_id(mcp, rid, member));
2275 }
2276
2277 int
cmd_print_tab(mdb_tab_cookie_t * mcp,uint_t flags,int argc,const mdb_arg_t * argv)2278 cmd_print_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
2279 const mdb_arg_t *argv)
2280 {
2281 int i, dummy;
2282
2283 /*
2284 * This getopts is only here to make the tab completion work better when
2285 * including options in the ::print arguments. None of the values should
2286 * be used. This should only be updated with additional arguments, if
2287 * they are added to cmd_print.
2288 */
2289 i = mdb_getopts(argc, argv,
2290 'a', MDB_OPT_SETBITS, PA_SHOWADDR, &dummy,
2291 'C', MDB_OPT_SETBITS, TRUE, &dummy,
2292 'c', MDB_OPT_UINTPTR, &dummy,
2293 'd', MDB_OPT_SETBITS, PA_INTDEC, &dummy,
2294 'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &dummy,
2295 'i', MDB_OPT_SETBITS, TRUE, &dummy,
2296 'L', MDB_OPT_SETBITS, TRUE, &dummy,
2297 'l', MDB_OPT_UINTPTR, &dummy,
2298 'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &dummy,
2299 'p', MDB_OPT_SETBITS, TRUE, &dummy,
2300 's', MDB_OPT_UINTPTR, &dummy,
2301 'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &dummy,
2302 't', MDB_OPT_SETBITS, PA_SHOWTYPE, &dummy,
2303 'x', MDB_OPT_SETBITS, PA_INTHEX, &dummy,
2304 NULL);
2305
2306 argc -= i;
2307 argv += i;
2308
2309 return (cmd_print_tab_common(mcp, flags, argc, argv));
2310 }
2311
2312 /*
2313 * Recursively descend a print a given data structure. We create a struct of
2314 * the relevant print arguments and then call mdb_ctf_type_visit() to do the
2315 * traversal, using elt_print() as the callback for each element.
2316 */
2317 /*ARGSUSED*/
2318 int
cmd_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2319 cmd_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2320 {
2321 uintptr_t opt_c = MDB_ARR_NOLIMIT, opt_l = MDB_ARR_NOLIMIT;
2322 uint_t opt_C = FALSE, opt_L = FALSE, opt_p = FALSE, opt_i = FALSE;
2323 uintptr_t opt_s = (uintptr_t)-1ul;
2324 int uflags = (flags & DCMD_ADDRSPEC) ? PA_SHOWVAL : 0;
2325 mdb_ctf_id_t id;
2326 int err = DCMD_OK;
2327
2328 mdb_tgt_t *t = mdb.m_target;
2329 printarg_t pa;
2330 int d, i;
2331
2332 char s_name[MDB_SYM_NAMLEN];
2333 mdb_syminfo_t s_info;
2334 GElf_Sym sym;
2335
2336 /*
2337 * If a new option is added, make sure the getopts above in
2338 * cmd_print_tab is also updated.
2339 */
2340 i = mdb_getopts(argc, argv,
2341 'a', MDB_OPT_SETBITS, PA_SHOWADDR, &uflags,
2342 'C', MDB_OPT_SETBITS, TRUE, &opt_C,
2343 'c', MDB_OPT_UINTPTR, &opt_c,
2344 'd', MDB_OPT_SETBITS, PA_INTDEC, &uflags,
2345 'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &uflags,
2346 'i', MDB_OPT_SETBITS, TRUE, &opt_i,
2347 'L', MDB_OPT_SETBITS, TRUE, &opt_L,
2348 'l', MDB_OPT_UINTPTR, &opt_l,
2349 'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &uflags,
2350 'p', MDB_OPT_SETBITS, TRUE, &opt_p,
2351 's', MDB_OPT_UINTPTR, &opt_s,
2352 'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &uflags,
2353 't', MDB_OPT_SETBITS, PA_SHOWTYPE, &uflags,
2354 'x', MDB_OPT_SETBITS, PA_INTHEX, &uflags,
2355 NULL);
2356
2357 if (uflags & PA_INTHEX)
2358 uflags &= ~PA_INTDEC; /* -x and -d are mutually exclusive */
2359
2360 uflags |= PA_SHOWNAME;
2361
2362 if (opt_p && opt_i) {
2363 mdb_warn("-p and -i options are incompatible\n");
2364 return (DCMD_ERR);
2365 }
2366
2367 argc -= i;
2368 argv += i;
2369
2370 if (argc != 0 && argv->a_type == MDB_TYPE_STRING) {
2371 const char *t_name = s_name;
2372 int ret;
2373
2374 if (strchr("+-", argv->a_un.a_str[0]) != NULL)
2375 return (DCMD_USAGE);
2376
2377 if ((ret = args_to_typename(&argc, &argv, s_name,
2378 sizeof (s_name))) != 0)
2379 return (ret);
2380
2381 if (mdb_ctf_lookup_by_name(t_name, &id) != 0) {
2382 if (!(flags & DCMD_ADDRSPEC) || opt_i ||
2383 addr_to_sym(t, addr, s_name, sizeof (s_name),
2384 &sym, &s_info) == NULL ||
2385 mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) {
2386
2387 mdb_warn("failed to look up type %s", t_name);
2388 return (DCMD_ABORT);
2389 }
2390 } else {
2391 argc--;
2392 argv++;
2393 }
2394
2395 } else if (!(flags & DCMD_ADDRSPEC) || opt_i) {
2396 return (DCMD_USAGE);
2397
2398 } else if (addr_to_sym(t, addr, s_name, sizeof (s_name),
2399 &sym, &s_info) == NULL) {
2400 mdb_warn("no symbol information for %a", addr);
2401 return (DCMD_ERR);
2402
2403 } else if (mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) {
2404 mdb_warn("no type data available for %a [%u]", addr,
2405 s_info.sym_id);
2406 return (DCMD_ERR);
2407 }
2408
2409 pa.pa_tgt = mdb.m_target;
2410 pa.pa_realtgt = pa.pa_tgt;
2411 pa.pa_immtgt = NULL;
2412 pa.pa_as = opt_p ? MDB_TGT_AS_PHYS : MDB_TGT_AS_VIRT;
2413 pa.pa_armemlim = mdb.m_armemlim;
2414 pa.pa_arstrlim = mdb.m_arstrlim;
2415 pa.pa_delim = "\n";
2416 pa.pa_flags = uflags;
2417 pa.pa_nest = 0;
2418 pa.pa_tab = 4;
2419 pa.pa_prefix = NULL;
2420 pa.pa_suffix = NULL;
2421 pa.pa_holes = NULL;
2422 pa.pa_nholes = 0;
2423 pa.pa_depth = 0;
2424 pa.pa_maxdepth = opt_s;
2425 pa.pa_nooutdepth = (uint_t)-1;
2426
2427 if ((flags & DCMD_ADDRSPEC) && !opt_i)
2428 pa.pa_addr = opt_p ? mdb_get_dot() : addr;
2429 else
2430 pa.pa_addr = 0;
2431
2432 if (opt_i) {
2433 const char *vargv[2];
2434 uintmax_t dot = mdb_get_dot();
2435 size_t outsize = mdb_ctf_type_size(id);
2436 vargv[0] = (const char *)˙
2437 vargv[1] = (const char *)&outsize;
2438 pa.pa_immtgt = mdb_tgt_create(mdb_value_tgt_create,
2439 0, 2, vargv);
2440 pa.pa_tgt = pa.pa_immtgt;
2441 }
2442
2443 if (opt_c != MDB_ARR_NOLIMIT)
2444 pa.pa_arstrlim = opt_c;
2445 if (opt_C)
2446 pa.pa_arstrlim = MDB_ARR_NOLIMIT;
2447 if (opt_l != MDB_ARR_NOLIMIT)
2448 pa.pa_armemlim = opt_l;
2449 if (opt_L)
2450 pa.pa_armemlim = MDB_ARR_NOLIMIT;
2451
2452 if (argc > 0) {
2453 for (i = 0; i < argc; i++) {
2454 mdb_ctf_id_t mid;
2455 int last_deref;
2456 ulong_t off;
2457 int kind;
2458 char buf[MDB_SYM_NAMLEN];
2459
2460 mdb_tgt_t *oldtgt = pa.pa_tgt;
2461 mdb_tgt_as_t oldas = pa.pa_as;
2462 mdb_tgt_addr_t oldaddr = pa.pa_addr;
2463
2464 if (argv->a_type == MDB_TYPE_STRING) {
2465 const char *member = argv[i].a_un.a_str;
2466 mdb_ctf_id_t rid;
2467
2468 if (parse_member(&pa, member, id, &mid,
2469 &off, &last_deref) != 0) {
2470 err = DCMD_ABORT;
2471 goto out;
2472 }
2473
2474 /*
2475 * If the member string ends with a "[0]"
2476 * (last_deref * is true) and the type is a
2477 * structure or union, * print "->" rather
2478 * than "[0]." in elt_print.
2479 */
2480 (void) mdb_ctf_type_resolve(mid, &rid);
2481 kind = mdb_ctf_type_kind(rid);
2482 if (last_deref && IS_SOU(kind)) {
2483 char *end;
2484 (void) mdb_snprintf(buf, sizeof (buf),
2485 "%s", member);
2486 end = strrchr(buf, '[');
2487 *end = '\0';
2488 pa.pa_suffix = "->";
2489 member = &buf[0];
2490 } else if (IS_SOU(kind)) {
2491 pa.pa_suffix = ".";
2492 } else {
2493 pa.pa_suffix = "";
2494 }
2495
2496 pa.pa_prefix = member;
2497 } else {
2498 ulong_t moff;
2499
2500 moff = (ulong_t)argv[i].a_un.a_val;
2501
2502 if (mdb_ctf_offset_to_name(id, moff * NBBY,
2503 buf, sizeof (buf), 0, &mid, &off) == -1) {
2504 mdb_warn("invalid offset %lx\n", moff);
2505 err = DCMD_ABORT;
2506 goto out;
2507 }
2508
2509 pa.pa_prefix = buf;
2510 pa.pa_addr += moff - off / NBBY;
2511 pa.pa_suffix = strlen(buf) == 0 ? "" : ".";
2512 }
2513
2514 off %= NBBY;
2515 if (flags & DCMD_PIPE_OUT) {
2516 if (pipe_print(mid, off, &pa) != 0) {
2517 mdb_warn("failed to print type");
2518 err = DCMD_ERR;
2519 goto out;
2520 }
2521 } else if (off != 0) {
2522 mdb_ctf_id_t base;
2523 (void) mdb_ctf_type_resolve(mid, &base);
2524
2525 if (elt_print("", mid, base, off, 0,
2526 &pa) != 0) {
2527 mdb_warn("failed to print type");
2528 err = DCMD_ERR;
2529 goto out;
2530 }
2531 } else {
2532 if (mdb_ctf_type_visit(mid, elt_print,
2533 &pa) == -1) {
2534 mdb_warn("failed to print type");
2535 err = DCMD_ERR;
2536 goto out;
2537 }
2538
2539 for (d = pa.pa_depth - 1; d >= 0; d--)
2540 print_close_sou(&pa, d);
2541 }
2542
2543 pa.pa_depth = 0;
2544 pa.pa_tgt = oldtgt;
2545 pa.pa_as = oldas;
2546 pa.pa_addr = oldaddr;
2547 pa.pa_delim = "\n";
2548 }
2549
2550 } else if (flags & DCMD_PIPE_OUT) {
2551 if (pipe_print(id, 0, &pa) != 0) {
2552 mdb_warn("failed to print type");
2553 err = DCMD_ERR;
2554 goto out;
2555 }
2556 } else {
2557 if (mdb_ctf_type_visit(id, elt_print, &pa) == -1) {
2558 mdb_warn("failed to print type");
2559 err = DCMD_ERR;
2560 goto out;
2561 }
2562
2563 for (d = pa.pa_depth - 1; d >= 0; d--)
2564 print_close_sou(&pa, d);
2565 }
2566
2567 mdb_set_dot(addr + mdb_ctf_type_size(id));
2568 err = DCMD_OK;
2569 out:
2570 if (pa.pa_immtgt)
2571 mdb_tgt_destroy(pa.pa_immtgt);
2572 return (err);
2573 }
2574
2575 void
print_help(void)2576 print_help(void)
2577 {
2578 mdb_printf(
2579 "-a show address of object\n"
2580 "-C unlimit the length of character arrays\n"
2581 "-c limit limit the length of character arrays\n"
2582 "-d output values in decimal\n"
2583 "-h print holes in structures\n"
2584 "-i interpret address as data of the given type\n"
2585 "-L unlimit the length of standard arrays\n"
2586 "-l limit limit the length of standard arrays\n"
2587 "-n don't print pointers as symbol offsets\n"
2588 "-p interpret address as a physical memory address\n"
2589 "-s depth limit the recursion depth\n"
2590 "-T show type and <<base type>> of object\n"
2591 "-t show type of object\n"
2592 "-x output values in hexadecimal\n"
2593 "\n"
2594 "type may be omitted if the C type of addr can be inferred.\n"
2595 "\n"
2596 "Members may be specified with standard C syntax using the\n"
2597 "array indexing operator \"[index]\", structure member\n"
2598 "operator \".\", or structure pointer operator \"->\".\n"
2599 "\n"
2600 "Offsets must use the $[ expression ] syntax\n");
2601 }
2602
2603 static int
printf_signed(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt,boolean_t sign)2604 printf_signed(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt,
2605 boolean_t sign)
2606 {
2607 size_t size;
2608 mdb_ctf_id_t base;
2609 ctf_encoding_t e;
2610
2611 union {
2612 uint64_t ui8;
2613 uint32_t ui4;
2614 uint16_t ui2;
2615 uint8_t ui1;
2616 int64_t i8;
2617 int32_t i4;
2618 int16_t i2;
2619 int8_t i1;
2620 } u;
2621
2622 if (mdb_ctf_type_resolve(id, &base) == -1) {
2623 mdb_warn("could not resolve type");
2624 return (DCMD_ABORT);
2625 }
2626
2627 switch (mdb_ctf_type_kind(base)) {
2628 case CTF_K_ENUM:
2629 e.cte_format = CTF_INT_SIGNED;
2630 e.cte_offset = 0;
2631 e.cte_bits = mdb_ctf_type_size(id) * NBBY;
2632 break;
2633 case CTF_K_INTEGER:
2634 if (mdb_ctf_type_encoding(base, &e) != 0) {
2635 mdb_warn("could not get type encoding");
2636 return (DCMD_ABORT);
2637 }
2638 break;
2639 default:
2640 mdb_warn("expected integer type\n");
2641 return (DCMD_ABORT);
2642 }
2643
2644 if (sign)
2645 sign = e.cte_format & CTF_INT_SIGNED;
2646
2647 size = e.cte_bits / NBBY;
2648
2649 /*
2650 * Check to see if our life has been complicated by the presence of
2651 * a bitfield. If it has, we will print it using logic that is only
2652 * slightly different than that found in print_bitfield(), above. (In
2653 * particular, see the comments there for an explanation of the
2654 * endianness differences in this code.)
2655 */
2656 if (is_bitfield(&e, off)) {
2657 uint64_t mask = (1ULL << e.cte_bits) - 1;
2658 uint64_t value = 0;
2659 uint8_t *buf = (uint8_t *)&value;
2660 uint8_t shift;
2661 uint_t nbits;
2662
2663 /*
2664 * Our bitfield may straddle a byte boundary. We explicitly take
2665 * the offset of the bitfield within its byte into account when
2666 * determining the overall amount of data to copy and mask off
2667 * from the underlying data.
2668 */
2669 nbits = e.cte_bits + (off % NBBY);
2670 size = P2ROUNDUP(nbits, NBBY) / NBBY;
2671
2672 if (e.cte_bits > sizeof (value) * NBBY - 1) {
2673 mdb_printf("invalid bitfield size %u", e.cte_bits);
2674 return (DCMD_ABORT);
2675 }
2676
2677 /*
2678 * Our bitfield may straddle a byte boundary, if so, the
2679 * calculation of size may not correctly capture that. However,
2680 * off is relative to the entire bitfield, so we first have to
2681 * make that relative to the byte.
2682 */
2683 if ((off % NBBY) + e.cte_bits > NBBY * size) {
2684 size++;
2685 }
2686
2687 if (size > sizeof (value)) {
2688 mdb_warn("??? (total bitfield too large after "
2689 "alignment\n");
2690 return (DCMD_ABORT);
2691 }
2692
2693 #ifdef _BIG_ENDIAN
2694 buf += sizeof (value) - size;
2695 off += e.cte_bits;
2696 #endif
2697
2698 if (mdb_vread(buf, size, addr) == -1) {
2699 mdb_warn("failed to read %lu bytes at %p", size, addr);
2700 return (DCMD_ERR);
2701 }
2702
2703 shift = off % NBBY;
2704 #ifdef _BIG_ENDIAN
2705 shift = NBBY - shift;
2706 #endif
2707
2708 /*
2709 * If we have a bit offset within the byte, shift it down.
2710 */
2711 if (off % NBBY != 0)
2712 value >>= shift;
2713 value &= mask;
2714
2715 if (sign) {
2716 int sshift = sizeof (value) * NBBY - e.cte_bits;
2717 value = ((int64_t)value << sshift) >> sshift;
2718 }
2719
2720 mdb_printf(fmt, value);
2721 return (0);
2722 }
2723
2724 if (mdb_vread(&u.i8, size, addr) == -1) {
2725 mdb_warn("failed to read %lu bytes at %p", (ulong_t)size, addr);
2726 return (DCMD_ERR);
2727 }
2728
2729 switch (size) {
2730 case sizeof (uint8_t):
2731 mdb_printf(fmt, (uint64_t)(sign ? u.i1 : u.ui1));
2732 break;
2733 case sizeof (uint16_t):
2734 mdb_printf(fmt, (uint64_t)(sign ? u.i2 : u.ui2));
2735 break;
2736 case sizeof (uint32_t):
2737 mdb_printf(fmt, (uint64_t)(sign ? u.i4 : u.ui4));
2738 break;
2739 case sizeof (uint64_t):
2740 mdb_printf(fmt, (uint64_t)(sign ? u.i8 : u.ui8));
2741 break;
2742 }
2743
2744 return (0);
2745 }
2746
2747 static int
printf_int(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2748 printf_int(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2749 {
2750 return (printf_signed(id, addr, off, fmt, B_TRUE));
2751 }
2752
2753 static int
printf_uint(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2754 printf_uint(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2755 {
2756 return (printf_signed(id, addr, off, fmt, B_FALSE));
2757 }
2758
2759 /*ARGSUSED*/
2760 static int
printf_uint32(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2761 printf_uint32(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2762 {
2763 mdb_ctf_id_t base;
2764 ctf_encoding_t e;
2765 uint32_t value;
2766
2767 if (mdb_ctf_type_resolve(id, &base) == -1) {
2768 mdb_warn("could not resolve type\n");
2769 return (DCMD_ABORT);
2770 }
2771
2772 if (mdb_ctf_type_kind(base) != CTF_K_INTEGER ||
2773 mdb_ctf_type_encoding(base, &e) != 0 ||
2774 e.cte_bits / NBBY != sizeof (value)) {
2775 mdb_warn("expected 32-bit integer type\n");
2776 return (DCMD_ABORT);
2777 }
2778
2779 if (mdb_vread(&value, sizeof (value), addr) == -1) {
2780 mdb_warn("failed to read 32-bit value at %p", addr);
2781 return (DCMD_ERR);
2782 }
2783
2784 mdb_printf(fmt, value);
2785
2786 return (0);
2787 }
2788
2789 /*ARGSUSED*/
2790 static int
printf_ptr(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2791 printf_ptr(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2792 {
2793 uintptr_t value;
2794 mdb_ctf_id_t base;
2795
2796 if (mdb_ctf_type_resolve(id, &base) == -1) {
2797 mdb_warn("could not resolve type\n");
2798 return (DCMD_ABORT);
2799 }
2800
2801 if (mdb_ctf_type_kind(base) != CTF_K_POINTER) {
2802 mdb_warn("expected pointer type\n");
2803 return (DCMD_ABORT);
2804 }
2805
2806 if (mdb_vread(&value, sizeof (value), addr) == -1) {
2807 mdb_warn("failed to read pointer at %llx", addr);
2808 return (DCMD_ERR);
2809 }
2810
2811 mdb_printf(fmt, value);
2812
2813 return (0);
2814 }
2815
2816 /*ARGSUSED*/
2817 static int
printf_string(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2818 printf_string(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2819 {
2820 mdb_ctf_id_t base;
2821 mdb_ctf_arinfo_t r;
2822 char buf[1024];
2823 ssize_t size;
2824
2825 if (mdb_ctf_type_resolve(id, &base) == -1) {
2826 mdb_warn("could not resolve type");
2827 return (DCMD_ABORT);
2828 }
2829
2830 if (mdb_ctf_type_kind(base) == CTF_K_POINTER) {
2831 uintptr_t value;
2832
2833 if (mdb_vread(&value, sizeof (value), addr) == -1) {
2834 mdb_warn("failed to read pointer at %llx", addr);
2835 return (DCMD_ERR);
2836 }
2837
2838 if (mdb_readstr(buf, sizeof (buf) - 1, value) < 0) {
2839 mdb_warn("failed to read string at %llx", value);
2840 return (DCMD_ERR);
2841 }
2842
2843 mdb_printf(fmt, buf);
2844 return (0);
2845 }
2846
2847 if (mdb_ctf_type_kind(base) == CTF_K_ENUM) {
2848 const char *strval;
2849 int value;
2850
2851 if (mdb_vread(&value, sizeof (value), addr) == -1) {
2852 mdb_warn("failed to read pointer at %llx", addr);
2853 return (DCMD_ERR);
2854 }
2855
2856 if ((strval = mdb_ctf_enum_name(id, value))) {
2857 mdb_printf(fmt, strval);
2858 } else {
2859 (void) mdb_snprintf(buf, sizeof (buf), "<%d>", value);
2860 mdb_printf(fmt, buf);
2861 }
2862
2863 return (0);
2864 }
2865
2866 if (mdb_ctf_type_kind(base) != CTF_K_ARRAY) {
2867 mdb_warn("exepected pointer or array type\n");
2868 return (DCMD_ABORT);
2869 }
2870
2871 if (mdb_ctf_array_info(base, &r) == -1 ||
2872 mdb_ctf_type_resolve(r.mta_contents, &base) == -1 ||
2873 (size = mdb_ctf_type_size(base)) == -1) {
2874 mdb_warn("can't determine array type");
2875 return (DCMD_ABORT);
2876 }
2877
2878 if (size != 1) {
2879 mdb_warn("string format specifier requires "
2880 "an array of characters\n");
2881 return (DCMD_ABORT);
2882 }
2883
2884 bzero(buf, sizeof (buf));
2885
2886 if (r.mta_nelems != 0) {
2887 const size_t read_sz = MIN(r.mta_nelems, sizeof (buf) - 1);
2888 if (mdb_vread(buf, read_sz, addr) == -1) {
2889 mdb_warn("failed to read array at %p", addr);
2890 return (DCMD_ERR);
2891 }
2892 } else {
2893 /*
2894 * If the element count is zero, assume that the input is a
2895 * flexible length array which is NUL terminated.
2896 */
2897 if (mdb_readstr(buf, sizeof (buf), addr) < 0) {
2898 mdb_warn("failed to read string at %llx", addr);
2899 return (DCMD_ERR);
2900 }
2901 }
2902
2903 mdb_printf(fmt, buf);
2904
2905 return (0);
2906 }
2907
2908 /*ARGSUSED*/
2909 static int
printf_ipv6(mdb_ctf_id_t id,uintptr_t addr,ulong_t off,char * fmt)2910 printf_ipv6(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt)
2911 {
2912 mdb_ctf_id_t base;
2913 mdb_ctf_id_t ipv6_type, ipv6_base;
2914 in6_addr_t ipv6;
2915
2916 if (mdb_ctf_lookup_by_name("in6_addr_t", &ipv6_type) == -1) {
2917 mdb_warn("could not resolve in6_addr_t type\n");
2918 return (DCMD_ABORT);
2919 }
2920
2921 if (mdb_ctf_type_resolve(id, &base) == -1) {
2922 mdb_warn("could not resolve type\n");
2923 return (DCMD_ABORT);
2924 }
2925
2926 if (mdb_ctf_type_resolve(ipv6_type, &ipv6_base) == -1) {
2927 mdb_warn("could not resolve in6_addr_t type\n");
2928 return (DCMD_ABORT);
2929 }
2930
2931 if (mdb_ctf_type_cmp(base, ipv6_base) != 0) {
2932 mdb_warn("requires argument of type in6_addr_t\n");
2933 return (DCMD_ABORT);
2934 }
2935
2936 if (mdb_vread(&ipv6, sizeof (ipv6), addr) == -1) {
2937 mdb_warn("couldn't read in6_addr_t at %p", addr);
2938 return (DCMD_ERR);
2939 }
2940
2941 mdb_printf(fmt, &ipv6);
2942
2943 return (0);
2944 }
2945
2946 /*
2947 * To validate the format string specified to ::printf, we run the format
2948 * string through a very simple state machine that restricts us to a subset
2949 * of mdb_printf() functionality.
2950 */
2951 enum {
2952 PRINTF_NOFMT = 1, /* no current format specifier */
2953 PRINTF_PERC, /* processed '%' */
2954 PRINTF_FMT, /* processing format specifier */
2955 PRINTF_LEFT, /* processed '-', expecting width */
2956 PRINTF_WIDTH, /* processing width */
2957 PRINTF_QUES /* processed '?', expecting format */
2958 };
2959
2960 int
cmd_printf_tab(mdb_tab_cookie_t * mcp,uint_t flags,int argc,const mdb_arg_t * argv)2961 cmd_printf_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
2962 const mdb_arg_t *argv)
2963 {
2964 int ii;
2965 char *f;
2966
2967 /*
2968 * If argc doesn't have more than what should be the format string,
2969 * ignore it.
2970 */
2971 if (argc <= 1)
2972 return (0);
2973
2974 /*
2975 * Because we aren't leveraging the lex and yacc engine, we have to
2976 * manually walk the arguments to find both the first and last
2977 * open/close quote of the format string.
2978 */
2979 f = strchr(argv[0].a_un.a_str, '"');
2980 if (f == NULL)
2981 return (0);
2982
2983 f = strchr(f + 1, '"');
2984 if (f != NULL) {
2985 ii = 0;
2986 } else {
2987 for (ii = 1; ii < argc; ii++) {
2988 if (argv[ii].a_type != MDB_TYPE_STRING)
2989 continue;
2990 f = strchr(argv[ii].a_un.a_str, '"');
2991 if (f != NULL)
2992 break;
2993 }
2994 /* Never found */
2995 if (ii == argc)
2996 return (0);
2997 }
2998
2999 ii++;
3000 argc -= ii;
3001 argv += ii;
3002
3003 return (cmd_print_tab_common(mcp, flags, argc, argv));
3004 }
3005
3006 int
cmd_printf(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3007 cmd_printf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3008 {
3009 char type[MDB_SYM_NAMLEN];
3010 int i, nfmts = 0, ret;
3011 mdb_ctf_id_t id;
3012 const char *fmt, *member;
3013 char **fmts, *last, *dest, f;
3014 int (**funcs)(mdb_ctf_id_t, uintptr_t, ulong_t, char *);
3015 int state = PRINTF_NOFMT;
3016 printarg_t pa;
3017
3018 if (!(flags & DCMD_ADDRSPEC))
3019 return (DCMD_USAGE);
3020
3021 bzero(&pa, sizeof (pa));
3022 pa.pa_as = MDB_TGT_AS_VIRT;
3023 pa.pa_realtgt = pa.pa_tgt = mdb.m_target;
3024
3025 if (argc == 0 || argv[0].a_type != MDB_TYPE_STRING) {
3026 mdb_warn("expected a format string\n");
3027 return (DCMD_USAGE);
3028 }
3029
3030 /*
3031 * Our first argument is a format string; rip it apart and run it
3032 * through our state machine to validate that our input is within the
3033 * subset of mdb_printf() format strings that we allow.
3034 */
3035 fmt = argv[0].a_un.a_str;
3036 /*
3037 * 'dest' must be large enough to hold a copy of the format string,
3038 * plus a NUL and up to 2 additional characters for each conversion
3039 * in the format string. This gives us a bloat factor of 5/2 ~= 3.
3040 * e.g. "%d" (strlen of 2) --> "%lld\0" (need 5 bytes)
3041 */
3042 dest = mdb_zalloc(strlen(fmt) * 3, UM_SLEEP | UM_GC);
3043 fmts = mdb_zalloc(strlen(fmt) * sizeof (char *), UM_SLEEP | UM_GC);
3044 funcs = mdb_zalloc(strlen(fmt) * sizeof (void *), UM_SLEEP | UM_GC);
3045 last = dest;
3046
3047 for (i = 0; fmt[i] != '\0'; i++) {
3048 *dest++ = f = fmt[i];
3049
3050 switch (state) {
3051 case PRINTF_NOFMT:
3052 state = f == '%' ? PRINTF_PERC : PRINTF_NOFMT;
3053 break;
3054
3055 case PRINTF_PERC:
3056 state = f == '-' ? PRINTF_LEFT :
3057 f >= '0' && f <= '9' ? PRINTF_WIDTH :
3058 f == '?' ? PRINTF_QUES :
3059 f == '%' ? PRINTF_NOFMT : PRINTF_FMT;
3060 break;
3061
3062 case PRINTF_LEFT:
3063 state = f >= '0' && f <= '9' ? PRINTF_WIDTH :
3064 f == '?' ? PRINTF_QUES : PRINTF_FMT;
3065 break;
3066
3067 case PRINTF_WIDTH:
3068 state = f >= '0' && f <= '9' ? PRINTF_WIDTH :
3069 PRINTF_FMT;
3070 break;
3071
3072 case PRINTF_QUES:
3073 state = PRINTF_FMT;
3074 break;
3075 }
3076
3077 if (state != PRINTF_FMT)
3078 continue;
3079
3080 dest--;
3081
3082 /*
3083 * Now check that we have one of our valid format characters.
3084 */
3085 switch (f) {
3086 case 'a':
3087 case 'A':
3088 case 'p':
3089 funcs[nfmts] = printf_ptr;
3090 break;
3091
3092 case 'd':
3093 case 'q':
3094 case 'R':
3095 funcs[nfmts] = printf_int;
3096 *dest++ = 'l';
3097 *dest++ = 'l';
3098 break;
3099
3100 case 'I':
3101 funcs[nfmts] = printf_uint32;
3102 break;
3103
3104 case 'N':
3105 funcs[nfmts] = printf_ipv6;
3106 break;
3107
3108 case 'H':
3109 case 'o':
3110 case 'r':
3111 case 'u':
3112 case 'x':
3113 case 'X':
3114 funcs[nfmts] = printf_uint;
3115 *dest++ = 'l';
3116 *dest++ = 'l';
3117 break;
3118
3119 case 's':
3120 funcs[nfmts] = printf_string;
3121 break;
3122
3123 case 'Y':
3124 funcs[nfmts] = sizeof (time_t) == sizeof (int) ?
3125 printf_uint32 : printf_uint;
3126 break;
3127
3128 default:
3129 mdb_warn("illegal format string at or near "
3130 "'%c' (position %d)\n", f, i + 1);
3131 return (DCMD_ABORT);
3132 }
3133
3134 *dest++ = f;
3135 *dest++ = '\0';
3136 fmts[nfmts++] = last;
3137 last = dest;
3138 state = PRINTF_NOFMT;
3139 }
3140
3141 argc--;
3142 argv++;
3143
3144 /*
3145 * Now we expect a type name.
3146 */
3147 if ((ret = args_to_typename(&argc, &argv, type, sizeof (type))) != 0)
3148 return (ret);
3149
3150 argv++;
3151 argc--;
3152
3153 if (mdb_ctf_lookup_by_name(type, &id) != 0) {
3154 mdb_warn("failed to look up type %s", type);
3155 return (DCMD_ABORT);
3156 }
3157
3158 if (argc == 0) {
3159 mdb_warn("at least one member must be specified\n");
3160 return (DCMD_USAGE);
3161 }
3162
3163 if (argc != nfmts) {
3164 mdb_warn("%s format specifiers (found %d, expected %d)\n",
3165 argc > nfmts ? "missing" : "extra", nfmts, argc);
3166 return (DCMD_ABORT);
3167 }
3168
3169 for (i = 0; i < argc; i++) {
3170 mdb_ctf_id_t mid;
3171 ulong_t off;
3172 int ignored;
3173
3174 if (argv[i].a_type != MDB_TYPE_STRING) {
3175 mdb_warn("expected only type member arguments\n");
3176 return (DCMD_ABORT);
3177 }
3178
3179 if (strcmp((member = argv[i].a_un.a_str), ".") == 0) {
3180 /*
3181 * We allow "." to be specified to denote the current
3182 * value of dot.
3183 */
3184 if (funcs[i] != printf_ptr && funcs[i] != printf_uint &&
3185 funcs[i] != printf_int) {
3186 mdb_warn("expected integer or pointer format "
3187 "specifier for '.'\n");
3188 return (DCMD_ABORT);
3189 }
3190
3191 mdb_printf(fmts[i], mdb_get_dot());
3192 continue;
3193 }
3194
3195 pa.pa_addr = addr;
3196
3197 if (parse_member(&pa, member, id, &mid, &off, &ignored) != 0)
3198 return (DCMD_ABORT);
3199
3200 if ((ret = funcs[i](mid, pa.pa_addr, off, fmts[i])) != 0) {
3201 mdb_warn("failed to print member '%s'\n", member);
3202 return (ret);
3203 }
3204 }
3205
3206 mdb_printf("%s", last);
3207 mdb_set_dot(addr + mdb_ctf_type_size(id));
3208
3209 return (DCMD_OK);
3210 }
3211
3212 static char _mdb_printf_help[] =
3213 "The format string argument is a printf(3C)-like format string that is a\n"
3214 "subset of the format strings supported by mdb_printf(). The type argument\n"
3215 "is the name of a type to be used to interpret the memory referenced by dot.\n"
3216 "The member should either be a field in the specified structure, or the\n"
3217 "special member '.', denoting the value of dot (and treated as a pointer).\n"
3218 "The number of members must match the number of format specifiers in the\n"
3219 "format string.\n"
3220 "\n"
3221 "The following format specifiers are recognized by ::printf:\n"
3222 "\n"
3223 " %% Prints the '%' symbol.\n"
3224 " %a Prints the member in symbolic form.\n"
3225 " %d Prints the member as a decimal integer. If the member is a signed\n"
3226 " integer type, the output will be signed.\n"
3227 " %H Prints the member as a human-readable size.\n"
3228 " %I Prints the member as an IPv4 address (must be 32-bit integer type).\n"
3229 " %N Prints the member as an IPv6 address (must be of type in6_addr_t).\n"
3230 " %o Prints the member as an unsigned octal integer.\n"
3231 " %p Prints the member as a pointer, in hexadecimal.\n"
3232 " %q Prints the member in signed octal. Honk if you ever use this!\n"
3233 " %r Prints the member as an unsigned value in the current output radix.\n"
3234 " %R Prints the member as a signed value in the current output radix.\n"
3235 " %s Prints the member as a string (requires a pointer or an array of\n"
3236 " characters).\n"
3237 " %u Prints the member as an unsigned decimal integer.\n"
3238 " %x Prints the member in hexadecimal.\n"
3239 " %X Prints the member in hexadecimal, using the characters A-F as the\n"
3240 " digits for the values 10-15.\n"
3241 " %Y Prints the member as a time_t as the string "
3242 "'year month day HH:MM:SS'.\n"
3243 "\n"
3244 "The following field width specifiers are recognized by ::printf:\n"
3245 "\n"
3246 " %n Field width is set to the specified decimal value.\n"
3247 " %? Field width is set to the maximum width of a hexadecimal pointer\n"
3248 " value. This is 8 in an ILP32 environment, and 16 in an LP64\n"
3249 " environment.\n"
3250 "\n"
3251 "The following flag specifers are recognized by ::printf:\n"
3252 "\n"
3253 " %- Left-justify the output within the specified field width. If the\n"
3254 " width of the output is less than the specified field width, the\n"
3255 " output will be padded with blanks on the right-hand side. Without\n"
3256 " %-, values are right-justified by default.\n"
3257 "\n"
3258 " %0 Zero-fill the output field if the output is right-justified and the\n"
3259 " width of the output is less than the specified field width. Without\n"
3260 " %0, right-justified values are prepended with blanks in order to\n"
3261 " fill the field.\n"
3262 "\n"
3263 "Examples: \n"
3264 "\n"
3265 " ::walk proc | "
3266 "::printf \"%-6d %s\\n\" proc_t p_pidp->pid_id p_user.u_psargs\n"
3267 " ::walk thread | "
3268 "::printf \"%?p %3d %a\\n\" kthread_t . t_pri t_startpc\n"
3269 " ::walk zone | "
3270 "::printf \"%-40s %20s\\n\" zone_t zone_name zone_nodename\n"
3271 " ::walk ire | "
3272 "::printf \"%Y %I\\n\" ire_t ire_create_time ire_u.ire4_u.ire4_addr\n"
3273 "\n";
3274
3275 void
printf_help(void)3276 printf_help(void)
3277 {
3278 mdb_printf("%s", _mdb_printf_help);
3279 }
3280