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 by Delphix. All rights reserved.
28 * Copyright (c) 2012 Joyent, Inc. All rights reserved.
29 */
30
31 #include <mdb/mdb_modapi.h>
32 #include <mdb/mdb_target.h>
33 #include <mdb/mdb_argvec.h>
34 #include <mdb/mdb_string.h>
35 #include <mdb/mdb_stdlib.h>
36 #include <mdb/mdb_err.h>
37 #include <mdb/mdb_debug.h>
38 #include <mdb/mdb_fmt.h>
39 #include <mdb/mdb_ctf.h>
40 #include <mdb/mdb_ctf_impl.h>
41 #include <mdb/mdb.h>
42 #include <mdb/mdb_tab.h>
43
44 #include <sys/isa_defs.h>
45 #include <sys/param.h>
46 #include <sys/sysmacros.h>
47 #include <strings.h>
48 #include <libctf.h>
49 #include <ctype.h>
50
51 typedef struct holeinfo {
52 ulong_t hi_offset; /* expected offset */
53 uchar_t hi_isunion; /* represents a union */
54 } holeinfo_t;
55
56 typedef struct printarg {
57 mdb_tgt_t *pa_tgt; /* current target */
58 mdb_tgt_t *pa_realtgt; /* real target (for -i) */
59 mdb_tgt_t *pa_immtgt; /* immediate target (for -i) */
60 mdb_tgt_as_t pa_as; /* address space to use for i/o */
61 mdb_tgt_addr_t pa_addr; /* base address for i/o */
62 ulong_t pa_armemlim; /* limit on array elements to print */
63 ulong_t pa_arstrlim; /* limit on array chars to print */
64 const char *pa_delim; /* element delimiter string */
65 const char *pa_prefix; /* element prefix string */
66 const char *pa_suffix; /* element suffix string */
67 holeinfo_t *pa_holes; /* hole detection information */
68 int pa_nholes; /* size of holes array */
69 int pa_flags; /* formatting flags (see below) */
70 int pa_depth; /* previous depth */
71 int pa_nest; /* array nesting depth */
72 int pa_tab; /* tabstop width */
73 uint_t pa_maxdepth; /* Limit max depth */
74 } printarg_t;
75
76 #define PA_SHOWTYPE 0x001 /* print type name */
77 #define PA_SHOWBASETYPE 0x002 /* print base type name */
78 #define PA_SHOWNAME 0x004 /* print member name */
79 #define PA_SHOWADDR 0x008 /* print address */
80 #define PA_SHOWVAL 0x010 /* print value */
81 #define PA_SHOWHOLES 0x020 /* print holes in structs */
82 #define PA_INTHEX 0x040 /* print integer values in hex */
83 #define PA_INTDEC 0x080 /* print integer values in decimal */
84 #define PA_NOSYMBOLIC 0x100 /* don't print ptrs as func+offset */
85
86 #define IS_CHAR(e) \
87 (((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == \
88 (CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY)
89
90 #define COMPOSITE_MASK ((1 << CTF_K_STRUCT) | \
91 (1 << CTF_K_UNION) | (1 << CTF_K_ARRAY))
92 #define IS_COMPOSITE(k) (((1 << k) & COMPOSITE_MASK) != 0)
93
94 #define SOU_MASK ((1 << CTF_K_STRUCT) | (1 << CTF_K_UNION))
95 #define IS_SOU(k) (((1 << k) & SOU_MASK) != 0)
96
97 #define MEMBER_DELIM_ERR -1
98 #define MEMBER_DELIM_DONE 0
99 #define MEMBER_DELIM_PTR 1
100 #define MEMBER_DELIM_DOT 2
101 #define MEMBER_DELIM_LBR 3
102
103 typedef int printarg_f(const char *, const char *,
104 mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, printarg_t *);
105
106 static int elt_print(const char *, mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, int,
107 void *);
108 static void print_close_sou(printarg_t *, int);
109
110 /*
111 * Given an address, look up the symbol ID of the specified symbol in its
112 * containing module. We only support lookups for exact matches.
113 */
114 static const char *
115 addr_to_sym(mdb_tgt_t *t, uintptr_t addr, char *name, size_t namelen,
116 GElf_Sym *symp, mdb_syminfo_t *sip)
117 {
118 const mdb_map_t *mp;
119 const char *p;
120
121 if (mdb_tgt_lookup_by_addr(t, addr, MDB_TGT_SYM_EXACT, name,
122 namelen, NULL, NULL) == -1)
123 return (NULL); /* address does not exactly match a symbol */
124
125 if ((p = strrsplit(name, '`')) != NULL) {
126 if (mdb_tgt_lookup_by_name(t, name, p, symp, sip) == -1)
127 return (NULL);
128 return (p);
129 }
130
131 if ((mp = mdb_tgt_addr_to_map(t, addr)) == NULL)
132 return (NULL); /* address does not fall within a mapping */
133
134 if (mdb_tgt_lookup_by_name(t, mp->map_name, name, symp, sip) == -1)
135 return (NULL);
136
137 return (name);
138 }
139
140 /*
141 * This lets dcmds be a little fancy with their processing of type arguments
142 * while still treating them more or less as a single argument.
143 * For example, if a command is invokes like this:
144 *
145 * ::<dcmd> proc_t ...
146 *
147 * this function will just copy "proc_t" into the provided buffer. If the
148 * command is instead invoked like this:
149 *
150 * ::<dcmd> struct proc ...
151 *
152 * this function will place the string "struct proc" into the provided buffer
153 * and increment the caller's argv and argc. This allows the caller to still
154 * treat the type argument logically as it would an other atomic argument.
155 */
156 int
157 args_to_typename(int *argcp, const mdb_arg_t **argvp, char *buf, size_t len)
158 {
159 int argc = *argcp;
160 const mdb_arg_t *argv = *argvp;
161
162 if (argc < 1 || argv->a_type != MDB_TYPE_STRING)
163 return (DCMD_USAGE);
164
165 if (strcmp(argv->a_un.a_str, "struct") == 0 ||
166 strcmp(argv->a_un.a_str, "enum") == 0 ||
167 strcmp(argv->a_un.a_str, "union") == 0) {
168 if (argc <= 1) {
169 mdb_warn("%s is not a valid type\n", argv->a_un.a_str);
170 return (DCMD_ABORT);
171 }
172
173 if (argv[1].a_type != MDB_TYPE_STRING)
174 return (DCMD_USAGE);
175
176 (void) mdb_snprintf(buf, len, "%s %s",
177 argv[0].a_un.a_str, argv[1].a_un.a_str);
178
179 *argcp = argc - 1;
180 *argvp = argv + 1;
181 } else {
182 (void) mdb_snprintf(buf, len, "%s", argv[0].a_un.a_str);
183 }
184
185 return (0);
186 }
187
188 /*ARGSUSED*/
189 int
190 cmd_sizeof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
191 {
192 mdb_ctf_id_t id;
193 char tn[MDB_SYM_NAMLEN];
194 int ret;
195
196 if (flags & DCMD_ADDRSPEC)
197 return (DCMD_USAGE);
198
199 if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0)
200 return (ret);
201
202 if (argc != 1)
203 return (DCMD_USAGE);
204
205 if (mdb_ctf_lookup_by_name(tn, &id) != 0) {
206 mdb_warn("failed to look up type %s", tn);
207 return (DCMD_ERR);
208 }
209
210 if (flags & DCMD_PIPE_OUT)
211 mdb_printf("%#lr\n", mdb_ctf_type_size(id));
212 else
213 mdb_printf("sizeof (%s) = %#lr\n", tn, mdb_ctf_type_size(id));
214
215 return (DCMD_OK);
216 }
217
218 int
219 cmd_sizeof_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
220 const mdb_arg_t *argv)
221 {
222 char tn[MDB_SYM_NAMLEN];
223 int ret;
224
225 if (argc == 0 && !(flags & DCMD_TAB_SPACE))
226 return (0);
227
228 if (argc == 0 && (flags & DCMD_TAB_SPACE))
229 return (mdb_tab_complete_type(mcp, NULL, MDB_TABC_NOPOINT));
230
231 if ((ret = mdb_tab_typename(&argc, &argv, tn, sizeof (tn))) < 0)
232 return (ret);
233
234 if (argc == 1)
235 return (mdb_tab_complete_type(mcp, tn, MDB_TABC_NOPOINT));
236
237 return (0);
238 }
239
240 /*ARGSUSED*/
241 int
242 cmd_offsetof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
243 {
244 const char *member;
245 mdb_ctf_id_t id;
246 ulong_t off;
247 char tn[MDB_SYM_NAMLEN];
248 ssize_t sz;
249 int ret;
250
251 if (flags & DCMD_ADDRSPEC)
252 return (DCMD_USAGE);
253
254 if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0)
255 return (ret);
256
257 if (argc != 2 || argv[1].a_type != MDB_TYPE_STRING)
258 return (DCMD_USAGE);
259
260 if (mdb_ctf_lookup_by_name(tn, &id) != 0) {
261 mdb_warn("failed to look up type %s", tn);
262 return (DCMD_ERR);
263 }
264
265 member = argv[1].a_un.a_str;
266
267 if (mdb_ctf_member_info(id, member, &off, &id) != 0) {
268 mdb_warn("failed to find member %s of type %s", member, tn);
269 return (DCMD_ERR);
270 }
271
272 if (flags & DCMD_PIPE_OUT) {
273 if (off % NBBY != 0) {
274 mdb_warn("member %s of type %s is not byte-aligned\n",
275 member, tn);
276 return (DCMD_ERR);
277 }
278 mdb_printf("%#lr", off / NBBY);
279 return (DCMD_OK);
280 }
281
282 mdb_printf("offsetof (%s, %s) = %#lr",
283 tn, member, off / NBBY);
284 if (off % NBBY != 0)
285 mdb_printf(".%lr", off % NBBY);
286
287 if ((sz = mdb_ctf_type_size(id)) > 0)
288 mdb_printf(", sizeof (...->%s) = %#lr", member, sz);
289
290 mdb_printf("\n");
291
292 return (DCMD_OK);
293 }
294
295 /*ARGSUSED*/
296 static int
297 enum_prefix_scan_cb(const char *name, int value, void *arg)
298 {
299 char *str = arg;
300
301 /*
302 * This function is called with every name in the enum. We make
303 * "arg" be the common prefix, if any.
304 */
305 if (str[0] == 0) {
306 if (strlcpy(arg, name, MDB_SYM_NAMLEN) >= MDB_SYM_NAMLEN)
307 return (1);
308 return (0);
309 }
310
311 while (*name == *str) {
312 if (*str == 0) {
313 if (str != arg) {
314 str--; /* don't smother a name completely */
315 }
316 break;
317 }
318 name++;
319 str++;
320 }
321 *str = 0;
322
323 return (str == arg); /* only continue if prefix is non-empty */
324 }
325
326 struct enum_p2_info {
327 intmax_t e_value; /* value we're processing */
328 char *e_buf; /* buffer for holding names */
329 size_t e_size; /* size of buffer */
330 size_t e_prefix; /* length of initial prefix */
331 uint_t e_allprefix; /* apply prefix to first guy, too */
332 uint_t e_bits; /* bits seen */
333 uint8_t e_found; /* have we seen anything? */
334 uint8_t e_first; /* does buf contain the first one? */
335 uint8_t e_zero; /* have we seen a zero value? */
336 };
337
338 static int
339 enum_p2_cb(const char *name, int bit_arg, void *arg)
340 {
341 struct enum_p2_info *eiip = arg;
342 uintmax_t bit = bit_arg;
343
344 if (bit != 0 && !ISP2(bit))
345 return (1); /* non-power-of-2; abort processing */
346
347 if ((bit == 0 && eiip->e_zero) ||
348 (bit != 0 && (eiip->e_bits & bit) != 0)) {
349 return (0); /* already seen this value */
350 }
351
352 if (bit == 0)
353 eiip->e_zero = 1;
354 else
355 eiip->e_bits |= bit;
356
357 if (eiip->e_buf != NULL && (eiip->e_value & bit) != 0) {
358 char *buf = eiip->e_buf;
359 size_t prefix = eiip->e_prefix;
360
361 if (eiip->e_found) {
362 (void) strlcat(buf, "|", eiip->e_size);
363
364 if (eiip->e_first && !eiip->e_allprefix && prefix > 0) {
365 char c1 = buf[prefix];
366 char c2 = buf[prefix + 1];
367 buf[prefix] = '{';
368 buf[prefix + 1] = 0;
369 mdb_printf("%s", buf);
370 buf[prefix] = c1;
371 buf[prefix + 1] = c2;
372 mdb_printf("%s", buf + prefix);
373 } else {
374 mdb_printf("%s", buf);
375 }
376
377 }
378 /* skip the common prefix as necessary */
379 if ((eiip->e_found || eiip->e_allprefix) &&
380 strlen(name) > prefix)
381 name += prefix;
382
383 (void) strlcpy(eiip->e_buf, name, eiip->e_size);
384 eiip->e_first = !eiip->e_found;
385 eiip->e_found = 1;
386 }
387 return (0);
388 }
389
390 static int
391 enum_is_p2(mdb_ctf_id_t id)
392 {
393 struct enum_p2_info eii;
394 bzero(&eii, sizeof (eii));
395
396 return (mdb_ctf_type_kind(id) == CTF_K_ENUM &&
397 mdb_ctf_enum_iter(id, enum_p2_cb, &eii) == 0 &&
398 eii.e_bits != 0);
399 }
400
401 static int
402 enum_value_print_p2(mdb_ctf_id_t id, intmax_t value, uint_t allprefix)
403 {
404 struct enum_p2_info eii;
405 char prefix[MDB_SYM_NAMLEN + 2];
406 intmax_t missed;
407
408 bzero(&eii, sizeof (eii));
409
410 eii.e_value = value;
411 eii.e_buf = prefix;
412 eii.e_size = sizeof (prefix);
413 eii.e_allprefix = allprefix;
414
415 prefix[0] = 0;
416 if (mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0)
417 eii.e_prefix = strlen(prefix);
418
419 if (mdb_ctf_enum_iter(id, enum_p2_cb, &eii) != 0 || eii.e_bits == 0)
420 return (-1);
421
422 missed = (value & ~(intmax_t)eii.e_bits);
423
424 if (eii.e_found) {
425 /* push out any final value, with a | if we missed anything */
426 if (!eii.e_first)
427 (void) strlcat(prefix, "}", sizeof (prefix));
428 if (missed != 0)
429 (void) strlcat(prefix, "|", sizeof (prefix));
430
431 mdb_printf("%s", prefix);
432 }
433
434 if (!eii.e_found || missed) {
435 mdb_printf("%#llx", missed);
436 }
437
438 return (0);
439 }
440
441 struct enum_cbinfo {
442 uint_t e_flags;
443 const char *e_string; /* NULL for value searches */
444 size_t e_prefix;
445 intmax_t e_value;
446 uint_t e_found;
447 mdb_ctf_id_t e_id;
448 };
449 #define E_PRETTY 0x01
450 #define E_HEX 0x02
451 #define E_SEARCH_STRING 0x04
452 #define E_SEARCH_VALUE 0x08
453 #define E_ELIDE_PREFIX 0x10
454
455 static void
456 enum_print(struct enum_cbinfo *info, const char *name, int value)
457 {
458 uint_t flags = info->e_flags;
459 uint_t elide_prefix = (info->e_flags & E_ELIDE_PREFIX);
460
461 if (name != NULL && info->e_prefix && strlen(name) > info->e_prefix)
462 name += info->e_prefix;
463
464 if (flags & E_PRETTY) {
465 uint_t indent = 5 + ((flags & E_HEX) ? 8 : 11);
466
467 mdb_printf((flags & E_HEX)? "%8x " : "%11d ", value);
468 (void) mdb_inc_indent(indent);
469 if (name != NULL) {
470 mdb_iob_puts(mdb.m_out, name);
471 } else {
472 (void) enum_value_print_p2(info->e_id, value,
473 elide_prefix);
474 }
475 (void) mdb_dec_indent(indent);
476 mdb_printf("\n");
477 } else {
478 mdb_printf("%#r\n", value);
479 }
480 }
481
482 static int
483 enum_cb(const char *name, int value, void *arg)
484 {
485 struct enum_cbinfo *info = arg;
486 uint_t flags = info->e_flags;
487
488 if (flags & E_SEARCH_STRING) {
489 if (strcmp(name, info->e_string) != 0)
490 return (0);
491
492 } else if (flags & E_SEARCH_VALUE) {
493 if (value != info->e_value)
494 return (0);
495 }
496
497 enum_print(info, name, value);
498
499 info->e_found = 1;
500 return (0);
501 }
502
503 void
504 enum_help(void)
505 {
506 mdb_printf("%s",
507 "Without an address and name, print all values for the enumeration \"enum\".\n"
508 "With an address, look up a particular value in \"enum\". With a name, look\n"
509 "up a particular name in \"enum\".\n");
510
511 (void) mdb_dec_indent(2);
512 mdb_printf("\n%<b>OPTIONS%</b>\n");
513 (void) mdb_inc_indent(2);
514
515 mdb_printf("%s",
516 " -e remove common prefixes from enum names\n"
517 " -x report enum values in hexadecimal\n");
518 }
519
520 /*ARGSUSED*/
521 int
522 cmd_enum(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
523 {
524 struct enum_cbinfo info;
525
526 char type[MDB_SYM_NAMLEN + sizeof ("enum ")];
527 char tn2[MDB_SYM_NAMLEN + sizeof ("enum ")];
528 char prefix[MDB_SYM_NAMLEN];
529 mdb_ctf_id_t id;
530 mdb_ctf_id_t idr;
531
532 int i;
533 intmax_t search;
534 uint_t isp2;
535
536 info.e_flags = (flags & DCMD_PIPE_OUT)? 0 : E_PRETTY;
537 info.e_string = NULL;
538 info.e_value = 0;
539 info.e_found = 0;
540
541 i = mdb_getopts(argc, argv,
542 'e', MDB_OPT_SETBITS, E_ELIDE_PREFIX, &info.e_flags,
543 'x', MDB_OPT_SETBITS, E_HEX, &info.e_flags,
544 NULL);
545
546 argc -= i;
547 argv += i;
548
549 if ((i = args_to_typename(&argc, &argv, type, MDB_SYM_NAMLEN)) != 0)
550 return (i);
551
552 if (strchr(type, ' ') == NULL) {
553 /*
554 * Check as an enumeration tag first, and fall back
555 * to checking for a typedef. Yes, this means that
556 * anonymous enumerations whose typedefs conflict with
557 * an enum tag can't be accessed. Don't do that.
558 */
559 (void) mdb_snprintf(tn2, sizeof (tn2), "enum %s", type);
560
561 if (mdb_ctf_lookup_by_name(tn2, &id) == 0) {
562 (void) strcpy(type, tn2);
563 } else if (mdb_ctf_lookup_by_name(type, &id) != 0) {
564 mdb_warn("types '%s', '%s'", tn2, type);
565 return (DCMD_ERR);
566 }
567 } else {
568 if (mdb_ctf_lookup_by_name(type, &id) != 0) {
569 mdb_warn("'%s'", type);
570 return (DCMD_ERR);
571 }
572 }
573
574 /* resolve it, and make sure we're looking at an enumeration */
575 if (mdb_ctf_type_resolve(id, &idr) == -1) {
576 mdb_warn("unable to resolve '%s'", type);
577 return (DCMD_ERR);
578 }
579 if (mdb_ctf_type_kind(idr) != CTF_K_ENUM) {
580 mdb_warn("'%s': not an enumeration\n", type);
581 return (DCMD_ERR);
582 }
583
584 info.e_id = idr;
585
586 if (argc > 2)
587 return (DCMD_USAGE);
588
589 if (argc == 2) {
590 if (flags & DCMD_ADDRSPEC) {
591 mdb_warn("may only specify one of: name, address\n");
592 return (DCMD_USAGE);
593 }
594
595 if (argv[1].a_type == MDB_TYPE_STRING) {
596 info.e_flags |= E_SEARCH_STRING;
597 info.e_string = argv[1].a_un.a_str;
598 } else if (argv[1].a_type == MDB_TYPE_IMMEDIATE) {
599 info.e_flags |= E_SEARCH_VALUE;
600 search = argv[1].a_un.a_val;
601 } else {
602 return (DCMD_USAGE);
603 }
604 }
605
606 if (flags & DCMD_ADDRSPEC) {
607 info.e_flags |= E_SEARCH_VALUE;
608 search = mdb_get_dot();
609 }
610
611 if (info.e_flags & E_SEARCH_VALUE) {
612 if ((int)search != search) {
613 mdb_warn("value '%lld' out of enumeration range\n",
614 search);
615 }
616 info.e_value = search;
617 }
618
619 isp2 = enum_is_p2(idr);
620 if (isp2)
621 info.e_flags |= E_HEX;
622
623 if (DCMD_HDRSPEC(flags) && (info.e_flags & E_PRETTY)) {
624 if (info.e_flags & E_HEX)
625 mdb_printf("%<u>%8s %-64s%</u>\n", "VALUE", "NAME");
626 else
627 mdb_printf("%<u>%11s %-64s%</u>\n", "VALUE", "NAME");
628 }
629
630 /* if the enum is a power-of-two one, process it that way */
631 if ((info.e_flags & E_SEARCH_VALUE) && isp2) {
632 enum_print(&info, NULL, info.e_value);
633 return (DCMD_OK);
634 }
635
636 prefix[0] = 0;
637 if ((info.e_flags & E_ELIDE_PREFIX) &&
638 mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0)
639 info.e_prefix = strlen(prefix);
640
641 if (mdb_ctf_enum_iter(idr, enum_cb, &info) == -1) {
642 mdb_warn("cannot walk '%s' as enum", type);
643 return (DCMD_ERR);
644 }
645
646 if (info.e_found == 0 &&
647 (info.e_flags & (E_SEARCH_STRING | E_SEARCH_VALUE)) != 0) {
648 if (info.e_flags & E_SEARCH_STRING)
649 mdb_warn("name \"%s\" not in '%s'\n", info.e_string,
650 type);
651 else
652 mdb_warn("value %#lld not in '%s'\n", info.e_value,
653 type);
654
655 return (DCMD_ERR);
656 }
657
658 return (DCMD_OK);
659 }
660
661 static int
662 setup_vcb(const char *name, uintptr_t addr)
663 {
664 const char *p;
665 mdb_var_t *v;
666
667 if ((v = mdb_nv_lookup(&mdb.m_nv, name)) == NULL) {
668 if ((p = strbadid(name)) != NULL) {
669 mdb_warn("'%c' may not be used in a variable "
670 "name\n", *p);
671 return (DCMD_ABORT);
672 }
673
674 if ((v = mdb_nv_insert(&mdb.m_nv, name, NULL, addr, 0)) == NULL)
675 return (DCMD_ERR);
676 } else {
677 if (v->v_flags & MDB_NV_RDONLY) {
678 mdb_warn("variable %s is read-only\n", name);
679 return (DCMD_ABORT);
680 }
681 }
682
683 /*
684 * If there already exists a vcb for this variable, we may be
685 * calling the dcmd in a loop. We only create a vcb for this
686 * variable on the first invocation.
687 */
688 if (mdb_vcb_find(v, mdb.m_frame) == NULL)
689 mdb_vcb_insert(mdb_vcb_create(v), mdb.m_frame);
690
691 return (0);
692 }
693
694 /*ARGSUSED*/
695 int
696 cmd_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
697 {
698 mdb_ctf_id_t id;
699 ulong_t offset;
700 uintptr_t a, tmp;
701 int ret;
702
703 if (!(flags & DCMD_ADDRSPEC) || argc == 0)
704 return (DCMD_USAGE);
705
706 if (argv->a_type != MDB_TYPE_STRING) {
707 /*
708 * We are being given a raw offset in lieu of a type and
709 * member; confirm the arguments.
710 */
711 if (argv->a_type != MDB_TYPE_IMMEDIATE)
712 return (DCMD_USAGE);
713
714 offset = argv->a_un.a_val;
715
716 argv++;
717 argc--;
718
719 if (offset % sizeof (uintptr_t)) {
720 mdb_warn("offset must fall on a word boundary\n");
721 return (DCMD_ABORT);
722 }
723 } else {
724 const char *member;
725 char buf[MDB_SYM_NAMLEN];
726 int ret;
727
728 ret = args_to_typename(&argc, &argv, buf, sizeof (buf));
729 if (ret != 0)
730 return (ret);
731
732 if (mdb_ctf_lookup_by_name(buf, &id) != 0) {
733 mdb_warn("failed to look up type %s", buf);
734 return (DCMD_ABORT);
735 }
736
737 argv++;
738 argc--;
739
740 if (argc < 1 || argv->a_type != MDB_TYPE_STRING)
741 return (DCMD_USAGE);
742
743 member = argv->a_un.a_str;
744
745 argv++;
746 argc--;
747
748 if (mdb_ctf_offsetof(id, member, &offset) != 0) {
749 mdb_warn("failed to find member %s of type %s",
750 member, buf);
751 return (DCMD_ABORT);
752 }
753
754 if (offset % (sizeof (uintptr_t) * NBBY) != 0) {
755 mdb_warn("%s is not a word-aligned member\n", member);
756 return (DCMD_ABORT);
757 }
758
759 offset /= NBBY;
760 }
761
762 /*
763 * If we have any unchewed arguments, a variable name must be present.
764 */
765 if (argc == 1) {
766 if (argv->a_type != MDB_TYPE_STRING)
767 return (DCMD_USAGE);
768
769 if ((ret = setup_vcb(argv->a_un.a_str, addr)) != 0)
770 return (ret);
771
772 } else if (argc != 0) {
773 return (DCMD_USAGE);
774 }
775
776 a = addr;
777
778 do {
779 mdb_printf("%lr\n", a);
780
781 if (mdb_vread(&tmp, sizeof (tmp), a + offset) == -1) {
782 mdb_warn("failed to read next pointer from object %p",
783 a);
784 return (DCMD_ERR);
785 }
786
787 a = tmp;
788 } while (a != addr && a != NULL);
789
790 return (DCMD_OK);
791 }
792
793 int
794 cmd_array(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
795 {
796 mdb_ctf_id_t id;
797 ssize_t elemsize = 0;
798 char tn[MDB_SYM_NAMLEN];
799 int ret, nelem = -1;
800
801 mdb_tgt_t *t = mdb.m_target;
802 GElf_Sym sym;
803 mdb_ctf_arinfo_t ar;
804 mdb_syminfo_t s_info;
805
806 if (!(flags & DCMD_ADDRSPEC))
807 return (DCMD_USAGE);
808
809 if (argc >= 2) {
810 ret = args_to_typename(&argc, &argv, tn, sizeof (tn));
811 if (ret != 0)
812 return (ret);
813
814 if (argc == 1) /* unquoted compound type without count */
815 return (DCMD_USAGE);
816
817 if (mdb_ctf_lookup_by_name(tn, &id) != 0) {
818 mdb_warn("failed to look up type %s", tn);
819 return (DCMD_ABORT);
820 }
821
822 if (argv[1].a_type == MDB_TYPE_IMMEDIATE)
823 nelem = argv[1].a_un.a_val;
824 else
825 nelem = mdb_strtoull(argv[1].a_un.a_str);
826
827 elemsize = mdb_ctf_type_size(id);
828 } else if (addr_to_sym(t, addr, tn, sizeof (tn), &sym, &s_info)
829 != NULL && mdb_ctf_lookup_by_symbol(&sym, &s_info, &id)
830 == 0 && mdb_ctf_type_kind(id) == CTF_K_ARRAY &&
831 mdb_ctf_array_info(id, &ar) != -1) {
832 elemsize = mdb_ctf_type_size(id) / ar.mta_nelems;
833 nelem = ar.mta_nelems;
834 } else {
835 mdb_warn("no symbol information for %a", addr);
836 return (DCMD_ERR);
837 }
838
839 if (argc == 3 || argc == 1) {
840 if (argv[argc - 1].a_type != MDB_TYPE_STRING)
841 return (DCMD_USAGE);
842
843 if ((ret = setup_vcb(argv[argc - 1].a_un.a_str, addr)) != 0)
844 return (ret);
845
846 } else if (argc > 3) {
847 return (DCMD_USAGE);
848 }
849
850 for (; nelem > 0; nelem--) {
851 mdb_printf("%lr\n", addr);
852 addr = addr + elemsize;
853 }
854
855 return (DCMD_OK);
856 }
857
858 /*
859 * Print an integer bitfield in hexadecimal by reading the enclosing byte(s)
860 * and then shifting and masking the data in the lower bits of a uint64_t.
861 */
862 static int
863 print_bitfield(ulong_t off, printarg_t *pap, ctf_encoding_t *ep)
864 {
865 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
866 size_t size = (ep->cte_bits + (NBBY - 1)) / NBBY;
867 uint64_t mask = (1ULL << ep->cte_bits) - 1;
868 uint64_t value = 0;
869 uint8_t *buf = (uint8_t *)&value;
870 uint8_t shift;
871
872 const char *format;
873
874 if (!(pap->pa_flags & PA_SHOWVAL))
875 return (0);
876
877 if (ep->cte_bits > sizeof (value) * NBBY - 1) {
878 mdb_printf("??? (invalid bitfield size %u)", ep->cte_bits);
879 return (0);
880 }
881
882 /*
883 * On big-endian machines, we need to adjust the buf pointer to refer
884 * to the lowest 'size' bytes in 'value', and we need shift based on
885 * the offset from the end of the data, not the offset of the start.
886 */
887 #ifdef _BIG_ENDIAN
888 buf += sizeof (value) - size;
889 off += ep->cte_bits;
890 #endif
891 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, buf, size, addr) != size) {
892 mdb_warn("failed to read %lu bytes at %llx",
893 (ulong_t)size, addr);
894 return (1);
895 }
896
897 shift = off % NBBY;
898
899 /*
900 * Offsets are counted from opposite ends on little- and
901 * big-endian machines.
902 */
903 #ifdef _BIG_ENDIAN
904 shift = NBBY - shift;
905 #endif
906
907 /*
908 * If the bits we want do not begin on a byte boundary, shift the data
909 * right so that the value is in the lowest 'cte_bits' of 'value'.
910 */
911 if (off % NBBY != 0)
912 value >>= shift;
913 value &= mask;
914
915 /*
916 * We default to printing signed bitfields as decimals,
917 * and unsigned bitfields in hexadecimal. If they specify
918 * hexadecimal, we treat the field as unsigned.
919 */
920 if ((pap->pa_flags & PA_INTHEX) ||
921 !(ep->cte_format & CTF_INT_SIGNED)) {
922 format = (pap->pa_flags & PA_INTDEC)? "%#llu" : "%#llx";
923 } else {
924 int sshift = sizeof (value) * NBBY - ep->cte_bits;
925
926 /* sign-extend value, and print as a signed decimal */
927 value = ((int64_t)value << sshift) >> sshift;
928 format = "%#lld";
929 }
930 mdb_printf(format, value);
931
932 return (0);
933 }
934
935 /*
936 * Print out a character or integer value. We use some simple heuristics,
937 * described below, to determine the appropriate radix to use for output.
938 */
939 static int
940 print_int_val(const char *type, ctf_encoding_t *ep, ulong_t off,
941 printarg_t *pap)
942 {
943 static const char *const sformat[] = { "%#d", "%#d", "%#d", "%#lld" };
944 static const char *const uformat[] = { "%#u", "%#u", "%#u", "%#llu" };
945 static const char *const xformat[] = { "%#x", "%#x", "%#x", "%#llx" };
946
947 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
948 const char *const *fsp;
949 size_t size;
950
951 union {
952 uint64_t i8;
953 uint32_t i4;
954 uint16_t i2;
955 uint8_t i1;
956 time_t t;
957 } u;
958
959 if (!(pap->pa_flags & PA_SHOWVAL))
960 return (0);
961
962 if (ep->cte_format & CTF_INT_VARARGS) {
963 mdb_printf("...\n");
964 return (0);
965 }
966
967 /*
968 * If the size is not a power-of-two number of bytes in the range 1-8
969 * then we assume it is a bitfield and print it as such.
970 */
971 size = ep->cte_bits / NBBY;
972 if (size > 8 || (ep->cte_bits % NBBY) != 0 || (size & (size - 1)) != 0)
973 return (print_bitfield(off, pap, ep));
974
975 if (IS_CHAR(*ep)) {
976 mdb_printf("'");
977 if (mdb_fmt_print(pap->pa_tgt, pap->pa_as,
978 addr, 1, 'C') == addr)
979 return (1);
980 mdb_printf("'");
981 return (0);
982 }
983
984 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, addr) != size) {
985 mdb_warn("failed to read %lu bytes at %llx",
986 (ulong_t)size, addr);
987 return (1);
988 }
989
990 /*
991 * We pretty-print time_t values as a calendar date and time.
992 */
993 if (!(pap->pa_flags & (PA_INTHEX | PA_INTDEC)) &&
994 strcmp(type, "time_t") == 0 && u.t != 0) {
995 mdb_printf("%Y", u.t);
996 return (0);
997 }
998
999 /*
1000 * The default format is hexadecimal.
1001 */
1002 if (!(pap->pa_flags & PA_INTDEC))
1003 fsp = xformat;
1004 else if (ep->cte_format & CTF_INT_SIGNED)
1005 fsp = sformat;
1006 else
1007 fsp = uformat;
1008
1009 switch (size) {
1010 case sizeof (uint8_t):
1011 mdb_printf(fsp[0], u.i1);
1012 break;
1013 case sizeof (uint16_t):
1014 mdb_printf(fsp[1], u.i2);
1015 break;
1016 case sizeof (uint32_t):
1017 mdb_printf(fsp[2], u.i4);
1018 break;
1019 case sizeof (uint64_t):
1020 mdb_printf(fsp[3], u.i8);
1021 break;
1022 }
1023 return (0);
1024 }
1025
1026 /*ARGSUSED*/
1027 static int
1028 print_int(const char *type, const char *name, mdb_ctf_id_t id,
1029 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1030 {
1031 ctf_encoding_t e;
1032
1033 if (!(pap->pa_flags & PA_SHOWVAL))
1034 return (0);
1035
1036 if (mdb_ctf_type_encoding(base, &e) != 0) {
1037 mdb_printf("??? (%s)", mdb_strerror(errno));
1038 return (0);
1039 }
1040
1041 return (print_int_val(type, &e, off, pap));
1042 }
1043
1044 /*
1045 * Print out a floating point value. We only provide support for floats in
1046 * the ANSI-C float, double, and long double formats.
1047 */
1048 /*ARGSUSED*/
1049 static int
1050 print_float(const char *type, const char *name, mdb_ctf_id_t id,
1051 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1052 {
1053 #ifndef _KMDB
1054 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1055 ctf_encoding_t e;
1056
1057 union {
1058 float f;
1059 double d;
1060 long double ld;
1061 } u;
1062
1063 if (!(pap->pa_flags & PA_SHOWVAL))
1064 return (0);
1065
1066 if (mdb_ctf_type_encoding(base, &e) == 0) {
1067 if (e.cte_format == CTF_FP_SINGLE &&
1068 e.cte_bits == sizeof (float) * NBBY) {
1069 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.f,
1070 sizeof (u.f), addr) != sizeof (u.f)) {
1071 mdb_warn("failed to read float at %llx", addr);
1072 return (1);
1073 }
1074 mdb_printf("%s", doubletos(u.f, 7, 'e'));
1075
1076 } else if (e.cte_format == CTF_FP_DOUBLE &&
1077 e.cte_bits == sizeof (double) * NBBY) {
1078 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.d,
1079 sizeof (u.d), addr) != sizeof (u.d)) {
1080 mdb_warn("failed to read float at %llx", addr);
1081 return (1);
1082 }
1083 mdb_printf("%s", doubletos(u.d, 7, 'e'));
1084
1085 } else if (e.cte_format == CTF_FP_LDOUBLE &&
1086 e.cte_bits == sizeof (long double) * NBBY) {
1087 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.ld,
1088 sizeof (u.ld), addr) != sizeof (u.ld)) {
1089 mdb_warn("failed to read float at %llx", addr);
1090 return (1);
1091 }
1092 mdb_printf("%s", longdoubletos(&u.ld, 16, 'e'));
1093
1094 } else {
1095 mdb_printf("??? (unsupported FP format %u / %u bits\n",
1096 e.cte_format, e.cte_bits);
1097 }
1098 } else
1099 mdb_printf("??? (%s)", mdb_strerror(errno));
1100 #else
1101 mdb_printf("<FLOAT>");
1102 #endif
1103 return (0);
1104 }
1105
1106
1107 /*
1108 * Print out a pointer value as a symbol name + offset or a hexadecimal value.
1109 * If the pointer itself is a char *, we attempt to read a bit of the data
1110 * referenced by the pointer and display it if it is a printable ASCII string.
1111 */
1112 /*ARGSUSED*/
1113 static int
1114 print_ptr(const char *type, const char *name, mdb_ctf_id_t id,
1115 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1116 {
1117 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1118 ctf_encoding_t e;
1119 uintptr_t value;
1120 char buf[256];
1121 ssize_t len;
1122
1123 if (!(pap->pa_flags & PA_SHOWVAL))
1124 return (0);
1125
1126 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
1127 &value, sizeof (value), addr) != sizeof (value)) {
1128 mdb_warn("failed to read %s pointer at %llx", name, addr);
1129 return (1);
1130 }
1131
1132 if (pap->pa_flags & PA_NOSYMBOLIC) {
1133 mdb_printf("%#lx", value);
1134 return (0);
1135 }
1136
1137 mdb_printf("%a", value);
1138
1139 if (value == NULL || strcmp(type, "caddr_t") == 0)
1140 return (0);
1141
1142 if (mdb_ctf_type_kind(base) == CTF_K_POINTER &&
1143 mdb_ctf_type_reference(base, &base) != -1 &&
1144 mdb_ctf_type_resolve(base, &base) != -1 &&
1145 mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e)) {
1146 if ((len = mdb_tgt_readstr(pap->pa_realtgt, pap->pa_as,
1147 buf, sizeof (buf), value)) >= 0 && strisprint(buf)) {
1148 if (len == sizeof (buf))
1149 (void) strabbr(buf, sizeof (buf));
1150 mdb_printf(" \"%s\"", buf);
1151 }
1152 }
1153
1154 return (0);
1155 }
1156
1157
1158 /*
1159 * Print out a fixed-size array. We special-case arrays of characters
1160 * and attempt to print them out as ASCII strings if possible. For other
1161 * arrays, we iterate over a maximum of pa_armemlim members and call
1162 * mdb_ctf_type_visit() again on each element to print its value.
1163 */
1164 /*ARGSUSED*/
1165 static int
1166 print_array(const char *type, const char *name, mdb_ctf_id_t id,
1167 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1168 {
1169 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1170 printarg_t pa = *pap;
1171 ssize_t eltsize;
1172 mdb_ctf_arinfo_t r;
1173 ctf_encoding_t e;
1174 uint_t i, kind, limit;
1175 int d, sou;
1176 char buf[8];
1177 char *str;
1178
1179 if (!(pap->pa_flags & PA_SHOWVAL))
1180 return (0);
1181
1182 if (pap->pa_depth == pap->pa_maxdepth) {
1183 mdb_printf("[ ... ]");
1184 return (0);
1185 }
1186
1187 /*
1188 * Determine the base type and size of the array's content. If this
1189 * fails, we cannot print anything and just give up.
1190 */
1191 if (mdb_ctf_array_info(base, &r) == -1 ||
1192 mdb_ctf_type_resolve(r.mta_contents, &base) == -1 ||
1193 (eltsize = mdb_ctf_type_size(base)) == -1) {
1194 mdb_printf("[ ??? ] (%s)", mdb_strerror(errno));
1195 return (0);
1196 }
1197
1198 /*
1199 * Read a few bytes and determine if the content appears to be
1200 * printable ASCII characters. If so, read the entire array and
1201 * attempt to display it as a string if it is printable.
1202 */
1203 if ((pap->pa_arstrlim == MDB_ARR_NOLIMIT ||
1204 r.mta_nelems <= pap->pa_arstrlim) &&
1205 mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e) &&
1206 mdb_tgt_readstr(pap->pa_tgt, pap->pa_as, buf,
1207 MIN(sizeof (buf), r.mta_nelems), addr) > 0 && strisprint(buf)) {
1208
1209 str = mdb_alloc(r.mta_nelems + 1, UM_SLEEP | UM_GC);
1210 str[r.mta_nelems] = '\0';
1211
1212 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, str,
1213 r.mta_nelems, addr) != r.mta_nelems) {
1214 mdb_warn("failed to read char array at %llx", addr);
1215 return (1);
1216 }
1217
1218 if (strisprint(str)) {
1219 mdb_printf("[ \"%s\" ]", str);
1220 return (0);
1221 }
1222 }
1223
1224 if (pap->pa_armemlim != MDB_ARR_NOLIMIT)
1225 limit = MIN(r.mta_nelems, pap->pa_armemlim);
1226 else
1227 limit = r.mta_nelems;
1228
1229 if (limit == 0) {
1230 mdb_printf("[ ... ]");
1231 return (0);
1232 }
1233
1234 kind = mdb_ctf_type_kind(base);
1235 sou = IS_COMPOSITE(kind);
1236
1237 pa.pa_addr = addr; /* set base address to start of array */
1238 pa.pa_maxdepth = pa.pa_maxdepth - pa.pa_depth - 1;
1239 pa.pa_nest += pa.pa_depth + 1; /* nesting level is current depth + 1 */
1240 pa.pa_depth = 0; /* reset depth to 0 for new scope */
1241 pa.pa_prefix = NULL;
1242
1243 if (sou) {
1244 pa.pa_delim = "\n";
1245 mdb_printf("[\n");
1246 } else {
1247 pa.pa_flags &= ~(PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR);
1248 pa.pa_delim = ", ";
1249 mdb_printf("[ ");
1250 }
1251
1252 for (i = 0; i < limit; i++, pa.pa_addr += eltsize) {
1253 if (i == limit - 1 && !sou) {
1254 if (limit < r.mta_nelems)
1255 pa.pa_delim = ", ... ]";
1256 else
1257 pa.pa_delim = " ]";
1258 }
1259
1260 if (mdb_ctf_type_visit(r.mta_contents, elt_print, &pa) == -1) {
1261 mdb_warn("failed to print array data");
1262 return (1);
1263 }
1264 }
1265
1266 if (sou) {
1267 for (d = pa.pa_depth - 1; d >= 0; d--)
1268 print_close_sou(&pa, d);
1269
1270 if (limit < r.mta_nelems) {
1271 mdb_printf("%*s... ]",
1272 (pap->pa_depth + pap->pa_nest) * pap->pa_tab, "");
1273 } else {
1274 mdb_printf("%*s]",
1275 (pap->pa_depth + pap->pa_nest) * pap->pa_tab, "");
1276 }
1277 }
1278
1279 /* copy the hole array info, since it may have been grown */
1280 pap->pa_holes = pa.pa_holes;
1281 pap->pa_nholes = pa.pa_nholes;
1282
1283 return (0);
1284 }
1285
1286 /*
1287 * Print out a struct or union header. We need only print the open brace
1288 * because mdb_ctf_type_visit() itself will automatically recurse through
1289 * all members of the given struct or union.
1290 */
1291 /*ARGSUSED*/
1292 static int
1293 print_sou(const char *type, const char *name, mdb_ctf_id_t id,
1294 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1295 {
1296 if (pap->pa_depth == pap->pa_maxdepth)
1297 mdb_printf("{ ... }");
1298 else
1299 mdb_printf("{");
1300 pap->pa_delim = "\n";
1301 return (0);
1302 }
1303
1304 /*
1305 * Print an enum value. We attempt to convert the value to the corresponding
1306 * enum name and print that if possible.
1307 */
1308 /*ARGSUSED*/
1309 static int
1310 print_enum(const char *type, const char *name, mdb_ctf_id_t id,
1311 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1312 {
1313 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY;
1314 const char *ename;
1315 int value;
1316 int isp2 = enum_is_p2(base);
1317 int flags = pap->pa_flags | (isp2 ? PA_INTHEX : 0);
1318
1319 if (!(flags & PA_SHOWVAL))
1320 return (0);
1321
1322 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
1323 &value, sizeof (value), addr) != sizeof (value)) {
1324 mdb_warn("failed to read %s integer at %llx", name, addr);
1325 return (1);
1326 }
1327
1328 if (flags & PA_INTHEX)
1329 mdb_printf("%#x", value);
1330 else
1331 mdb_printf("%#d", value);
1332
1333 (void) mdb_inc_indent(8);
1334 mdb_printf(" (");
1335
1336 if (!isp2 || enum_value_print_p2(base, value, 0) != 0) {
1337 ename = mdb_ctf_enum_name(base, value);
1338 if (ename == NULL) {
1339 ename = "???";
1340 }
1341 mdb_printf("%s", ename);
1342 }
1343 mdb_printf(")");
1344 (void) mdb_dec_indent(8);
1345
1346 return (0);
1347 }
1348
1349 /*
1350 * This will only get called if the structure isn't found in any available CTF
1351 * data.
1352 */
1353 /*ARGSUSED*/
1354 static int
1355 print_tag(const char *type, const char *name, mdb_ctf_id_t id,
1356 mdb_ctf_id_t base, ulong_t off, printarg_t *pap)
1357 {
1358 char basename[MDB_SYM_NAMLEN];
1359
1360 if (pap->pa_flags & PA_SHOWVAL)
1361 mdb_printf("; ");
1362
1363 if (mdb_ctf_type_name(base, basename, sizeof (basename)) != NULL)
1364 mdb_printf("<forward declaration of %s>", basename);
1365 else
1366 mdb_printf("<forward declaration of unknown type>");
1367
1368 return (0);
1369 }
1370
1371 static void
1372 print_hole(printarg_t *pap, int depth, ulong_t off, ulong_t endoff)
1373 {
1374 ulong_t bits = endoff - off;
1375 ulong_t size = bits / NBBY;
1376 ctf_encoding_t e;
1377
1378 static const char *const name = "<<HOLE>>";
1379 char type[MDB_SYM_NAMLEN];
1380
1381 int bitfield =
1382 (off % NBBY != 0 ||
1383 bits % NBBY != 0 ||
1384 size > 8 ||
1385 (size & (size - 1)) != 0);
1386
1387 ASSERT(off < endoff);
1388
1389 if (bits > NBBY * sizeof (uint64_t)) {
1390 ulong_t end;
1391
1392 /*
1393 * The hole is larger than the largest integer type. To
1394 * handle this, we split up the hole at 8-byte-aligned
1395 * boundaries, recursing to print each subsection. For
1396 * normal C structures, we'll loop at most twice.
1397 */
1398 for (; off < endoff; off = end) {
1399 end = P2END(off, NBBY * sizeof (uint64_t));
1400 if (end > endoff)
1401 end = endoff;
1402
1403 ASSERT((end - off) <= NBBY * sizeof (uint64_t));
1404 print_hole(pap, depth, off, end);
1405 }
1406 ASSERT(end == endoff);
1407
1408 return;
1409 }
1410
1411 if (bitfield)
1412 (void) mdb_snprintf(type, sizeof (type), "unsigned");
1413 else
1414 (void) mdb_snprintf(type, sizeof (type), "uint%d_t", bits);
1415
1416 if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR))
1417 mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, "");
1418
1419 if (pap->pa_flags & PA_SHOWADDR) {
1420 if (off % NBBY == 0)
1421 mdb_printf("%llx ", pap->pa_addr + off / NBBY);
1422 else
1423 mdb_printf("%llx.%lx ",
1424 pap->pa_addr + off / NBBY, off % NBBY);
1425 }
1426
1427 if (pap->pa_flags & PA_SHOWTYPE)
1428 mdb_printf("%s ", type);
1429
1430 if (pap->pa_flags & PA_SHOWNAME)
1431 mdb_printf("%s", name);
1432
1433 if (bitfield && (pap->pa_flags & PA_SHOWTYPE))
1434 mdb_printf(" :%d", bits);
1435
1436 mdb_printf("%s ", (pap->pa_flags & PA_SHOWVAL)? " =" : "");
1437
1438 /*
1439 * We fake up a ctf_encoding_t, and use print_int_val() to print
1440 * the value. Holes are always processed as unsigned integers.
1441 */
1442 bzero(&e, sizeof (e));
1443 e.cte_format = 0;
1444 e.cte_offset = 0;
1445 e.cte_bits = bits;
1446
1447 if (print_int_val(type, &e, off, pap) != 0)
1448 mdb_iob_discard(mdb.m_out);
1449 else
1450 mdb_iob_puts(mdb.m_out, pap->pa_delim);
1451 }
1452
1453 /*
1454 * The print_close_sou() function is called for each structure or union
1455 * which has been completed. For structures, we detect and print any holes
1456 * before printing the closing brace.
1457 */
1458 static void
1459 print_close_sou(printarg_t *pap, int newdepth)
1460 {
1461 int d = newdepth + pap->pa_nest;
1462
1463 if ((pap->pa_flags & PA_SHOWHOLES) && !pap->pa_holes[d].hi_isunion) {
1464 ulong_t end = pap->pa_holes[d + 1].hi_offset;
1465 ulong_t expected = pap->pa_holes[d].hi_offset;
1466
1467 if (end < expected)
1468 print_hole(pap, newdepth + 1, end, expected);
1469 }
1470 /* if the struct is an array element, print a comma after the } */
1471 mdb_printf("%*s}%s\n", d * pap->pa_tab, "",
1472 (newdepth == 0 && pap->pa_nest > 0)? "," : "");
1473 }
1474
1475 static printarg_f *const printfuncs[] = {
1476 print_int, /* CTF_K_INTEGER */
1477 print_float, /* CTF_K_FLOAT */
1478 print_ptr, /* CTF_K_POINTER */
1479 print_array, /* CTF_K_ARRAY */
1480 print_ptr, /* CTF_K_FUNCTION */
1481 print_sou, /* CTF_K_STRUCT */
1482 print_sou, /* CTF_K_UNION */
1483 print_enum, /* CTF_K_ENUM */
1484 print_tag /* CTF_K_FORWARD */
1485 };
1486
1487 /*
1488 * The elt_print function is used as the mdb_ctf_type_visit callback. For
1489 * each element, we print an appropriate name prefix and then call the
1490 * print subroutine for this type class in the array above.
1491 */
1492 static int
1493 elt_print(const char *name, mdb_ctf_id_t id, mdb_ctf_id_t base,
1494 ulong_t off, int depth, void *data)
1495 {
1496 char type[MDB_SYM_NAMLEN + sizeof (" <<12345678...>>")];
1497 int kind, rc, d;
1498 printarg_t *pap = data;
1499
1500 for (d = pap->pa_depth - 1; d >= depth; d--)
1501 print_close_sou(pap, d);
1502
1503 if (depth > pap->pa_maxdepth)
1504 return (0);
1505
1506 if (!mdb_ctf_type_valid(base) ||
1507 (kind = mdb_ctf_type_kind(base)) == -1)
1508 return (-1); /* errno is set for us */
1509
1510 if (mdb_ctf_type_name(id, type, MDB_SYM_NAMLEN) == NULL)
1511 (void) strcpy(type, "(?)");
1512
1513 if (pap->pa_flags & PA_SHOWBASETYPE) {
1514 /*
1515 * If basetype is different and informative, concatenate
1516 * <<basetype>> (or <<baset...>> if it doesn't fit)
1517 *
1518 * We just use the end of the buffer to store the type name, and
1519 * only connect it up if that's necessary.
1520 */
1521
1522 char *type_end = type + strlen(type);
1523 char *basetype;
1524 size_t sz;
1525
1526 (void) strlcat(type, " <<", sizeof (type));
1527
1528 basetype = type + strlen(type);
1529 sz = sizeof (type) - (basetype - type);
1530
1531 *type_end = '\0'; /* restore the end of type for strcmp() */
1532
1533 if (mdb_ctf_type_name(base, basetype, sz) != NULL &&
1534 strcmp(basetype, type) != 0 &&
1535 strcmp(basetype, "struct ") != 0 &&
1536 strcmp(basetype, "enum ") != 0 &&
1537 strcmp(basetype, "union ") != 0) {
1538 type_end[0] = ' '; /* reconnect */
1539 if (strlcat(type, ">>", sizeof (type)) >= sizeof (type))
1540 (void) strlcpy(
1541 type + sizeof (type) - 6, "...>>", 6);
1542 }
1543 }
1544
1545 if (pap->pa_flags & PA_SHOWHOLES) {
1546 ctf_encoding_t e;
1547 ssize_t nsize;
1548 ulong_t newoff;
1549 holeinfo_t *hole;
1550 int extra = IS_COMPOSITE(kind)? 1 : 0;
1551
1552 /*
1553 * grow the hole array, if necessary
1554 */
1555 if (pap->pa_nest + depth + extra >= pap->pa_nholes) {
1556 int new = MAX(MAX(8, pap->pa_nholes * 2),
1557 pap->pa_nest + depth + extra + 1);
1558
1559 holeinfo_t *nhi = mdb_zalloc(
1560 sizeof (*nhi) * new, UM_NOSLEEP | UM_GC);
1561
1562 bcopy(pap->pa_holes, nhi,
1563 pap->pa_nholes * sizeof (*nhi));
1564
1565 pap->pa_holes = nhi;
1566 pap->pa_nholes = new;
1567 }
1568
1569 hole = &pap->pa_holes[depth + pap->pa_nest];
1570
1571 if (depth != 0 && off > hole->hi_offset)
1572 print_hole(pap, depth, hole->hi_offset, off);
1573
1574 /* compute the next expected offset */
1575 if (kind == CTF_K_INTEGER &&
1576 mdb_ctf_type_encoding(base, &e) == 0)
1577 newoff = off + e.cte_bits;
1578 else if ((nsize = mdb_ctf_type_size(base)) >= 0)
1579 newoff = off + nsize * NBBY;
1580 else {
1581 /* something bad happened, disable hole checking */
1582 newoff = -1UL; /* ULONG_MAX */
1583 }
1584
1585 hole->hi_offset = newoff;
1586
1587 if (IS_COMPOSITE(kind)) {
1588 hole->hi_isunion = (kind == CTF_K_UNION);
1589 hole++;
1590 hole->hi_offset = off;
1591 }
1592 }
1593
1594 if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR))
1595 mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, "");
1596
1597 if (pap->pa_flags & PA_SHOWADDR) {
1598 if (off % NBBY == 0)
1599 mdb_printf("%llx ", pap->pa_addr + off / NBBY);
1600 else
1601 mdb_printf("%llx.%lx ",
1602 pap->pa_addr + off / NBBY, off % NBBY);
1603 }
1604
1605 if ((pap->pa_flags & PA_SHOWTYPE)) {
1606 mdb_printf("%s", type);
1607 /*
1608 * We want to avoid printing a trailing space when
1609 * dealing with pointers in a structure, so we end
1610 * up with:
1611 *
1612 * label_t *t_onfault = 0
1613 *
1614 * If depth is zero, always print the trailing space unless
1615 * we also have a prefix.
1616 */
1617 if (type[strlen(type) - 1] != '*' ||
1618 (depth == 0 && (!(pap->pa_flags & PA_SHOWNAME) ||
1619 pap->pa_prefix == NULL)))
1620 mdb_printf(" ");
1621 }
1622
1623 if (pap->pa_flags & PA_SHOWNAME) {
1624 if (pap->pa_prefix != NULL && depth <= 1)
1625 mdb_printf("%s%s", pap->pa_prefix,
1626 (depth == 0) ? "" : pap->pa_suffix);
1627 mdb_printf("%s", name);
1628 }
1629
1630 if ((pap->pa_flags & PA_SHOWTYPE) && kind == CTF_K_INTEGER) {
1631 ctf_encoding_t e;
1632
1633 if (mdb_ctf_type_encoding(base, &e) == 0) {
1634 ulong_t bits = e.cte_bits;
1635 ulong_t size = bits / NBBY;
1636
1637 if (bits % NBBY != 0 ||
1638 off % NBBY != 0 ||
1639 size > 8 ||
1640 size != mdb_ctf_type_size(base))
1641 mdb_printf(" :%d", bits);
1642 }
1643 }
1644
1645 if (depth != 0 ||
1646 ((pap->pa_flags & PA_SHOWNAME) && pap->pa_prefix != NULL))
1647 mdb_printf("%s ", pap->pa_flags & PA_SHOWVAL ? " =" : "");
1648
1649 if (depth == 0 && pap->pa_prefix != NULL)
1650 name = pap->pa_prefix;
1651
1652 pap->pa_depth = depth;
1653 if (kind <= CTF_K_UNKNOWN || kind >= CTF_K_TYPEDEF) {
1654 mdb_warn("unknown ctf for %s type %s kind %d\n",
1655 name, type, kind);
1656 return (-1);
1657 }
1658 rc = printfuncs[kind - 1](type, name, id, base, off, pap);
1659
1660 if (rc != 0)
1661 mdb_iob_discard(mdb.m_out);
1662 else
1663 mdb_iob_puts(mdb.m_out, pap->pa_delim);
1664
1665 return (rc);
1666 }
1667
1668 /*
1669 * Special semantics for pipelines.
1670 */
1671 static int
1672 pipe_print(mdb_ctf_id_t id, ulong_t off, void *data)
1673 {
1674 printarg_t *pap = data;
1675 ssize_t size;
1676 static const char *const fsp[] = { "%#r", "%#r", "%#r", "%#llr" };
1677 uintptr_t value;
1678 uintptr_t addr = pap->pa_addr + off / NBBY;
1679 mdb_ctf_id_t base;
1680 ctf_encoding_t e;
1681
1682 union {
1683 uint64_t i8;
1684 uint32_t i4;
1685 uint16_t i2;
1686 uint8_t i1;
1687 } u;
1688
1689 if (mdb_ctf_type_resolve(id, &base) == -1) {
1690 mdb_warn("could not resolve type\n");
1691 return (-1);
1692 }
1693
1694 /*
1695 * If the user gives -a, then always print out the address of the
1696 * member.
1697 */
1698 if ((pap->pa_flags & PA_SHOWADDR)) {
1699 mdb_printf("%#lr\n", addr);
1700 return (0);
1701 }
1702
1703 again:
1704 switch (mdb_ctf_type_kind(base)) {
1705 case CTF_K_POINTER:
1706 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as,
1707 &value, sizeof (value), addr) != sizeof (value)) {
1708 mdb_warn("failed to read pointer at %p", addr);
1709 return (-1);
1710 }
1711 mdb_printf("%#lr\n", value);
1712 break;
1713
1714 case CTF_K_INTEGER:
1715 case CTF_K_ENUM:
1716 if (mdb_ctf_type_encoding(base, &e) != 0) {
1717 mdb_printf("could not get type encoding\n");
1718 return (-1);
1719 }
1720
1721 /*
1722 * For immediate values, we just print out the value.
1723 */
1724 size = e.cte_bits / NBBY;
1725 if (size > 8 || (e.cte_bits % NBBY) != 0 ||
1726 (size & (size - 1)) != 0) {
1727 return (print_bitfield(off, pap, &e));
1728 }
1729
1730 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size,
1731 addr) != size) {
1732 mdb_warn("failed to read %lu bytes at %p",
1733 (ulong_t)size, pap->pa_addr);
1734 return (-1);
1735 }
1736
1737 switch (size) {
1738 case sizeof (uint8_t):
1739 mdb_printf(fsp[0], u.i1);
1740 break;
1741 case sizeof (uint16_t):
1742 mdb_printf(fsp[1], u.i2);
1743 break;
1744 case sizeof (uint32_t):
1745 mdb_printf(fsp[2], u.i4);
1746 break;
1747 case sizeof (uint64_t):
1748 mdb_printf(fsp[3], u.i8);
1749 break;
1750 }
1751 mdb_printf("\n");
1752 break;
1753
1754 case CTF_K_FUNCTION:
1755 case CTF_K_FLOAT:
1756 case CTF_K_ARRAY:
1757 case CTF_K_UNKNOWN:
1758 case CTF_K_STRUCT:
1759 case CTF_K_UNION:
1760 case CTF_K_FORWARD:
1761 /*
1762 * For these types, always print the address of the member
1763 */
1764 mdb_printf("%#lr\n", addr);
1765 break;
1766
1767 default:
1768 mdb_warn("unknown type %d", mdb_ctf_type_kind(base));
1769 break;
1770 }
1771
1772 return (0);
1773 }
1774
1775 static int
1776 parse_delimiter(char **strp)
1777 {
1778 switch (**strp) {
1779 case '\0':
1780 return (MEMBER_DELIM_DONE);
1781
1782 case '.':
1783 *strp = *strp + 1;
1784 return (MEMBER_DELIM_DOT);
1785
1786 case '[':
1787 *strp = *strp + 1;
1788 return (MEMBER_DELIM_LBR);
1789
1790 case '-':
1791 *strp = *strp + 1;
1792 if (**strp == '>') {
1793 *strp = *strp + 1;
1794 return (MEMBER_DELIM_PTR);
1795 }
1796 *strp = *strp - 1;
1797 /*FALLTHROUGH*/
1798 default:
1799 return (MEMBER_DELIM_ERR);
1800 }
1801 }
1802
1803 static int
1804 deref(printarg_t *pap, size_t size)
1805 {
1806 uint32_t a32;
1807 mdb_tgt_as_t as = pap->pa_as;
1808 mdb_tgt_addr_t *ap = &pap->pa_addr;
1809
1810 if (size == sizeof (mdb_tgt_addr_t)) {
1811 if (mdb_tgt_aread(mdb.m_target, as, ap, size, *ap) == -1) {
1812 mdb_warn("could not dereference pointer %llx\n", *ap);
1813 return (-1);
1814 }
1815 } else {
1816 if (mdb_tgt_aread(mdb.m_target, as, &a32, size, *ap) == -1) {
1817 mdb_warn("could not dereference pointer %x\n", *ap);
1818 return (-1);
1819 }
1820
1821 *ap = (mdb_tgt_addr_t)a32;
1822 }
1823
1824 /*
1825 * We've dereferenced at least once, we must be on the real
1826 * target. If we were in the immediate target, reset to the real
1827 * target; it's reset as needed when we return to the print
1828 * routines.
1829 */
1830 if (pap->pa_tgt == pap->pa_immtgt)
1831 pap->pa_tgt = pap->pa_realtgt;
1832
1833 return (0);
1834 }
1835
1836 static int
1837 parse_member(printarg_t *pap, const char *str, mdb_ctf_id_t id,
1838 mdb_ctf_id_t *idp, ulong_t *offp, int *last_deref)
1839 {
1840 int delim;
1841 char member[64];
1842 char buf[128];
1843 uint_t index;
1844 char *start = (char *)str;
1845 char *end;
1846 ulong_t off = 0;
1847 mdb_ctf_arinfo_t ar;
1848 mdb_ctf_id_t rid;
1849 int kind;
1850 ssize_t size;
1851 int non_array = FALSE;
1852
1853 /*
1854 * id always has the unresolved type for printing error messages
1855 * that include the type; rid always has the resolved type for
1856 * use in mdb_ctf_* calls. It is possible for this command to fail,
1857 * however, if the resolved type is in the parent and it is currently
1858 * unavailable. Note that we also can't print out the name of the
1859 * type, since that would also rely on looking up the resolved name.
1860 */
1861 if (mdb_ctf_type_resolve(id, &rid) != 0) {
1862 mdb_warn("failed to resolve type");
1863 return (-1);
1864 }
1865
1866 delim = parse_delimiter(&start);
1867 /*
1868 * If the user fails to specify an initial delimiter, guess -> for
1869 * pointer types and . for non-pointer types.
1870 */
1871 if (delim == MEMBER_DELIM_ERR)
1872 delim = (mdb_ctf_type_kind(rid) == CTF_K_POINTER) ?
1873 MEMBER_DELIM_PTR : MEMBER_DELIM_DOT;
1874
1875 *last_deref = FALSE;
1876
1877 while (delim != MEMBER_DELIM_DONE) {
1878 switch (delim) {
1879 case MEMBER_DELIM_PTR:
1880 kind = mdb_ctf_type_kind(rid);
1881 if (kind != CTF_K_POINTER) {
1882 mdb_warn("%s is not a pointer type\n",
1883 mdb_ctf_type_name(id, buf, sizeof (buf)));
1884 return (-1);
1885 }
1886
1887 size = mdb_ctf_type_size(id);
1888 if (deref(pap, size) != 0)
1889 return (-1);
1890
1891 (void) mdb_ctf_type_reference(rid, &id);
1892 (void) mdb_ctf_type_resolve(id, &rid);
1893
1894 off = 0;
1895 break;
1896
1897 case MEMBER_DELIM_DOT:
1898 kind = mdb_ctf_type_kind(rid);
1899 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
1900 mdb_warn("%s is not a struct or union type\n",
1901 mdb_ctf_type_name(id, buf, sizeof (buf)));
1902 return (-1);
1903 }
1904 break;
1905
1906 case MEMBER_DELIM_LBR:
1907 end = strchr(start, ']');
1908 if (end == NULL) {
1909 mdb_warn("no trailing ']'\n");
1910 return (-1);
1911 }
1912
1913 (void) mdb_snprintf(member, end - start + 1, "%s",
1914 start);
1915
1916 index = mdb_strtoull(member);
1917
1918 switch (mdb_ctf_type_kind(rid)) {
1919 case CTF_K_POINTER:
1920 size = mdb_ctf_type_size(rid);
1921
1922 if (deref(pap, size) != 0)
1923 return (-1);
1924
1925 (void) mdb_ctf_type_reference(rid, &id);
1926 (void) mdb_ctf_type_resolve(id, &rid);
1927
1928 size = mdb_ctf_type_size(id);
1929 if (size <= 0) {
1930 mdb_warn("cannot dereference void "
1931 "type\n");
1932 return (-1);
1933 }
1934
1935 pap->pa_addr += index * size;
1936 off = 0;
1937
1938 if (index == 0 && non_array)
1939 *last_deref = TRUE;
1940 break;
1941
1942 case CTF_K_ARRAY:
1943 (void) mdb_ctf_array_info(rid, &ar);
1944
1945 if (index >= ar.mta_nelems) {
1946 mdb_warn("index %r is outside of "
1947 "array bounds [0 .. %r]\n",
1948 index, ar.mta_nelems - 1);
1949 }
1950
1951 id = ar.mta_contents;
1952 (void) mdb_ctf_type_resolve(id, &rid);
1953
1954 size = mdb_ctf_type_size(id);
1955 if (size <= 0) {
1956 mdb_warn("cannot dereference void "
1957 "type\n");
1958 return (-1);
1959 }
1960
1961 pap->pa_addr += index * size;
1962 off = 0;
1963 break;
1964
1965 default:
1966 mdb_warn("cannot index into non-array, "
1967 "non-pointer type\n");
1968 return (-1);
1969 }
1970
1971 start = end + 1;
1972 delim = parse_delimiter(&start);
1973 continue;
1974
1975 case MEMBER_DELIM_ERR:
1976 default:
1977 mdb_warn("'%c' is not a valid delimiter\n", *start);
1978 return (-1);
1979 }
1980
1981 *last_deref = FALSE;
1982 non_array = TRUE;
1983
1984 /*
1985 * Find the end of the member name; assume that a member
1986 * name is at least one character long.
1987 */
1988 for (end = start + 1; isalnum(*end) || *end == '_'; end++)
1989 continue;
1990
1991 (void) mdb_snprintf(member, end - start + 1, "%s", start);
1992
1993 if (mdb_ctf_member_info(rid, member, &off, &id) != 0) {
1994 mdb_warn("failed to find member %s of %s", member,
1995 mdb_ctf_type_name(id, buf, sizeof (buf)));
1996 return (-1);
1997 }
1998 (void) mdb_ctf_type_resolve(id, &rid);
1999
2000 pap->pa_addr += off / NBBY;
2001
2002 start = end;
2003 delim = parse_delimiter(&start);
2004 }
2005
2006
2007 *idp = id;
2008 *offp = off;
2009
2010 return (0);
2011 }
2012
2013 int
2014 cmd_print_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
2015 const mdb_arg_t *argv)
2016 {
2017 char tn[MDB_SYM_NAMLEN];
2018 char member[64];
2019 int i, dummy, delim, kind;
2020 int ret = 0;
2021 mdb_ctf_id_t id, rid;
2022 mdb_ctf_arinfo_t ar;
2023 char *start, *end;
2024 ulong_t dul;
2025
2026 /*
2027 * This getopts is only here to make the tab completion work better when
2028 * including options in the ::print arguments. None of the values should
2029 * be used. This should only be updated with additional arguments, if
2030 * they are added to cmd_print.
2031 */
2032 i = mdb_getopts(argc, argv,
2033 'a', MDB_OPT_SETBITS, PA_SHOWADDR, &dummy,
2034 'C', MDB_OPT_SETBITS, TRUE, &dummy,
2035 'c', MDB_OPT_UINTPTR, &dummy,
2036 'd', MDB_OPT_SETBITS, PA_INTDEC, &dummy,
2037 'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &dummy,
2038 'i', MDB_OPT_SETBITS, TRUE, &dummy,
2039 'L', MDB_OPT_SETBITS, TRUE, &dummy,
2040 'l', MDB_OPT_UINTPTR, &dummy,
2041 'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &dummy,
2042 'p', MDB_OPT_SETBITS, TRUE, &dummy,
2043 's', MDB_OPT_UINTPTR, &dummy,
2044 'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &dummy,
2045 't', MDB_OPT_SETBITS, PA_SHOWTYPE, &dummy,
2046 'x', MDB_OPT_SETBITS, PA_INTHEX, &dummy,
2047 NULL);
2048
2049 argc -= i;
2050 argv += i;
2051
2052 if (argc == 0 && !(flags & DCMD_TAB_SPACE))
2053 return (0);
2054
2055 if (argc == 0 && (flags & DCMD_TAB_SPACE))
2056 return (mdb_tab_complete_type(mcp, NULL, MDB_TABC_NOPOINT |
2057 MDB_TABC_NOARRAY));
2058
2059 if ((ret = mdb_tab_typename(&argc, &argv, tn, sizeof (tn))) < 0)
2060 return (ret);
2061
2062 if (argc == 1 && (!(flags & DCMD_TAB_SPACE) || ret == 1))
2063 return (mdb_tab_complete_type(mcp, tn, MDB_TABC_NOPOINT |
2064 MDB_TABC_NOARRAY));
2065
2066 if (argc == 1 && (flags & DCMD_TAB_SPACE))
2067 return (mdb_tab_complete_member(mcp, tn, NULL));
2068
2069 /*
2070 * This is the reason that tab completion was created. We're going to go
2071 * along and walk the delimiters until we find something a member that
2072 * we don't recognize, at which point we'll try and tab complete it.
2073 * Note that ::print takes multiple args, so this is going to operate on
2074 * whatever the last arg that we have is.
2075 */
2076 if (mdb_ctf_lookup_by_name(tn, &id) != 0)
2077 return (1);
2078
2079 (void) mdb_ctf_type_resolve(id, &rid);
2080 start = (char *)argv[argc-1].a_un.a_str;
2081 delim = parse_delimiter(&start);
2082
2083 /*
2084 * If we hit the case where we actually have no delimiters, than we need
2085 * to make sure that we properly set up the fields the loops would.
2086 */
2087 if (delim == MEMBER_DELIM_DONE)
2088 (void) mdb_snprintf(member, sizeof (member), "%s", start);
2089
2090 while (delim != MEMBER_DELIM_DONE) {
2091 switch (delim) {
2092 case MEMBER_DELIM_PTR:
2093 kind = mdb_ctf_type_kind(rid);
2094 if (kind != CTF_K_POINTER)
2095 return (1);
2096
2097 (void) mdb_ctf_type_reference(rid, &id);
2098 (void) mdb_ctf_type_resolve(id, &rid);
2099 break;
2100 case MEMBER_DELIM_DOT:
2101 kind = mdb_ctf_type_kind(rid);
2102 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
2103 return (1);
2104 break;
2105 case MEMBER_DELIM_LBR:
2106 end = strchr(start, ']');
2107 /*
2108 * We're not going to try and tab complete the indexes
2109 * here. So for now, punt on it. Also, we're not going
2110 * to try and validate you're within the bounds, just
2111 * that you get the type you asked for.
2112 */
2113 if (end == NULL)
2114 return (1);
2115
2116 switch (mdb_ctf_type_kind(rid)) {
2117 case CTF_K_POINTER:
2118 (void) mdb_ctf_type_reference(rid, &id);
2119 (void) mdb_ctf_type_resolve(id, &rid);
2120 break;
2121 case CTF_K_ARRAY:
2122 (void) mdb_ctf_array_info(rid, &ar);
2123 id = ar.mta_contents;
2124 (void) mdb_ctf_type_resolve(id, &rid);
2125 break;
2126 default:
2127 return (1);
2128 }
2129
2130 start = end + 1;
2131 delim = parse_delimiter(&start);
2132 break;
2133 case MEMBER_DELIM_ERR:
2134 default:
2135 break;
2136 }
2137
2138 for (end = start + 1; isalnum(*end) || *end == '_'; end++)
2139 continue;
2140
2141 (void) mdb_snprintf(member, end - start + 1, start);
2142
2143 /*
2144 * We are going to try to resolve this name as a member. There
2145 * are a few two different questions that we need to answer. The
2146 * first is do we recognize this member. The second is are we at
2147 * the end of the string. If we encounter a member that we don't
2148 * recognize before the end, then we have to error out and can't
2149 * complete it. But if there are no more delimiters then we can
2150 * try and complete it.
2151 */
2152 ret = mdb_ctf_member_info(rid, member, &dul, &id);
2153 start = end;
2154 delim = parse_delimiter(&start);
2155 if (ret != 0 && errno == EMDB_CTFNOMEMB) {
2156 if (delim != MEMBER_DELIM_DONE)
2157 return (1);
2158 continue;
2159 } else if (ret != 0)
2160 return (1);
2161
2162 if (delim == MEMBER_DELIM_DONE)
2163 return (mdb_tab_complete_member_by_id(mcp, rid,
2164 member));
2165
2166 (void) mdb_ctf_type_resolve(id, &rid);
2167 }
2168
2169 /*
2170 * If we've reached here, then we need to try and tab complete the last
2171 * field, which is currently member, based on the ctf type id that we
2172 * already have in rid.
2173 */
2174 return (mdb_tab_complete_member_by_id(mcp, rid, member));
2175 }
2176
2177 /*
2178 * Recursively descend a print a given data structure. We create a struct of
2179 * the relevant print arguments and then call mdb_ctf_type_visit() to do the
2180 * traversal, using elt_print() as the callback for each element.
2181 */
2182 /*ARGSUSED*/
2183 int
2184 cmd_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2185 {
2186 uintptr_t opt_c = MDB_ARR_NOLIMIT, opt_l = MDB_ARR_NOLIMIT;
2187 uint_t opt_C = FALSE, opt_L = FALSE, opt_p = FALSE, opt_i = FALSE;
2188 uintptr_t opt_s = (uintptr_t)-1ul;
2189 int uflags = (flags & DCMD_ADDRSPEC) ? PA_SHOWVAL : 0;
2190 mdb_ctf_id_t id;
2191 int err = DCMD_OK;
2192
2193 mdb_tgt_t *t = mdb.m_target;
2194 printarg_t pa;
2195 int d, i;
2196
2197 char s_name[MDB_SYM_NAMLEN];
2198 mdb_syminfo_t s_info;
2199 GElf_Sym sym;
2200
2201 /*
2202 * If a new option is added, make sure the getopts above in
2203 * cmd_print_tab is also updated.
2204 */
2205 i = mdb_getopts(argc, argv,
2206 'a', MDB_OPT_SETBITS, PA_SHOWADDR, &uflags,
2207 'C', MDB_OPT_SETBITS, TRUE, &opt_C,
2208 'c', MDB_OPT_UINTPTR, &opt_c,
2209 'd', MDB_OPT_SETBITS, PA_INTDEC, &uflags,
2210 'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &uflags,
2211 'i', MDB_OPT_SETBITS, TRUE, &opt_i,
2212 'L', MDB_OPT_SETBITS, TRUE, &opt_L,
2213 'l', MDB_OPT_UINTPTR, &opt_l,
2214 'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &uflags,
2215 'p', MDB_OPT_SETBITS, TRUE, &opt_p,
2216 's', MDB_OPT_UINTPTR, &opt_s,
2217 'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &uflags,
2218 't', MDB_OPT_SETBITS, PA_SHOWTYPE, &uflags,
2219 'x', MDB_OPT_SETBITS, PA_INTHEX, &uflags,
2220 NULL);
2221
2222 if (uflags & PA_INTHEX)
2223 uflags &= ~PA_INTDEC; /* -x and -d are mutually exclusive */
2224
2225 uflags |= PA_SHOWNAME;
2226
2227 if (opt_p && opt_i) {
2228 mdb_warn("-p and -i options are incompatible\n");
2229 return (DCMD_ERR);
2230 }
2231
2232 argc -= i;
2233 argv += i;
2234
2235 if (argc != 0 && argv->a_type == MDB_TYPE_STRING) {
2236 const char *t_name = s_name;
2237 int ret;
2238
2239 if (strchr("+-", argv->a_un.a_str[0]) != NULL)
2240 return (DCMD_USAGE);
2241
2242 if ((ret = args_to_typename(&argc, &argv, s_name,
2243 sizeof (s_name))) != 0)
2244 return (ret);
2245
2246 if (mdb_ctf_lookup_by_name(t_name, &id) != 0) {
2247 if (!(flags & DCMD_ADDRSPEC) || opt_i ||
2248 addr_to_sym(t, addr, s_name, sizeof (s_name),
2249 &sym, &s_info) == NULL ||
2250 mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) {
2251
2252 mdb_warn("failed to look up type %s", t_name);
2253 return (DCMD_ABORT);
2254 }
2255 } else {
2256 argc--;
2257 argv++;
2258 }
2259
2260 } else if (!(flags & DCMD_ADDRSPEC) || opt_i) {
2261 return (DCMD_USAGE);
2262
2263 } else if (addr_to_sym(t, addr, s_name, sizeof (s_name),
2264 &sym, &s_info) == NULL) {
2265 mdb_warn("no symbol information for %a", addr);
2266 return (DCMD_ERR);
2267
2268 } else if (mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) {
2269 mdb_warn("no type data available for %a [%u]", addr,
2270 s_info.sym_id);
2271 return (DCMD_ERR);
2272 }
2273
2274 pa.pa_tgt = mdb.m_target;
2275 pa.pa_realtgt = pa.pa_tgt;
2276 pa.pa_immtgt = NULL;
2277 pa.pa_as = opt_p ? MDB_TGT_AS_PHYS : MDB_TGT_AS_VIRT;
2278 pa.pa_armemlim = mdb.m_armemlim;
2279 pa.pa_arstrlim = mdb.m_arstrlim;
2280 pa.pa_delim = "\n";
2281 pa.pa_flags = uflags;
2282 pa.pa_nest = 0;
2283 pa.pa_tab = 4;
2284 pa.pa_prefix = NULL;
2285 pa.pa_suffix = NULL;
2286 pa.pa_holes = NULL;
2287 pa.pa_nholes = 0;
2288 pa.pa_depth = 0;
2289 pa.pa_maxdepth = opt_s;
2290
2291 if ((flags & DCMD_ADDRSPEC) && !opt_i)
2292 pa.pa_addr = opt_p ? mdb_get_dot() : addr;
2293 else
2294 pa.pa_addr = NULL;
2295
2296 if (opt_i) {
2297 const char *vargv[2];
2298 uintmax_t dot = mdb_get_dot();
2299 size_t outsize = mdb_ctf_type_size(id);
2300 vargv[0] = (const char *)˙
2301 vargv[1] = (const char *)&outsize;
2302 pa.pa_immtgt = mdb_tgt_create(mdb_value_tgt_create,
2303 0, 2, vargv);
2304 pa.pa_tgt = pa.pa_immtgt;
2305 }
2306
2307 if (opt_c != MDB_ARR_NOLIMIT)
2308 pa.pa_arstrlim = opt_c;
2309 if (opt_C)
2310 pa.pa_arstrlim = MDB_ARR_NOLIMIT;
2311 if (opt_l != MDB_ARR_NOLIMIT)
2312 pa.pa_armemlim = opt_l;
2313 if (opt_L)
2314 pa.pa_armemlim = MDB_ARR_NOLIMIT;
2315
2316 if (argc > 0) {
2317 for (i = 0; i < argc; i++) {
2318 mdb_ctf_id_t mid;
2319 int last_deref;
2320 ulong_t off;
2321 int kind;
2322 char buf[MDB_SYM_NAMLEN];
2323
2324 mdb_tgt_t *oldtgt = pa.pa_tgt;
2325 mdb_tgt_as_t oldas = pa.pa_as;
2326 mdb_tgt_addr_t oldaddr = pa.pa_addr;
2327
2328 if (argv->a_type == MDB_TYPE_STRING) {
2329 const char *member = argv[i].a_un.a_str;
2330 mdb_ctf_id_t rid;
2331
2332 if (parse_member(&pa, member, id, &mid,
2333 &off, &last_deref) != 0) {
2334 err = DCMD_ABORT;
2335 goto out;
2336 }
2337
2338 /*
2339 * If the member string ends with a "[0]"
2340 * (last_deref * is true) and the type is a
2341 * structure or union, * print "->" rather
2342 * than "[0]." in elt_print.
2343 */
2344 (void) mdb_ctf_type_resolve(mid, &rid);
2345 kind = mdb_ctf_type_kind(rid);
2346 if (last_deref && IS_SOU(kind)) {
2347 char *end;
2348 (void) mdb_snprintf(buf, sizeof (buf),
2349 "%s", member);
2350 end = strrchr(buf, '[');
2351 *end = '\0';
2352 pa.pa_suffix = "->";
2353 member = &buf[0];
2354 } else if (IS_SOU(kind)) {
2355 pa.pa_suffix = ".";
2356 } else {
2357 pa.pa_suffix = "";
2358 }
2359
2360 pa.pa_prefix = member;
2361 } else {
2362 ulong_t moff;
2363
2364 moff = (ulong_t)argv[i].a_un.a_val;
2365
2366 if (mdb_ctf_offset_to_name(id, moff * NBBY,
2367 buf, sizeof (buf), 0, &mid, &off) == -1) {
2368 mdb_warn("invalid offset %lx\n", moff);
2369 err = DCMD_ABORT;
2370 goto out;
2371 }
2372
2373 pa.pa_prefix = buf;
2374 pa.pa_addr += moff - off / NBBY;
2375 pa.pa_suffix = strlen(buf) == 0 ? "" : ".";
2376 }
2377
2378 off %= NBBY;
2379 if (flags & DCMD_PIPE_OUT) {
2380 if (pipe_print(mid, off, &pa) != 0) {
2381 mdb_warn("failed to print type");
2382 err = DCMD_ERR;
2383 goto out;
2384 }
2385 } else if (off != 0) {
2386 mdb_ctf_id_t base;
2387 (void) mdb_ctf_type_resolve(mid, &base);
2388
2389 if (elt_print("", mid, base, off, 0,
2390 &pa) != 0) {
2391 mdb_warn("failed to print type");
2392 err = DCMD_ERR;
2393 goto out;
2394 }
2395 } else {
2396 if (mdb_ctf_type_visit(mid, elt_print,
2397 &pa) == -1) {
2398 mdb_warn("failed to print type");
2399 err = DCMD_ERR;
2400 goto out;
2401 }
2402
2403 for (d = pa.pa_depth - 1; d >= 0; d--)
2404 print_close_sou(&pa, d);
2405 }
2406
2407 pa.pa_depth = 0;
2408 pa.pa_tgt = oldtgt;
2409 pa.pa_as = oldas;
2410 pa.pa_addr = oldaddr;
2411 pa.pa_delim = "\n";
2412 }
2413
2414 } else if (flags & DCMD_PIPE_OUT) {
2415 if (pipe_print(id, 0, &pa) != 0) {
2416 mdb_warn("failed to print type");
2417 err = DCMD_ERR;
2418 goto out;
2419 }
2420 } else {
2421 if (mdb_ctf_type_visit(id, elt_print, &pa) == -1) {
2422 mdb_warn("failed to print type");
2423 err = DCMD_ERR;
2424 goto out;
2425 }
2426
2427 for (d = pa.pa_depth - 1; d >= 0; d--)
2428 print_close_sou(&pa, d);
2429 }
2430
2431 mdb_set_dot(addr + mdb_ctf_type_size(id));
2432 err = DCMD_OK;
2433 out:
2434 if (pa.pa_immtgt)
2435 mdb_tgt_destroy(pa.pa_immtgt);
2436 return (err);
2437 }
2438
2439 void
2440 print_help(void)
2441 {
2442 mdb_printf(
2443 "-a show address of object\n"
2444 "-C unlimit the length of character arrays\n"
2445 "-c limit limit the length of character arrays\n"
2446 "-d output values in decimal\n"
2447 "-h print holes in structures\n"
2448 "-i interpret address as data of the given type\n"
2449 "-L unlimit the length of standard arrays\n"
2450 "-l limit limit the length of standard arrays\n"
2451 "-n don't print pointers as symbol offsets\n"
2452 "-p interpret address as a physical memory address\n"
2453 "-s depth limit the recursion depth\n"
2454 "-T show type and <<base type>> of object\n"
2455 "-t show type of object\n"
2456 "-x output values in hexadecimal\n"
2457 "\n"
2458 "type may be omitted if the C type of addr can be inferred.\n"
2459 "\n"
2460 "Members may be specified with standard C syntax using the\n"
2461 "array indexing operator \"[index]\", structure member\n"
2462 "operator \".\", or structure pointer operator \"->\".\n"
2463 "\n"
2464 "Offsets must use the $[ expression ] syntax\n");
2465 }