Print this page
patch mdb_var_alloc
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/mdb/common/mdb/mdb_cmds.c
+++ new/usr/src/cmd/mdb/common/mdb/mdb_cmds.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 24 * Use is subject to license terms.
25 25 */
26 26
27 27 /*
28 28 * Copyright (c) 2012 by Delphix. All rights reserved.
29 29 * Copyright (c) 2013 Joyent, Inc. All rights reserved.
30 30 */
31 31
32 32 #include <sys/elf.h>
33 33 #include <sys/elf_SPARC.h>
34 34
35 35 #include <libproc.h>
36 36 #include <stdlib.h>
37 37 #include <string.h>
38 38 #include <fcntl.h>
39 39 #include <errno.h>
40 40 #include <alloca.h>
41 41 #include <libctf.h>
42 42 #include <ctype.h>
43 43
44 44 #include <mdb/mdb_string.h>
45 45 #include <mdb/mdb_argvec.h>
46 46 #include <mdb/mdb_nv.h>
47 47 #include <mdb/mdb_fmt.h>
48 48 #include <mdb/mdb_target.h>
49 49 #include <mdb/mdb_err.h>
50 50 #include <mdb/mdb_debug.h>
51 51 #include <mdb/mdb_conf.h>
52 52 #include <mdb/mdb_module.h>
53 53 #include <mdb/mdb_modapi.h>
54 54 #include <mdb/mdb_stdlib.h>
55 55 #include <mdb/mdb_lex.h>
56 56 #include <mdb/mdb_io_impl.h>
57 57 #include <mdb/mdb_help.h>
58 58 #include <mdb/mdb_disasm.h>
59 59 #include <mdb/mdb_frame.h>
60 60 #include <mdb/mdb_evset.h>
61 61 #include <mdb/mdb_print.h>
62 62 #include <mdb/mdb_nm.h>
63 63 #include <mdb/mdb_set.h>
64 64 #include <mdb/mdb_demangle.h>
65 65 #include <mdb/mdb_ctf.h>
66 66 #include <mdb/mdb_whatis.h>
67 67 #include <mdb/mdb_whatis_impl.h>
68 68 #include <mdb/mdb_macalias.h>
69 69 #include <mdb/mdb_tab.h>
70 70 #include <mdb/mdb_typedef.h>
71 71 #ifdef _KMDB
72 72 #include <kmdb/kmdb_kdi.h>
73 73 #endif
74 74 #include <mdb/mdb.h>
75 75
76 76 #ifdef __sparc
77 77 #define SETHI_MASK 0xc1c00000
78 78 #define SETHI_VALUE 0x01000000
79 79
80 80 #define IS_SETHI(machcode) (((machcode) & SETHI_MASK) == SETHI_VALUE)
81 81
82 82 #define OP(machcode) ((machcode) >> 30)
83 83 #define OP3(machcode) (((machcode) >> 19) & 0x3f)
84 84 #define RD(machcode) (((machcode) >> 25) & 0x1f)
85 85 #define RS1(machcode) (((machcode) >> 14) & 0x1f)
86 86 #define I(machcode) (((machcode) >> 13) & 0x01)
87 87
88 88 #define IMM13(machcode) ((machcode) & 0x1fff)
89 89 #define IMM22(machcode) ((machcode) & 0x3fffff)
90 90
91 91 #define OP_ARITH_MEM_MASK 0x2
92 92 #define OP_ARITH 0x2
93 93 #define OP_MEM 0x3
94 94
95 95 #define OP3_CC_MASK 0x10
96 96 #define OP3_COMPLEX_MASK 0x20
97 97
98 98 #define OP3_ADD 0x00
99 99 #define OP3_OR 0x02
100 100 #define OP3_XOR 0x03
101 101
102 102 #ifndef R_O7
103 103 #define R_O7 0xf
104 104 #endif
105 105 #endif /* __sparc */
106 106
107 107 static mdb_tgt_addr_t
108 108 write_uint8(mdb_tgt_as_t as, mdb_tgt_addr_t addr, uint64_t ull, uint_t rdback)
109 109 {
110 110 uint8_t o, n = (uint8_t)ull;
111 111
112 112 if (rdback && mdb_tgt_aread(mdb.m_target, as, &o, sizeof (o),
113 113 addr) == -1)
114 114 return (addr);
115 115
116 116 if (mdb_tgt_awrite(mdb.m_target, as, &n, sizeof (n), addr) == -1)
117 117 return (addr);
118 118
119 119 if (rdback) {
120 120 if (mdb_tgt_aread(mdb.m_target, as, &n, sizeof (n), addr) == -1)
121 121 return (addr);
122 122
123 123 mdb_iob_printf(mdb.m_out, "%-#*lla%16T%-#8x=%8T0x%x\n",
124 124 mdb_iob_getmargin(mdb.m_out), addr, o, n);
125 125 }
126 126
127 127 return (addr + sizeof (n));
128 128 }
129 129
130 130 static mdb_tgt_addr_t
131 131 write_uint16(mdb_tgt_as_t as, mdb_tgt_addr_t addr, uint64_t ull, uint_t rdback)
132 132 {
133 133 uint16_t o, n = (uint16_t)ull;
134 134
135 135 if (rdback && mdb_tgt_aread(mdb.m_target, as, &o, sizeof (o),
136 136 addr) == -1)
137 137 return (addr);
138 138
139 139 if (mdb_tgt_awrite(mdb.m_target, as, &n, sizeof (n), addr) == -1)
140 140 return (addr);
141 141
142 142 if (rdback) {
143 143 if (mdb_tgt_aread(mdb.m_target, as, &n, sizeof (n), addr) == -1)
144 144 return (addr);
145 145
146 146 mdb_iob_printf(mdb.m_out, "%-#*lla%16T%-#8hx=%8T0x%hx\n",
147 147 mdb_iob_getmargin(mdb.m_out), addr, o, n);
148 148 }
149 149
150 150 return (addr + sizeof (n));
151 151 }
152 152
153 153 static mdb_tgt_addr_t
154 154 write_uint32(mdb_tgt_as_t as, mdb_tgt_addr_t addr, uint64_t ull, uint_t rdback)
155 155 {
156 156 uint32_t o, n = (uint32_t)ull;
157 157
158 158 if (rdback && mdb_tgt_aread(mdb.m_target, as, &o, sizeof (o),
159 159 addr) == -1)
160 160 return (addr);
161 161
162 162 if (mdb_tgt_awrite(mdb.m_target, as, &n, sizeof (n), addr) == -1)
163 163 return (addr);
164 164
165 165 if (rdback) {
166 166 if (mdb_tgt_aread(mdb.m_target, as, &n, sizeof (n), addr) == -1)
167 167 return (addr);
168 168
169 169 mdb_iob_printf(mdb.m_out, "%-#*lla%16T%-#16x=%8T0x%x\n",
170 170 mdb_iob_getmargin(mdb.m_out), addr, o, n);
171 171 }
172 172
173 173 return (addr + sizeof (n));
174 174 }
175 175
176 176 static mdb_tgt_addr_t
177 177 write_uint64(mdb_tgt_as_t as, mdb_tgt_addr_t addr, uint64_t n, uint_t rdback)
178 178 {
179 179 uint64_t o;
180 180
181 181 if (rdback && mdb_tgt_aread(mdb.m_target, as, &o, sizeof (o),
182 182 addr) == -1)
183 183 return (addr);
184 184
185 185 if (mdb_tgt_awrite(mdb.m_target, as, &n, sizeof (n), addr) == -1)
186 186 return (addr);
187 187
188 188 if (rdback) {
189 189 if (mdb_tgt_aread(mdb.m_target, as, &n, sizeof (n), addr) == -1)
190 190 return (addr);
191 191
192 192 mdb_iob_printf(mdb.m_out, "%-#*lla%16T%-#24llx=%8T0x%llx\n",
193 193 mdb_iob_getmargin(mdb.m_out), addr, o, n);
194 194 }
195 195
196 196 return (addr + sizeof (n));
197 197 }
198 198
199 199 static int
200 200 write_arglist(mdb_tgt_as_t as, mdb_tgt_addr_t addr,
201 201 int argc, const mdb_arg_t *argv)
202 202 {
203 203 mdb_tgt_addr_t (*write_value)(mdb_tgt_as_t, mdb_tgt_addr_t,
204 204 uint64_t, uint_t);
205 205 mdb_tgt_addr_t naddr;
206 206 uintmax_t value;
207 207 int rdback = mdb.m_flags & MDB_FL_READBACK;
208 208 size_t i;
209 209
210 210 if (argc == 1) {
211 211 mdb_warn("expected value to write following %c\n",
212 212 argv->a_un.a_char);
213 213 return (DCMD_ERR);
214 214 }
215 215
216 216 switch (argv->a_un.a_char) {
217 217 case 'v':
218 218 write_value = write_uint8;
219 219 break;
220 220 case 'w':
221 221 write_value = write_uint16;
222 222 break;
223 223 case 'W':
224 224 write_value = write_uint32;
225 225 break;
226 226 case 'Z':
227 227 write_value = write_uint64;
228 228 break;
229 229 }
230 230
231 231 for (argv++, i = 1; i < argc; i++, argv++) {
232 232 if (argv->a_type == MDB_TYPE_CHAR) {
233 233 mdb_warn("expected immediate value instead of '%c'\n",
234 234 argv->a_un.a_char);
235 235 return (DCMD_ERR);
236 236 }
237 237
238 238 if (argv->a_type == MDB_TYPE_STRING) {
239 239 if (mdb_eval(argv->a_un.a_str) == -1) {
240 240 mdb_warn("failed to write \"%s\"",
241 241 argv->a_un.a_str);
242 242 return (DCMD_ERR);
243 243 }
244 244 value = mdb_nv_get_value(mdb.m_dot);
245 245 } else
246 246 value = argv->a_un.a_val;
247 247
248 248 mdb_nv_set_value(mdb.m_dot, addr);
249 249
250 250 if ((naddr = write_value(as, addr, value, rdback)) == addr) {
251 251 mdb_warn("failed to write %llr at address 0x%llx",
252 252 value, addr);
253 253 mdb.m_incr = 0;
254 254 break;
255 255 }
256 256
257 257 mdb.m_incr = naddr - addr;
258 258 addr = naddr;
259 259 }
260 260
261 261 return (DCMD_OK);
262 262 }
263 263
264 264 static mdb_tgt_addr_t
265 265 match_uint16(mdb_tgt_as_t as, mdb_tgt_addr_t addr, uint64_t v64, uint64_t m64)
266 266 {
267 267 uint16_t x, val = (uint16_t)v64, mask = (uint16_t)m64;
268 268
269 269 for (; mdb_tgt_aread(mdb.m_target, as, &x,
270 270 sizeof (x), addr) == sizeof (x); addr += sizeof (x)) {
271 271
272 272 if ((x & mask) == val) {
273 273 mdb_iob_printf(mdb.m_out, "%lla\n", addr);
274 274 break;
275 275 }
276 276 }
277 277 return (addr);
278 278 }
279 279
280 280 static mdb_tgt_addr_t
281 281 match_uint32(mdb_tgt_as_t as, mdb_tgt_addr_t addr, uint64_t v64, uint64_t m64)
282 282 {
283 283 uint32_t x, val = (uint32_t)v64, mask = (uint32_t)m64;
284 284
285 285 for (; mdb_tgt_aread(mdb.m_target, as, &x,
286 286 sizeof (x), addr) == sizeof (x); addr += sizeof (x)) {
287 287
288 288 if ((x & mask) == val) {
289 289 mdb_iob_printf(mdb.m_out, "%lla\n", addr);
290 290 break;
291 291 }
292 292 }
293 293 return (addr);
294 294 }
295 295
296 296 static mdb_tgt_addr_t
297 297 match_uint64(mdb_tgt_as_t as, mdb_tgt_addr_t addr, uint64_t val, uint64_t mask)
298 298 {
299 299 uint64_t x;
300 300
301 301 for (; mdb_tgt_aread(mdb.m_target, as, &x,
302 302 sizeof (x), addr) == sizeof (x); addr += sizeof (x)) {
303 303
304 304 if ((x & mask) == val) {
305 305 mdb_iob_printf(mdb.m_out, "%lla\n", addr);
306 306 break;
307 307 }
308 308 }
309 309 return (addr);
310 310 }
311 311
312 312 static int
313 313 match_arglist(mdb_tgt_as_t as, uint_t flags, mdb_tgt_addr_t addr,
314 314 int argc, const mdb_arg_t *argv)
315 315 {
316 316 mdb_tgt_addr_t (*match_value)(mdb_tgt_as_t, mdb_tgt_addr_t,
317 317 uint64_t, uint64_t);
318 318
319 319 uint64_t args[2] = { 0, -1ULL }; /* [ value, mask ] */
320 320 size_t i;
321 321
322 322 if (argc < 2) {
323 323 mdb_warn("expected value following %c\n", argv->a_un.a_char);
324 324 return (DCMD_ERR);
325 325 }
326 326
327 327 if (argc > 3) {
328 328 mdb_warn("only value and mask may follow %c\n",
329 329 argv->a_un.a_char);
330 330 return (DCMD_ERR);
331 331 }
332 332
333 333 switch (argv->a_un.a_char) {
334 334 case 'l':
335 335 match_value = match_uint16;
336 336 break;
337 337 case 'L':
338 338 match_value = match_uint32;
339 339 break;
340 340 case 'M':
341 341 match_value = match_uint64;
342 342 break;
343 343 }
344 344
345 345 for (argv++, i = 1; i < argc; i++, argv++) {
346 346 if (argv->a_type == MDB_TYPE_CHAR) {
347 347 mdb_warn("expected immediate value instead of '%c'\n",
348 348 argv->a_un.a_char);
349 349 return (DCMD_ERR);
350 350 }
351 351
352 352 if (argv->a_type == MDB_TYPE_STRING) {
353 353 if (mdb_eval(argv->a_un.a_str) == -1) {
354 354 mdb_warn("failed to evaluate \"%s\"",
355 355 argv->a_un.a_str);
356 356 return (DCMD_ERR);
357 357 }
358 358 args[i - 1] = mdb_nv_get_value(mdb.m_dot);
359 359 } else
360 360 args[i - 1] = argv->a_un.a_val;
361 361 }
362 362
363 363 addr = match_value(as, addr, args[0], args[1]);
364 364 mdb_nv_set_value(mdb.m_dot, addr);
365 365
366 366 /*
367 367 * In adb(1), the match operators ignore any repeat count that has
368 368 * been applied to them. We emulate this undocumented property
369 369 * by returning DCMD_ABORT if our input is not a pipeline.
370 370 */
371 371 return ((flags & DCMD_PIPE) ? DCMD_OK : DCMD_ABORT);
372 372 }
373 373
374 374 static int
375 375 argncmp(int argc, const mdb_arg_t *argv, const char *s)
376 376 {
377 377 for (; *s != '\0'; s++, argc--, argv++) {
378 378 if (argc == 0 || argv->a_type != MDB_TYPE_CHAR)
379 379 return (FALSE);
380 380 if (argv->a_un.a_char != *s)
381 381 return (FALSE);
382 382 }
383 383 return (TRUE);
384 384 }
385 385
386 386 static int
387 387 print_arglist(mdb_tgt_as_t as, mdb_tgt_addr_t addr, uint_t flags,
388 388 int argc, const mdb_arg_t *argv)
389 389 {
390 390 char buf[MDB_TGT_SYM_NAMLEN];
391 391 mdb_tgt_addr_t oaddr = addr;
392 392 mdb_tgt_addr_t naddr;
393 393 GElf_Sym sym;
394 394 size_t i, n;
395 395
396 396 if (DCMD_HDRSPEC(flags) && (flags & DCMD_PIPE_OUT) == 0) {
397 397 const char *fmt;
398 398 int is_dis;
399 399 /*
400 400 * This is nasty, but necessary for precise adb compatibility.
401 401 * Detect disassembly format by looking for "ai" or "ia":
402 402 */
403 403 if (argncmp(argc, argv, "ai")) {
404 404 fmt = "%-#*lla\n";
405 405 is_dis = TRUE;
406 406 } else if (argncmp(argc, argv, "ia")) {
407 407 fmt = "%-#*lla";
408 408 is_dis = TRUE;
409 409 } else {
410 410 fmt = "%-#*lla%16T";
411 411 is_dis = FALSE;
412 412 }
413 413
414 414 /*
415 415 * If symbolic decoding is on, disassembly is off, and the
416 416 * address exactly matches a symbol, print the symbol name:
417 417 */
418 418 if ((mdb.m_flags & MDB_FL_PSYM) && !is_dis &&
419 419 (as == MDB_TGT_AS_VIRT || as == MDB_TGT_AS_FILE) &&
420 420 mdb_tgt_lookup_by_addr(mdb.m_target, (uintptr_t)addr,
421 421 MDB_TGT_SYM_EXACT, buf, sizeof (buf), &sym, NULL) == 0)
422 422 mdb_iob_printf(mdb.m_out, "%s:\n", buf);
423 423
424 424 /*
425 425 * If this is a virtual address, cast it so that it reflects
426 426 * only the valid component of the address.
427 427 */
428 428 if (as == MDB_TGT_AS_VIRT)
429 429 addr = (uintptr_t)addr;
430 430
431 431 mdb_iob_printf(mdb.m_out, fmt,
432 432 (uint_t)mdb_iob_getmargin(mdb.m_out), addr);
433 433 }
434 434
435 435 if (argc == 0) {
436 436 /*
437 437 * Yes, for you trivia buffs: if you use a format verb and give
438 438 * no format string, you get: X^"= "i ... note that in adb the
439 439 * the '=' verb once had 'z' as its default, but then 'z' was
440 440 * deleted (it was once an alias for 'i') and so =\n now calls
441 441 * scanform("z") and produces a 'bad modifier' message.
442 442 */
443 443 static const mdb_arg_t def_argv[] = {
444 444 { MDB_TYPE_CHAR, MDB_INIT_CHAR('X') },
445 445 { MDB_TYPE_CHAR, MDB_INIT_CHAR('^') },
446 446 { MDB_TYPE_STRING, MDB_INIT_STRING("= ") },
447 447 { MDB_TYPE_CHAR, MDB_INIT_CHAR('i') }
448 448 };
449 449
450 450 argc = sizeof (def_argv) / sizeof (mdb_arg_t);
451 451 argv = def_argv;
452 452 }
453 453
454 454 mdb_iob_setflags(mdb.m_out, MDB_IOB_INDENT);
455 455
456 456 for (i = 0, n = 1; i < argc; i++, argv++) {
457 457 switch (argv->a_type) {
458 458 case MDB_TYPE_CHAR:
459 459 naddr = mdb_fmt_print(mdb.m_target, as, addr, n,
460 460 argv->a_un.a_char);
461 461 mdb.m_incr = naddr - addr;
462 462 addr = naddr;
463 463 n = 1;
464 464 break;
465 465
466 466 case MDB_TYPE_IMMEDIATE:
467 467 n = argv->a_un.a_val;
468 468 break;
469 469
470 470 case MDB_TYPE_STRING:
471 471 mdb_iob_puts(mdb.m_out, argv->a_un.a_str);
472 472 n = 1;
473 473 break;
474 474 }
475 475 }
476 476
477 477 mdb.m_incr = addr - oaddr;
478 478 mdb_iob_clrflags(mdb.m_out, MDB_IOB_INDENT);
479 479 return (DCMD_OK);
480 480 }
481 481
482 482 static int
483 483 print_common(mdb_tgt_as_t as, uint_t flags, int argc, const mdb_arg_t *argv)
484 484 {
485 485 mdb_tgt_addr_t addr = mdb_nv_get_value(mdb.m_dot);
486 486
487 487 if (argc != 0 && argv->a_type == MDB_TYPE_CHAR) {
488 488 if (strchr("vwWZ", argv->a_un.a_char))
489 489 return (write_arglist(as, addr, argc, argv));
490 490 if (strchr("lLM", argv->a_un.a_char))
491 491 return (match_arglist(as, flags, addr, argc, argv));
492 492 }
493 493
494 494 return (print_arglist(as, addr, flags, argc, argv));
495 495 }
496 496
497 497 /*ARGSUSED*/
498 498 static int
499 499 cmd_print_core(uintptr_t x, uint_t flags, int argc, const mdb_arg_t *argv)
500 500 {
501 501 return (print_common(MDB_TGT_AS_VIRT, flags, argc, argv));
502 502 }
503 503
504 504 #ifndef _KMDB
505 505 /*ARGSUSED*/
506 506 static int
507 507 cmd_print_object(uintptr_t x, uint_t flags, int argc, const mdb_arg_t *argv)
508 508 {
509 509 return (print_common(MDB_TGT_AS_FILE, flags, argc, argv));
510 510 }
511 511 #endif
512 512
513 513 /*ARGSUSED*/
514 514 static int
515 515 cmd_print_phys(uintptr_t x, uint_t flags, int argc, const mdb_arg_t *argv)
516 516 {
517 517 return (print_common(MDB_TGT_AS_PHYS, flags, argc, argv));
518 518 }
519 519
520 520 /*ARGSUSED*/
521 521 static int
522 522 cmd_print_value(uintptr_t addr, uint_t flags,
523 523 int argc, const mdb_arg_t *argv)
524 524 {
525 525 uintmax_t ndot, dot = mdb_get_dot();
526 526 const char *tgt_argv[1];
527 527 mdb_tgt_t *t;
528 528 size_t i, n;
529 529
530 530 if (argc == 0) {
531 531 mdb_warn("expected one or more format characters "
532 532 "following '='\n");
533 533 return (DCMD_ERR);
534 534 }
535 535
536 536 tgt_argv[0] = (const char *)˙
537 537 t = mdb_tgt_create(mdb_value_tgt_create, 0, 1, tgt_argv);
538 538 mdb_iob_setflags(mdb.m_out, MDB_IOB_INDENT);
539 539
540 540 for (i = 0, n = 1; i < argc; i++, argv++) {
541 541 switch (argv->a_type) {
542 542 case MDB_TYPE_CHAR:
543 543 ndot = mdb_fmt_print(t, MDB_TGT_AS_VIRT,
544 544 dot, n, argv->a_un.a_char);
545 545 if (argv->a_un.a_char == '+' ||
546 546 argv->a_un.a_char == '-')
547 547 dot = ndot;
548 548 n = 1;
549 549 break;
550 550
551 551 case MDB_TYPE_IMMEDIATE:
552 552 n = argv->a_un.a_val;
553 553 break;
554 554
555 555 case MDB_TYPE_STRING:
556 556 mdb_iob_puts(mdb.m_out, argv->a_un.a_str);
557 557 n = 1;
558 558 break;
559 559 }
560 560 }
561 561
562 562 mdb_iob_clrflags(mdb.m_out, MDB_IOB_INDENT);
563 563 mdb_nv_set_value(mdb.m_dot, dot);
564 564 mdb.m_incr = 0;
565 565
566 566 mdb_tgt_destroy(t);
567 567 return (DCMD_OK);
568 568 }
569 569
570 570 /*ARGSUSED*/
571 571 static int
572 572 cmd_assign_variable(uintptr_t addr, uint_t flags,
573 573 int argc, const mdb_arg_t *argv)
574 574 {
575 575 uintmax_t dot = mdb_nv_get_value(mdb.m_dot);
576 576 const char *p;
577 577 mdb_var_t *v;
578 578
579 579 if (argc == 2) {
580 580 if (argv->a_type != MDB_TYPE_CHAR) {
581 581 mdb_warn("improper arguments following '>' operator\n");
582 582 return (DCMD_ERR);
583 583 }
584 584
585 585 switch (argv->a_un.a_char) {
586 586 case 'c':
587 587 addr = *((uchar_t *)&addr);
588 588 break;
589 589 case 's':
590 590 addr = *((ushort_t *)&addr);
591 591 break;
592 592 case 'i':
593 593 addr = *((uint_t *)&addr);
594 594 break;
595 595 case 'l':
596 596 addr = *((ulong_t *)&addr);
597 597 break;
598 598 default:
599 599 mdb_warn("%c is not a valid // modifier\n",
600 600 argv->a_un.a_char);
601 601 return (DCMD_ERR);
602 602 }
603 603
604 604 dot = addr;
605 605 argv++;
606 606 argc--;
607 607 }
608 608
609 609 if (argc != 1 || argv->a_type != MDB_TYPE_STRING) {
610 610 mdb_warn("expected single variable name following '>'\n");
611 611 return (DCMD_ERR);
612 612 }
613 613
614 614 if (strlen(argv->a_un.a_str) >= (size_t)MDB_NV_NAMELEN) {
615 615 mdb_warn("variable names may not exceed %d characters\n",
616 616 MDB_NV_NAMELEN - 1);
617 617 return (DCMD_ERR);
618 618 }
619 619
620 620 if ((p = strbadid(argv->a_un.a_str)) != NULL) {
621 621 mdb_warn("'%c' may not be used in a variable name\n", *p);
622 622 return (DCMD_ERR);
623 623 }
624 624
625 625 if ((v = mdb_nv_lookup(&mdb.m_nv, argv->a_un.a_str)) == NULL)
626 626 (void) mdb_nv_insert(&mdb.m_nv, argv->a_un.a_str, NULL, dot, 0);
627 627 else
628 628 mdb_nv_set_value(v, dot);
629 629
630 630 mdb.m_incr = 0;
631 631 return (DCMD_OK);
632 632 }
633 633
634 634 static int
635 635 print_soutype(const char *sou, uintptr_t addr, uint_t flags)
636 636 {
637 637 static const char *prefixes[] = { "struct ", "union " };
638 638 size_t namesz = 7 + strlen(sou) + 1;
639 639 char *name = mdb_alloc(namesz, UM_SLEEP | UM_GC);
640 640 mdb_ctf_id_t id;
641 641 int i;
642 642
643 643 for (i = 0; i < 2; i++) {
644 644 (void) mdb_snprintf(name, namesz, "%s%s", prefixes[i], sou);
645 645
646 646 if (mdb_ctf_lookup_by_name(name, &id) == 0) {
647 647 mdb_arg_t v;
648 648 int rv;
649 649
650 650 v.a_type = MDB_TYPE_STRING;
651 651 v.a_un.a_str = name;
652 652
653 653 rv = mdb_call_dcmd("print", addr, flags, 1, &v);
654 654 return (rv);
655 655 }
656 656 }
657 657
658 658 return (DCMD_ERR);
659 659 }
660 660
661 661 static int
662 662 print_type(const char *name, uintptr_t addr, uint_t flags)
663 663 {
664 664 mdb_ctf_id_t id;
665 665 char *sname;
666 666 size_t snamesz;
667 667 int rv;
668 668
669 669 if (!(flags & DCMD_ADDRSPEC)) {
670 670 addr = mdb_get_dot();
671 671 flags |= DCMD_ADDRSPEC;
672 672 }
673 673
674 674 if ((rv = print_soutype(name, addr, flags)) != DCMD_ERR)
675 675 return (rv);
676 676
677 677 snamesz = strlen(name) + 3;
678 678 sname = mdb_zalloc(snamesz, UM_SLEEP | UM_GC);
679 679 (void) mdb_snprintf(sname, snamesz, "%s_t", name);
680 680
681 681 if (mdb_ctf_lookup_by_name(sname, &id) == 0) {
682 682 mdb_arg_t v;
683 683 int rv;
684 684
685 685 v.a_type = MDB_TYPE_STRING;
686 686 v.a_un.a_str = sname;
687 687
688 688 rv = mdb_call_dcmd("print", addr, flags, 1, &v);
689 689 return (rv);
690 690 }
691 691
692 692 sname[snamesz - 2] = 's';
693 693 rv = print_soutype(sname, addr, flags);
694 694 return (rv);
695 695 }
696 696
697 697 static int
698 698 exec_alias(const char *fname, uintptr_t addr, uint_t flags)
699 699 {
700 700 const char *alias;
701 701 int rv;
702 702
703 703 if ((alias = mdb_macalias_lookup(fname)) == NULL)
704 704 return (DCMD_ERR);
705 705
706 706 if (flags & DCMD_ADDRSPEC) {
707 707 size_t sz = sizeof (uintptr_t) * 2 + strlen(alias) + 1;
708 708 char *addralias = mdb_alloc(sz, UM_SLEEP | UM_GC);
709 709 (void) mdb_snprintf(addralias, sz, "%p%s", addr, alias);
710 710 rv = mdb_eval(addralias);
711 711 } else {
712 712 rv = mdb_eval(alias);
713 713 }
714 714
715 715 return (rv == -1 ? DCMD_ABORT : DCMD_OK);
716 716 }
717 717
718 718 /*ARGSUSED*/
719 719 static int
720 720 cmd_src_file(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
721 721 {
722 722 const char *fname;
723 723 mdb_io_t *fio;
724 724 int rv;
725 725
726 726 if (argc != 1 || argv->a_type != MDB_TYPE_STRING)
727 727 return (DCMD_USAGE);
728 728
729 729 fname = argv->a_un.a_str;
730 730
731 731 if (flags & DCMD_PIPE_OUT) {
732 732 mdb_warn("macro files cannot be used as input to a pipeline\n");
733 733 return (DCMD_ABORT);
734 734 }
735 735
736 736 if ((fio = mdb_fdio_create_path(mdb.m_ipath, fname,
737 737 O_RDONLY, 0)) != NULL) {
738 738 mdb_frame_t *fp = mdb.m_frame;
739 739 int err;
740 740
741 741 mdb_iob_stack_push(&fp->f_istk, mdb.m_in, yylineno);
742 742 mdb.m_in = mdb_iob_create(fio, MDB_IOB_RDONLY);
743 743 err = mdb_run();
744 744
745 745 ASSERT(fp == mdb.m_frame);
746 746 mdb.m_in = mdb_iob_stack_pop(&fp->f_istk);
747 747 yylineno = mdb_iob_lineno(mdb.m_in);
748 748
749 749 if (err == MDB_ERR_PAGER && mdb.m_fmark != fp)
750 750 longjmp(fp->f_pcb, err);
751 751
752 752 if (err == MDB_ERR_QUIT || err == MDB_ERR_ABORT ||
753 753 err == MDB_ERR_SIGINT || err == MDB_ERR_OUTPUT)
754 754 longjmp(fp->f_pcb, err);
755 755
756 756 return (DCMD_OK);
757 757 }
758 758
759 759 if ((rv = exec_alias(fname, addr, flags)) != DCMD_ERR ||
760 760 (rv = print_type(fname, addr, flags)) != DCMD_ERR)
761 761 return (rv);
762 762
763 763 mdb_warn("failed to open %s (see ::help '$<')\n", fname);
764 764 return (DCMD_ABORT);
765 765 }
766 766
767 767 static int
768 768 cmd_exec_file(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
769 769 {
770 770 const char *fname;
771 771 mdb_io_t *fio;
772 772 int rv;
773 773
774 774 /*
775 775 * The syntax [expr[,count]]$< with no trailing macro file name is
776 776 * magic in that if count is zero, this command won't be called and
777 777 * the expression is thus a no-op. If count is non-zero, we get
778 778 * invoked with argc == 0, and this means abort the current macro.
779 779 * If our debugger stack depth is greater than one, we may be using
780 780 * $< from within a previous $<<, so in that case we set m_in to
781 781 * NULL to force this entire frame to be popped.
782 782 */
783 783 if (argc == 0) {
784 784 if (mdb_iob_stack_size(&mdb.m_frame->f_istk) != 0) {
785 785 mdb_iob_destroy(mdb.m_in);
786 786 mdb.m_in = mdb_iob_stack_pop(&mdb.m_frame->f_istk);
787 787 } else if (mdb.m_depth > 1) {
788 788 mdb_iob_destroy(mdb.m_in);
789 789 mdb.m_in = NULL;
790 790 } else
791 791 mdb_warn("input stack is empty\n");
792 792 return (DCMD_OK);
793 793 }
794 794
795 795 if ((flags & (DCMD_PIPE | DCMD_PIPE_OUT)) || mdb.m_depth == 1)
796 796 return (cmd_src_file(addr, flags, argc, argv));
797 797
798 798 if (argc != 1 || argv->a_type != MDB_TYPE_STRING)
799 799 return (DCMD_USAGE);
800 800
801 801 fname = argv->a_un.a_str;
802 802
803 803 if ((fio = mdb_fdio_create_path(mdb.m_ipath, fname,
804 804 O_RDONLY, 0)) != NULL) {
805 805 mdb_iob_destroy(mdb.m_in);
806 806 mdb.m_in = mdb_iob_create(fio, MDB_IOB_RDONLY);
807 807 return (DCMD_OK);
808 808 }
809 809
810 810 if ((rv = exec_alias(fname, addr, flags)) != DCMD_ERR ||
811 811 (rv = print_type(fname, addr, flags)) != DCMD_ERR)
812 812 return (rv);
813 813
814 814 mdb_warn("failed to open %s (see ::help '$<')\n", fname);
815 815 return (DCMD_ABORT);
816 816 }
817 817
818 818 #ifndef _KMDB
819 819 /*ARGSUSED*/
820 820 static int
821 821 cmd_cat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
822 822 {
823 823 int status = DCMD_OK;
824 824 char buf[BUFSIZ];
825 825 mdb_iob_t *iob;
826 826 mdb_io_t *fio;
827 827
828 828 if (flags & DCMD_ADDRSPEC)
829 829 return (DCMD_USAGE);
830 830
831 831 for (; argc-- != 0; argv++) {
832 832 if (argv->a_type != MDB_TYPE_STRING) {
833 833 mdb_warn("expected string argument\n");
834 834 status = DCMD_ERR;
835 835 continue;
836 836 }
837 837
838 838 if ((fio = mdb_fdio_create_path(NULL,
839 839 argv->a_un.a_str, O_RDONLY, 0)) == NULL) {
840 840 mdb_warn("failed to open %s", argv->a_un.a_str);
841 841 status = DCMD_ERR;
842 842 continue;
843 843 }
844 844
845 845 iob = mdb_iob_create(fio, MDB_IOB_RDONLY);
846 846
847 847 while (!(mdb_iob_getflags(iob) & (MDB_IOB_EOF | MDB_IOB_ERR))) {
848 848 ssize_t len = mdb_iob_read(iob, buf, sizeof (buf));
849 849 if (len > 0) {
850 850 if (mdb_iob_write(mdb.m_out, buf, len) < 0) {
851 851 if (errno != EPIPE)
852 852 mdb_warn("write failed");
853 853 status = DCMD_ERR;
854 854 break;
855 855 }
856 856 }
857 857 }
858 858
859 859 if (mdb_iob_err(iob))
860 860 mdb_warn("error while reading %s", mdb_iob_name(iob));
861 861
862 862 mdb_iob_destroy(iob);
863 863 }
864 864
865 865 return (status);
866 866 }
867 867 #endif
868 868
869 869 /*ARGSUSED*/
870 870 static int
871 871 cmd_grep(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
872 872 {
873 873 if (argc != 1 || argv->a_type != MDB_TYPE_STRING)
874 874 return (DCMD_USAGE);
875 875
876 876 if (mdb_eval(argv->a_un.a_str) == -1)
877 877 return (DCMD_ABORT);
878 878
879 879 if (mdb_get_dot() != 0)
880 880 mdb_printf("%lr\n", addr);
881 881
882 882 return (DCMD_OK);
883 883 }
884 884
885 885 /*ARGSUSED*/
886 886 static int
887 887 cmd_map(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
888 888 {
889 889 if (argc != 1 || argv->a_type != MDB_TYPE_STRING)
890 890 return (DCMD_USAGE);
891 891
892 892 if (mdb_eval(argv->a_un.a_str) == -1)
893 893 return (DCMD_ABORT);
894 894
895 895 mdb_printf("%llr\n", mdb_get_dot());
896 896 return (DCMD_OK);
897 897 }
898 898
899 899 /*ARGSUSED*/
900 900 static int
901 901 cmd_notsup(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
902 902 {
903 903 mdb_warn("command is not supported by current target\n");
904 904 return (DCMD_ERR);
905 905 }
906 906
907 907 /*ARGSUSED*/
908 908 static int
909 909 cmd_quit(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
910 910 {
911 911 #ifdef _KMDB
912 912 uint_t opt_u = FALSE;
913 913
914 914 if (mdb_getopts(argc, argv,
915 915 'u', MDB_OPT_SETBITS, TRUE, &opt_u, NULL) != argc)
916 916 return (DCMD_USAGE);
917 917
918 918 if (opt_u) {
919 919 if (mdb.m_flags & MDB_FL_NOUNLOAD) {
920 920 warn("%s\n", mdb_strerror(EMDB_KNOUNLOAD));
921 921 return (DCMD_ERR);
922 922 }
923 923
924 924 kmdb_kdi_set_unload_request();
925 925 }
926 926 #endif
927 927
928 928 longjmp(mdb.m_frame->f_pcb, MDB_ERR_QUIT);
929 929 /*NOTREACHED*/
930 930 return (DCMD_ERR);
931 931 }
932 932
933 933 #ifdef _KMDB
934 934 static void
935 935 quit_help(void)
936 936 {
937 937 mdb_printf(
938 938 "-u unload the debugger (if not loaded at boot)\n");
939 939 }
940 940 #endif
941 941
942 942 /*ARGSUSED*/
943 943 static int
944 944 cmd_vars(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
945 945 {
946 946 uint_t opt_nz = FALSE, opt_tag = FALSE, opt_prt = FALSE;
947 947 mdb_var_t *v;
948 948
949 949 if (mdb_getopts(argc, argv,
950 950 'n', MDB_OPT_SETBITS, TRUE, &opt_nz,
951 951 'p', MDB_OPT_SETBITS, TRUE, &opt_prt,
952 952 't', MDB_OPT_SETBITS, TRUE, &opt_tag, NULL) != argc)
953 953 return (DCMD_USAGE);
954 954
955 955 mdb_nv_rewind(&mdb.m_nv);
956 956
957 957 while ((v = mdb_nv_advance(&mdb.m_nv)) != NULL) {
958 958 if ((opt_tag == FALSE || (v->v_flags & MDB_NV_TAGGED)) &&
959 959 (opt_nz == FALSE || mdb_nv_get_value(v) != 0)) {
960 960 if (opt_prt) {
961 961 mdb_printf("%#llr>%s\n",
962 962 mdb_nv_get_value(v), mdb_nv_get_name(v));
963 963 } else {
964 964 mdb_printf("%s = %llr\n",
965 965 mdb_nv_get_name(v), mdb_nv_get_value(v));
966 966 }
967 967 }
968 968 }
969 969
970 970 return (DCMD_OK);
971 971 }
972 972
973 973 /*ARGSUSED*/
974 974 static int
975 975 cmd_nzvars(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
976 976 {
977 977 uintmax_t value;
978 978 mdb_var_t *v;
979 979
980 980 if (argc != 0)
981 981 return (DCMD_USAGE);
982 982
983 983 mdb_nv_rewind(&mdb.m_nv);
984 984
985 985 while ((v = mdb_nv_advance(&mdb.m_nv)) != NULL) {
986 986 if ((value = mdb_nv_get_value(v)) != 0)
987 987 mdb_printf("%s = %llr\n", mdb_nv_get_name(v), value);
988 988 }
989 989
990 990 return (DCMD_OK);
991 991 }
992 992
993 993 /*ARGSUSED*/
994 994 static int
995 995 cmd_radix(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
996 996 {
997 997 if (argc != 0)
998 998 return (DCMD_USAGE);
999 999
1000 1000 if (flags & DCMD_ADDRSPEC) {
1001 1001 if (addr < 2 || addr > 16) {
1002 1002 mdb_warn("expected radix from 2 to 16\n");
1003 1003 return (DCMD_ERR);
1004 1004 }
1005 1005 mdb.m_radix = (int)addr;
1006 1006 }
1007 1007
1008 1008 mdb_iob_printf(mdb.m_out, "radix = %d base ten\n", mdb.m_radix);
1009 1009 return (DCMD_OK);
1010 1010 }
1011 1011
1012 1012 /*ARGSUSED*/
1013 1013 static int
1014 1014 cmd_symdist(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1015 1015 {
1016 1016 if (argc != 0)
1017 1017 return (DCMD_USAGE);
1018 1018
1019 1019 if (flags & DCMD_ADDRSPEC)
1020 1020 mdb.m_symdist = addr;
1021 1021
1022 1022 mdb_printf("symbol matching distance = %lr (%s)\n",
1023 1023 mdb.m_symdist, mdb.m_symdist ? "absolute mode" : "smart mode");
1024 1024
1025 1025 return (DCMD_OK);
1026 1026 }
1027 1027
1028 1028 /*ARGSUSED*/
1029 1029 static int
1030 1030 cmd_pgwidth(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1031 1031 {
1032 1032 if (argc != 0)
1033 1033 return (DCMD_USAGE);
1034 1034
1035 1035 if (flags & DCMD_ADDRSPEC)
1036 1036 mdb_iob_resize(mdb.m_out, mdb.m_out->iob_rows, addr);
1037 1037
1038 1038 mdb_printf("output page width = %lu\n", mdb.m_out->iob_cols);
1039 1039 return (DCMD_OK);
1040 1040 }
1041 1041
1042 1042 /*ARGSUSED*/
1043 1043 static int
1044 1044 cmd_reopen(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1045 1045 {
1046 1046 if (argc != 0)
1047 1047 return (DCMD_USAGE);
1048 1048
1049 1049 if (mdb_tgt_setflags(mdb.m_target, MDB_TGT_F_RDWR) == -1) {
1050 1050 mdb_warn("failed to re-open target for writing");
1051 1051 return (DCMD_ERR);
1052 1052 }
1053 1053
1054 1054 return (DCMD_OK);
1055 1055 }
1056 1056
1057 1057 /*ARGSUSED*/
1058 1058 static int
1059 1059 print_xdata(void *ignored, const char *name, const char *desc, size_t nbytes)
1060 1060 {
1061 1061 mdb_printf("%-24s - %s (%lu bytes)\n", name, desc, (ulong_t)nbytes);
1062 1062 return (0);
1063 1063 }
1064 1064
1065 1065 /*ARGSUSED*/
1066 1066 static int
1067 1067 cmd_xdata(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1068 1068 {
1069 1069 if (argc != 0 || (flags & DCMD_ADDRSPEC))
1070 1070 return (DCMD_USAGE);
1071 1071
1072 1072 (void) mdb_tgt_xdata_iter(mdb.m_target, print_xdata, NULL);
1073 1073 return (DCMD_OK);
1074 1074 }
1075 1075
1076 1076 /*ARGSUSED*/
1077 1077 static int
1078 1078 cmd_unset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1079 1079 {
1080 1080 mdb_var_t *v;
1081 1081 size_t i;
1082 1082
1083 1083 for (i = 0; i < argc; i++) {
1084 1084 if (argv[i].a_type != MDB_TYPE_STRING) {
1085 1085 mdb_warn("bad option: arg %lu is not a string\n",
1086 1086 (ulong_t)i + 1);
1087 1087 return (DCMD_USAGE);
1088 1088 }
1089 1089 }
1090 1090
1091 1091 for (i = 0; i < argc; i++, argv++) {
1092 1092 if ((v = mdb_nv_lookup(&mdb.m_nv, argv->a_un.a_str)) == NULL)
1093 1093 mdb_warn("variable '%s' not defined\n",
1094 1094 argv->a_un.a_str);
1095 1095 else
1096 1096 mdb_nv_remove(&mdb.m_nv, v);
1097 1097 }
1098 1098
1099 1099 return (DCMD_OK);
1100 1100 }
1101 1101
1102 1102 #ifndef _KMDB
1103 1103 /*ARGSUSED*/
1104 1104 static int
1105 1105 cmd_log(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1106 1106 {
1107 1107 uint_t opt_e = FALSE, opt_d = FALSE;
1108 1108 const char *filename = NULL;
1109 1109 int i;
1110 1110
1111 1111 i = mdb_getopts(argc, argv,
1112 1112 'd', MDB_OPT_SETBITS, TRUE, &opt_d,
1113 1113 'e', MDB_OPT_SETBITS, TRUE, &opt_e, NULL);
1114 1114
1115 1115 if ((i != argc && i != argc - 1) || (opt_d && opt_e) ||
1116 1116 (i != argc && argv[i].a_type != MDB_TYPE_STRING) ||
1117 1117 (i != argc && opt_d == TRUE) || (flags & DCMD_ADDRSPEC))
1118 1118 return (DCMD_USAGE);
1119 1119
1120 1120 if (mdb.m_depth != 1) {
1121 1121 mdb_warn("log may not be manipulated in this context\n");
1122 1122 return (DCMD_ABORT);
1123 1123 }
1124 1124
1125 1125 if (i != argc)
1126 1126 filename = argv[i].a_un.a_str;
1127 1127
1128 1128 /*
1129 1129 * If no arguments were specified, print the log file name (if any)
1130 1130 * and report whether the log is enabled or disabled.
1131 1131 */
1132 1132 if (argc == 0) {
1133 1133 if (mdb.m_log) {
1134 1134 mdb_printf("%s: logging to \"%s\" is currently %s\n",
1135 1135 mdb.m_pname, IOP_NAME(mdb.m_log),
1136 1136 mdb.m_flags & MDB_FL_LOG ? "enabled" : "disabled");
1137 1137 } else
1138 1138 mdb_printf("%s: no log is active\n", mdb.m_pname);
1139 1139 return (DCMD_OK);
1140 1140 }
1141 1141
1142 1142 /*
1143 1143 * If the -d option was specified, pop the log i/o object off the
1144 1144 * i/o stack of stdin, stdout, and stderr.
1145 1145 */
1146 1146 if (opt_d) {
1147 1147 if (mdb.m_flags & MDB_FL_LOG) {
1148 1148 (void) mdb_iob_pop_io(mdb.m_in);
1149 1149 (void) mdb_iob_pop_io(mdb.m_out);
1150 1150 (void) mdb_iob_pop_io(mdb.m_err);
1151 1151 mdb.m_flags &= ~MDB_FL_LOG;
1152 1152 } else
1153 1153 mdb_warn("logging is already disabled\n");
1154 1154 return (DCMD_OK);
1155 1155 }
1156 1156
1157 1157 /*
1158 1158 * The -e option is the default: (re-)enable logging by pushing
1159 1159 * the log i/o object on to stdin, stdout, and stderr. If we have
1160 1160 * a previous log file, we need to pop it and close it. If we have
1161 1161 * no new log file, push the previous one back on.
1162 1162 */
1163 1163 if (filename != NULL) {
1164 1164 if (mdb.m_log != NULL) {
1165 1165 if (mdb.m_flags & MDB_FL_LOG) {
1166 1166 (void) mdb_iob_pop_io(mdb.m_in);
1167 1167 (void) mdb_iob_pop_io(mdb.m_out);
1168 1168 (void) mdb_iob_pop_io(mdb.m_err);
1169 1169 mdb.m_flags &= ~MDB_FL_LOG;
1170 1170 }
1171 1171 mdb_io_rele(mdb.m_log);
1172 1172 }
1173 1173
1174 1174 mdb.m_log = mdb_fdio_create_path(NULL, filename,
1175 1175 O_CREAT | O_APPEND | O_WRONLY, 0666);
1176 1176
1177 1177 if (mdb.m_log == NULL) {
1178 1178 mdb_warn("failed to open %s", filename);
1179 1179 return (DCMD_ERR);
1180 1180 }
1181 1181 }
1182 1182
1183 1183 if (mdb.m_log != NULL) {
1184 1184 mdb_iob_push_io(mdb.m_in, mdb_logio_create(mdb.m_log));
1185 1185 mdb_iob_push_io(mdb.m_out, mdb_logio_create(mdb.m_log));
1186 1186 mdb_iob_push_io(mdb.m_err, mdb_logio_create(mdb.m_log));
1187 1187
1188 1188 mdb_printf("%s: logging to \"%s\"\n", mdb.m_pname, filename);
1189 1189 mdb.m_log = mdb_io_hold(mdb.m_log);
1190 1190 mdb.m_flags |= MDB_FL_LOG;
1191 1191
1192 1192 return (DCMD_OK);
1193 1193 }
1194 1194
1195 1195 mdb_warn("no log file has been selected\n");
1196 1196 return (DCMD_ERR);
1197 1197 }
1198 1198
1199 1199 static int
1200 1200 cmd_old_log(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1201 1201 {
1202 1202 if (argc == 0) {
1203 1203 mdb_arg_t arg = { MDB_TYPE_STRING, MDB_INIT_STRING("-d") };
1204 1204 return (cmd_log(addr, flags, 1, &arg));
1205 1205 }
1206 1206
1207 1207 return (cmd_log(addr, flags, argc, argv));
1208 1208 }
1209 1209 #endif
1210 1210
1211 1211 /*ARGSUSED*/
1212 1212 static int
1213 1213 cmd_load(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1214 1214 {
1215 1215 int i, mode = MDB_MOD_LOCAL;
1216 1216
1217 1217 i = mdb_getopts(argc, argv,
1218 1218 #ifdef _KMDB
1219 1219 'd', MDB_OPT_SETBITS, MDB_MOD_DEFER, &mode,
1220 1220 #endif
1221 1221 'f', MDB_OPT_SETBITS, MDB_MOD_FORCE, &mode,
1222 1222 'g', MDB_OPT_SETBITS, MDB_MOD_GLOBAL, &mode,
1223 1223 's', MDB_OPT_SETBITS, MDB_MOD_SILENT, &mode,
1224 1224 NULL);
1225 1225
1226 1226 argc -= i;
1227 1227 argv += i;
1228 1228
1229 1229 if ((flags & DCMD_ADDRSPEC) || argc != 1 ||
1230 1230 argv->a_type != MDB_TYPE_STRING ||
1231 1231 strchr("+-", argv->a_un.a_str[0]) != NULL)
1232 1232 return (DCMD_USAGE);
1233 1233
1234 1234 if (mdb_module_load(argv->a_un.a_str, mode) < 0)
1235 1235 return (DCMD_ERR);
1236 1236
1237 1237 return (DCMD_OK);
1238 1238 }
1239 1239
1240 1240 static void
1241 1241 load_help(void)
1242 1242 {
1243 1243 mdb_printf(
1244 1244 #ifdef _KMDB
1245 1245 "-d defer load until next continue\n"
1246 1246 #endif
1247 1247 "-s load module silently\n");
1248 1248 }
1249 1249
1250 1250 /*ARGSUSED*/
1251 1251 static int
1252 1252 cmd_unload(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1253 1253 {
1254 1254 int mode = 0;
1255 1255 int i;
1256 1256
1257 1257 i = mdb_getopts(argc, argv,
1258 1258 #ifdef _KMDB
1259 1259 'd', MDB_OPT_SETBITS, MDB_MOD_DEFER, &mode,
1260 1260 #endif
1261 1261 NULL);
1262 1262
1263 1263 argc -= i;
1264 1264 argv += i;
1265 1265
1266 1266 if (argc != 1 || argv->a_type != MDB_TYPE_STRING)
1267 1267 return (DCMD_USAGE);
1268 1268
1269 1269 if (mdb_module_unload(argv->a_un.a_str, mode) == -1) {
1270 1270 mdb_warn("failed to unload %s", argv->a_un.a_str);
1271 1271 return (DCMD_ERR);
1272 1272 }
1273 1273
1274 1274 return (DCMD_OK);
1275 1275 }
1276 1276
1277 1277 #ifdef _KMDB
1278 1278 static void
1279 1279 unload_help(void)
1280 1280 {
1281 1281 mdb_printf(
1282 1282 "-d defer unload until next continue\n");
1283 1283 }
1284 1284 #endif
1285 1285
1286 1286 static int
1287 1287 cmd_dbmode(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1288 1288 {
1289 1289 if (argc > 1 || (argc != 0 && (flags & DCMD_ADDRSPEC)))
1290 1290 return (DCMD_USAGE);
1291 1291
1292 1292 if (argc != 0) {
1293 1293 if (argv->a_type != MDB_TYPE_STRING)
1294 1294 return (DCMD_USAGE);
1295 1295 if ((addr = mdb_dstr2mode(argv->a_un.a_str)) != MDB_DBG_HELP)
1296 1296 mdb_dmode(addr);
1297 1297 } else if (flags & DCMD_ADDRSPEC)
1298 1298 mdb_dmode(addr);
1299 1299
1300 1300 mdb_printf("debugging mode = 0x%04x\n", mdb.m_debug);
1301 1301 return (DCMD_OK);
1302 1302 }
1303 1303
1304 1304 /*ARGSUSED*/
1305 1305 static int
1306 1306 cmd_version(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1307 1307 {
1308 1308 #ifdef DEBUG
1309 1309 mdb_printf("\r%s (DEBUG)\n", mdb_conf_version());
1310 1310 #else
1311 1311 mdb_printf("\r%s\n", mdb_conf_version());
1312 1312 #endif
1313 1313 return (DCMD_OK);
1314 1314 }
1315 1315
1316 1316 /*ARGSUSED*/
1317 1317 static int
1318 1318 cmd_algol(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1319 1319 {
1320 1320 if (mdb.m_flags & MDB_FL_ADB)
1321 1321 mdb_printf("No algol 68 here\n");
1322 1322 else
1323 1323 mdb_printf("No adb here\n");
1324 1324 return (DCMD_OK);
1325 1325 }
1326 1326
1327 1327 /*ARGSUSED*/
1328 1328 static int
1329 1329 cmd_obey(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1330 1330 {
1331 1331 if (mdb.m_flags & MDB_FL_ADB)
1332 1332 mdb_printf("CHAPTER 1\n");
1333 1333 else
1334 1334 mdb_printf("No Language H here\n");
1335 1335 return (DCMD_OK);
1336 1336 }
1337 1337
1338 1338 /*ARGSUSED*/
1339 1339 static int
1340 1340 print_global(void *data, const GElf_Sym *sym, const char *name,
1341 1341 const mdb_syminfo_t *sip, const char *obj)
1342 1342 {
1343 1343 uintptr_t value;
1344 1344
1345 1345 if (mdb_tgt_vread((mdb_tgt_t *)data, &value, sizeof (value),
1346 1346 (uintptr_t)sym->st_value) == sizeof (value))
1347 1347 mdb_printf("%s(%llr):\t%lr\n", name, sym->st_value, value);
1348 1348 else
1349 1349 mdb_printf("%s(%llr):\t?\n", name, sym->st_value);
1350 1350
1351 1351 return (0);
1352 1352 }
1353 1353
1354 1354 /*ARGSUSED*/
1355 1355 static int
1356 1356 cmd_globals(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1357 1357 {
1358 1358 if (argc != 0)
1359 1359 return (DCMD_USAGE);
1360 1360
1361 1361 (void) mdb_tgt_symbol_iter(mdb.m_target, MDB_TGT_OBJ_EVERY,
1362 1362 MDB_TGT_SYMTAB, MDB_TGT_BIND_GLOBAL | MDB_TGT_TYPE_OBJECT |
1363 1363 MDB_TGT_TYPE_FUNC, print_global, mdb.m_target);
1364 1364
1365 1365 return (0);
1366 1366 }
1367 1367
1368 1368 /*ARGSUSED*/
1369 1369 static int
1370 1370 cmd_eval(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1371 1371 {
1372 1372 if (argc != 1 || argv->a_type != MDB_TYPE_STRING)
1373 1373 return (DCMD_USAGE);
1374 1374
1375 1375 if (mdb_eval(argv->a_un.a_str) == -1)
1376 1376 return (DCMD_ABORT);
1377 1377
1378 1378 return (DCMD_OK);
1379 1379 }
1380 1380
1381 1381 /*ARGSUSED*/
1382 1382 static int
1383 1383 print_file(void *data, const GElf_Sym *sym, const char *name,
1384 1384 const mdb_syminfo_t *sip, const char *obj)
1385 1385 {
1386 1386 int i = *((int *)data);
1387 1387
1388 1388 mdb_printf("%d\t%s\n", i++, name);
1389 1389 *((int *)data) = i;
1390 1390 return (0);
1391 1391 }
1392 1392
1393 1393 /*ARGSUSED*/
1394 1394 static int
1395 1395 cmd_files(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1396 1396 {
1397 1397 int i = 1;
1398 1398 const char *obj = MDB_TGT_OBJ_EVERY;
1399 1399
1400 1400 if ((flags & DCMD_ADDRSPEC) || argc > 1)
1401 1401 return (DCMD_USAGE);
1402 1402
1403 1403 if (argc == 1) {
1404 1404 if (argv->a_type != MDB_TYPE_STRING)
1405 1405 return (DCMD_USAGE);
1406 1406
1407 1407 obj = argv->a_un.a_str;
1408 1408 }
1409 1409
1410 1410 (void) mdb_tgt_symbol_iter(mdb.m_target, obj, MDB_TGT_SYMTAB,
1411 1411 MDB_TGT_BIND_ANY | MDB_TGT_TYPE_FILE, print_file, &i);
1412 1412
1413 1413 return (DCMD_OK);
1414 1414 }
1415 1415
1416 1416 static const char *
1417 1417 map_name(const mdb_map_t *map, const char *name)
1418 1418 {
1419 1419 if (map->map_flags & MDB_TGT_MAP_HEAP)
1420 1420 return ("[ heap ]");
1421 1421 if (name != NULL && name[0] != 0)
1422 1422 return (name);
1423 1423
1424 1424 if (map->map_flags & MDB_TGT_MAP_SHMEM)
1425 1425 return ("[ shmem ]");
1426 1426 if (map->map_flags & MDB_TGT_MAP_STACK)
1427 1427 return ("[ stack ]");
1428 1428 if (map->map_flags & MDB_TGT_MAP_ANON)
1429 1429 return ("[ anon ]");
1430 1430 if (map->map_name != NULL)
1431 1431 return (map->map_name);
1432 1432 return ("[ unknown ]");
1433 1433 }
1434 1434
1435 1435 /*ARGSUSED*/
1436 1436 static int
1437 1437 print_map(void *ignored, const mdb_map_t *map, const char *name)
1438 1438 {
1439 1439 name = map_name(map, name);
1440 1440
1441 1441 mdb_printf("%?p %?p %?lx %s\n", map->map_base,
1442 1442 map->map_base + map->map_size, map->map_size, name);
1443 1443 return (0);
1444 1444 }
1445 1445
1446 1446 static int
1447 1447 cmd_mappings(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1448 1448 {
1449 1449 const mdb_map_t *m;
1450 1450
1451 1451 if (argc > 1 || (argc != 0 && (flags & DCMD_ADDRSPEC)))
1452 1452 return (DCMD_USAGE);
1453 1453
1454 1454 mdb_printf("%<u>%?s %?s %?s %s%</u>\n",
1455 1455 "BASE", "LIMIT", "SIZE", "NAME");
1456 1456
1457 1457 if (flags & DCMD_ADDRSPEC) {
1458 1458 if ((m = mdb_tgt_addr_to_map(mdb.m_target, addr)) == NULL)
1459 1459 mdb_warn("failed to obtain mapping");
1460 1460 else
1461 1461 (void) print_map(NULL, m, NULL);
1462 1462
1463 1463 } else if (argc != 0) {
1464 1464 if (argv->a_type == MDB_TYPE_STRING)
1465 1465 m = mdb_tgt_name_to_map(mdb.m_target, argv->a_un.a_str);
1466 1466 else
1467 1467 m = mdb_tgt_addr_to_map(mdb.m_target, argv->a_un.a_val);
1468 1468
1469 1469 if (m == NULL)
1470 1470 mdb_warn("failed to obtain mapping");
1471 1471 else
1472 1472 (void) print_map(NULL, m, NULL);
1473 1473
1474 1474 } else if (mdb_tgt_mapping_iter(mdb.m_target, print_map, NULL) == -1)
1475 1475 mdb_warn("failed to iterate over mappings");
1476 1476
1477 1477 return (DCMD_OK);
1478 1478 }
1479 1479
1480 1480 static int
1481 1481 whatis_map_callback(void *wp, const mdb_map_t *map, const char *name)
1482 1482 {
1483 1483 mdb_whatis_t *w = wp;
1484 1484 uintptr_t cur;
1485 1485
1486 1486 name = map_name(map, name);
1487 1487
1488 1488 while (mdb_whatis_match(w, map->map_base, map->map_size, &cur))
1489 1489 mdb_whatis_report_address(w, cur, "in %s [%p,%p)\n",
1490 1490 name, map->map_base, map->map_base + map->map_size);
1491 1491
1492 1492 return (0);
1493 1493 }
1494 1494
1495 1495 /*ARGSUSED*/
1496 1496 int
1497 1497 whatis_run_mappings(mdb_whatis_t *w, void *ignored)
1498 1498 {
1499 1499 (void) mdb_tgt_mapping_iter(mdb.m_target, whatis_map_callback, w);
1500 1500 return (0);
1501 1501 }
1502 1502
1503 1503 /*ARGSUSED*/
1504 1504 static int
1505 1505 objects_printversion(void *ignored, const mdb_map_t *map, const char *name)
1506 1506 {
1507 1507 ctf_file_t *ctfp;
1508 1508 const char *version;
1509 1509
1510 1510 ctfp = mdb_tgt_name_to_ctf(mdb.m_target, name);
1511 1511 if (ctfp == NULL || (version = ctf_label_topmost(ctfp)) == NULL)
1512 1512 version = "Unknown";
1513 1513
1514 1514 mdb_printf("%-28s %s\n", name, version);
1515 1515 return (0);
1516 1516 }
1517 1517
1518 1518 /*ARGSUSED*/
1519 1519 static int
1520 1520 cmd_objects(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1521 1521 {
1522 1522 uint_t opt_v = FALSE;
1523 1523 mdb_tgt_map_f *cb;
1524 1524
1525 1525 if ((flags & DCMD_ADDRSPEC) || mdb_getopts(argc, argv,
1526 1526 'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
1527 1527 return (DCMD_USAGE);
1528 1528
1529 1529 if (opt_v) {
1530 1530 cb = objects_printversion;
1531 1531 mdb_printf("%<u>%-28s %s%</u>\n", "NAME", "VERSION");
1532 1532 } else {
1533 1533 cb = print_map;
1534 1534 mdb_printf("%<u>%?s %?s %?s %s%</u>\n",
1535 1535 "BASE", "LIMIT", "SIZE", "NAME");
1536 1536 }
1537 1537
1538 1538 if (mdb_tgt_object_iter(mdb.m_target, cb, NULL) == -1) {
1539 1539 mdb_warn("failed to iterate over objects");
1540 1540 return (DCMD_ERR);
1541 1541 }
1542 1542
1543 1543 return (DCMD_OK);
1544 1544 }
1545 1545
1546 1546 /*ARGSUSED*/
1547 1547 static int
1548 1548 showrev_addversion(void *vers_nv, const mdb_map_t *ignored, const char *object)
1549 1549 {
1550 1550 ctf_file_t *ctfp;
1551 1551 const char *version = NULL;
1552 1552 char *objname;
1553 1553
1554 1554 objname = mdb_alloc(strlen(object) + 1, UM_SLEEP | UM_GC);
1555 1555 (void) strcpy(objname, object);
|
↓ open down ↓ |
1555 lines elided |
↑ open up ↑ |
1556 1556
1557 1557 if ((ctfp = mdb_tgt_name_to_ctf(mdb.m_target, objname)) != NULL)
1558 1558 version = ctf_label_topmost(ctfp);
1559 1559
1560 1560 /*
1561 1561 * Not all objects have CTF and label data, so set version to "Unknown".
1562 1562 */
1563 1563 if (version == NULL)
1564 1564 version = "Unknown";
1565 1565
1566 - /*
1567 - * The hash table implementation in OVERLOAD mode limits the version
1568 - * name to 31 characters because we cannot specify an external name.
1569 - * The full version name is available via the ::objects dcmd if needed.
1570 - */
1571 1566 (void) mdb_nv_insert(vers_nv, version, NULL, (uintptr_t)objname,
1572 1567 MDB_NV_OVERLOAD);
1573 1568
1574 1569 return (0);
1575 1570 }
1576 1571
1577 1572 static int
1578 1573 showrev_ispatch(const char *s)
1579 1574 {
1580 1575 if (s == NULL)
1581 1576 return (0);
1582 1577
1583 1578 if (*s == 'T')
1584 1579 s++; /* skip T for T-patch */
1585 1580
1586 1581 for (; *s != '\0'; s++) {
1587 1582 if ((*s < '0' || *s > '9') && *s != '-')
1588 1583 return (0);
1589 1584 }
1590 1585
1591 1586 return (1);
1592 1587 }
1593 1588
1594 1589 /*ARGSUSED*/
1595 1590 static int
1596 1591 showrev_printobject(mdb_var_t *v, void *ignored)
1597 1592 {
1598 1593 mdb_printf("%s ", MDB_NV_COOKIE(v));
1599 1594 return (0);
1600 1595 }
1601 1596
1602 1597 static int
1603 1598 showrev_printversion(mdb_var_t *v, void *showall)
1604 1599 {
1605 1600 const char *version = mdb_nv_get_name(v);
1606 1601 int patch;
1607 1602
1608 1603 patch = showrev_ispatch(version);
1609 1604 if (patch || (uintptr_t)showall) {
1610 1605 mdb_printf("%s: %s Objects: ",
1611 1606 (patch ? "Patch" : "Version"), version);
1612 1607 (void) mdb_inc_indent(2);
1613 1608
1614 1609 mdb_nv_defn_iter(v, showrev_printobject, NULL);
1615 1610
1616 1611 (void) mdb_dec_indent(2);
1617 1612 mdb_printf("\n");
1618 1613 }
1619 1614
1620 1615 return (0);
1621 1616 }
1622 1617
1623 1618 /*
1624 1619 * Display version information for each object in the system.
1625 1620 * Print information about patches only, unless showall is TRUE.
1626 1621 */
1627 1622 static int
1628 1623 showrev_objectversions(int showall)
1629 1624 {
1630 1625 mdb_nv_t vers_nv;
1631 1626
1632 1627 (void) mdb_nv_create(&vers_nv, UM_SLEEP | UM_GC);
1633 1628 if (mdb_tgt_object_iter(mdb.m_target, showrev_addversion,
1634 1629 &vers_nv) == -1) {
1635 1630 mdb_warn("failed to iterate over objects");
1636 1631 return (DCMD_ERR);
1637 1632 }
1638 1633
1639 1634 mdb_nv_sort_iter(&vers_nv, showrev_printversion,
1640 1635 (void *)(uintptr_t)showall, UM_SLEEP | UM_GC);
1641 1636 return (DCMD_OK);
1642 1637 }
1643 1638
1644 1639 /*
1645 1640 * Display information similar to what showrev(1M) displays when invoked
1646 1641 * with no arguments.
1647 1642 */
1648 1643 static int
1649 1644 showrev_sysinfo(void)
1650 1645 {
1651 1646 const char *s;
1652 1647 int rc;
1653 1648 struct utsname u;
1654 1649
1655 1650 if ((rc = mdb_tgt_uname(mdb.m_target, &u)) != -1) {
1656 1651 mdb_printf("Hostname: %s\n", u.nodename);
1657 1652 mdb_printf("Release: %s\n", u.release);
1658 1653 mdb_printf("Kernel architecture: %s\n", u.machine);
1659 1654 }
1660 1655
1661 1656 /*
1662 1657 * Match the order of the showrev(1M) output and put "Application
1663 1658 * architecture" before "Kernel version"
1664 1659 */
1665 1660 if ((s = mdb_tgt_isa(mdb.m_target)) != NULL)
1666 1661 mdb_printf("Application architecture: %s\n", s);
1667 1662
1668 1663 if (rc != -1)
1669 1664 mdb_printf("Kernel version: %s %s %s %s\n",
1670 1665 u.sysname, u.release, u.machine, u.version);
1671 1666
1672 1667 if ((s = mdb_tgt_platform(mdb.m_target)) != NULL)
1673 1668 mdb_printf("Platform: %s\n", s);
1674 1669
1675 1670 return (DCMD_OK);
1676 1671 }
1677 1672
1678 1673 /*ARGSUSED*/
1679 1674 static int
1680 1675 cmd_showrev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1681 1676 {
1682 1677 uint_t opt_p = FALSE, opt_v = FALSE;
1683 1678
1684 1679 if ((flags & DCMD_ADDRSPEC) || mdb_getopts(argc, argv,
1685 1680 'p', MDB_OPT_SETBITS, TRUE, &opt_p,
1686 1681 'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
1687 1682 return (DCMD_USAGE);
1688 1683
1689 1684 if (opt_p || opt_v)
1690 1685 return (showrev_objectversions(opt_v));
1691 1686 else
1692 1687 return (showrev_sysinfo());
1693 1688 }
1694 1689
1695 1690 #ifdef __sparc
1696 1691 static void
1697 1692 findsym_output(uintptr_t *symlist, uintptr_t value, uintptr_t location)
1698 1693 {
1699 1694 uintptr_t *symbolp;
1700 1695
1701 1696 for (symbolp = symlist; *symbolp; symbolp++)
1702 1697 if (value == *symbolp)
1703 1698 mdb_printf("found %a at %a\n", value, location);
1704 1699 }
1705 1700
1706 1701 /*ARGSUSED*/
1707 1702 static int
1708 1703 findsym_cb(void *data, const GElf_Sym *sym, const char *name,
1709 1704 const mdb_syminfo_t *sip, const char *obj)
1710 1705 {
1711 1706 uint32_t *text;
1712 1707 int len;
1713 1708 int i;
1714 1709 int j;
1715 1710 uint8_t rd;
1716 1711 uintptr_t value;
1717 1712 int32_t imm13;
1718 1713 uint8_t op;
1719 1714 uint8_t op3;
1720 1715 uintptr_t *symlist = data;
1721 1716 size_t size = sym->st_size;
1722 1717
1723 1718 /*
1724 1719 * if the size of the symbol is 0, then this symbol must be for an
1725 1720 * alternate entry point or just some global label. We will,
1726 1721 * therefore, get back to the text that follows this symbol in
1727 1722 * some other symbol
1728 1723 */
1729 1724 if (size == 0)
1730 1725 return (0);
1731 1726
1732 1727 if (sym->st_shndx == SHN_UNDEF)
1733 1728 return (0);
1734 1729
1735 1730 text = alloca(size);
1736 1731
1737 1732 if (mdb_vread(text, size, sym->st_value) == -1) {
1738 1733 mdb_warn("failed to read text for %s", name);
1739 1734 return (0);
1740 1735 }
1741 1736
1742 1737 len = size / 4;
1743 1738 for (i = 0; i < len; i++) {
1744 1739 if (!IS_SETHI(text[i]))
1745 1740 continue;
1746 1741
1747 1742 rd = RD(text[i]);
1748 1743 value = IMM22(text[i]) << 10;
1749 1744
1750 1745 /*
1751 1746 * see if we already have a match with just the sethi
1752 1747 */
1753 1748 findsym_output(symlist, value, sym->st_value + i * 4);
1754 1749
1755 1750 /*
1756 1751 * search from the sethi on until we hit a relevant instr
1757 1752 */
1758 1753 for (j = i + 1; j < len; j++) {
1759 1754 if ((op = OP(text[j])) & OP_ARITH_MEM_MASK) {
1760 1755 op3 = OP3(text[j]);
1761 1756
1762 1757 if (RS1(text[j]) != rd)
1763 1758 goto instr_end;
1764 1759
1765 1760 /*
1766 1761 * This is a simple tool; we only deal
1767 1762 * with operations which take immediates
1768 1763 */
1769 1764 if (I(text[j]) == 0)
1770 1765 goto instr_end;
1771 1766
1772 1767 /*
1773 1768 * sign extend the immediate value
1774 1769 */
1775 1770 imm13 = IMM13(text[j]);
1776 1771 imm13 <<= 19;
1777 1772 imm13 >>= 19;
1778 1773
1779 1774 if (op == OP_ARITH) {
1780 1775 /* arithmetic operations */
1781 1776 if (op3 & OP3_COMPLEX_MASK)
1782 1777 goto instr_end;
1783 1778
1784 1779 switch (op3 & ~OP3_CC_MASK) {
1785 1780 case OP3_OR:
1786 1781 value |= imm13;
1787 1782 break;
1788 1783 case OP3_ADD:
1789 1784 value += imm13;
1790 1785 break;
1791 1786 case OP3_XOR:
1792 1787 value ^= imm13;
1793 1788 break;
1794 1789 default:
1795 1790 goto instr_end;
1796 1791 }
1797 1792 } else {
1798 1793 /* loads and stores */
1799 1794 /* op3 == OP_MEM */
1800 1795
1801 1796 value += imm13;
1802 1797 }
1803 1798
1804 1799 findsym_output(symlist, value,
1805 1800 sym->st_value + j * 4);
1806 1801 instr_end:
1807 1802 /*
1808 1803 * if we're clobbering rd, break
1809 1804 */
1810 1805 if (RD(text[j]) == rd)
1811 1806 break;
1812 1807 } else if (IS_SETHI(text[j])) {
1813 1808 if (RD(text[j]) == rd)
1814 1809 break;
1815 1810 } else if (OP(text[j]) == 1) {
1816 1811 /*
1817 1812 * see if a call clobbers an %o or %g
1818 1813 */
1819 1814 if (rd <= R_O7)
1820 1815 break;
1821 1816 }
1822 1817 }
1823 1818 }
1824 1819
1825 1820 return (0);
1826 1821 }
1827 1822
1828 1823 static int
1829 1824 cmd_findsym(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1830 1825 {
1831 1826 uintptr_t *symlist;
1832 1827 uint_t optg = FALSE;
1833 1828 uint_t type;
1834 1829 int len, i;
1835 1830
1836 1831 i = mdb_getopts(argc, argv, 'g', MDB_OPT_SETBITS, TRUE, &optg, NULL);
1837 1832
1838 1833 argc -= i;
1839 1834 argv += i;
1840 1835
1841 1836 len = argc + ((flags & DCMD_ADDRSPEC) ? 1 : 0) + 1;
1842 1837
1843 1838 if (len <= 1)
1844 1839 return (DCMD_USAGE);
1845 1840
1846 1841 /*
1847 1842 * Set up a NULL-terminated symbol list, and then iterate over the
1848 1843 * symbol table, scanning each function for references to these symbols.
1849 1844 */
1850 1845 symlist = mdb_alloc(len * sizeof (uintptr_t), UM_SLEEP | UM_GC);
1851 1846 len = 0;
1852 1847
1853 1848 for (i = 0; i < argc; i++, argv++) {
1854 1849 const char *str = argv->a_un.a_str;
1855 1850 uintptr_t value;
1856 1851 GElf_Sym sym;
1857 1852
1858 1853 if (argv->a_type == MDB_TYPE_STRING) {
1859 1854 if (strchr("+-", str[0]) != NULL)
1860 1855 return (DCMD_USAGE);
1861 1856 else if (str[0] >= '0' && str[0] <= '9')
1862 1857 value = mdb_strtoull(str);
1863 1858 else if (mdb_lookup_by_name(str, &sym) != 0) {
1864 1859 mdb_warn("symbol '%s' not found", str);
1865 1860 return (DCMD_USAGE);
1866 1861 } else
1867 1862 value = sym.st_value;
1868 1863 } else
1869 1864 value = argv[i].a_un.a_val;
1870 1865
1871 1866 if (value != NULL)
1872 1867 symlist[len++] = value;
1873 1868 }
1874 1869
1875 1870 if (flags & DCMD_ADDRSPEC)
1876 1871 symlist[len++] = addr;
1877 1872
1878 1873 symlist[len] = NULL;
1879 1874
1880 1875 if (optg)
1881 1876 type = MDB_TGT_BIND_GLOBAL | MDB_TGT_TYPE_FUNC;
1882 1877 else
1883 1878 type = MDB_TGT_BIND_ANY | MDB_TGT_TYPE_FUNC;
1884 1879
1885 1880 if (mdb_tgt_symbol_iter(mdb.m_target, MDB_TGT_OBJ_EVERY,
1886 1881 MDB_TGT_SYMTAB, type, findsym_cb, symlist) == -1) {
1887 1882 mdb_warn("failed to iterate over symbol table");
1888 1883 return (DCMD_ERR);
1889 1884 }
1890 1885
1891 1886 return (DCMD_OK);
1892 1887 }
1893 1888 #endif /* __sparc */
1894 1889
1895 1890 static int
1896 1891 dis_str2addr(const char *s, uintptr_t *addr)
1897 1892 {
1898 1893 GElf_Sym sym;
1899 1894
1900 1895 if (s[0] >= '0' && s[0] <= '9') {
1901 1896 *addr = (uintptr_t)mdb_strtoull(s);
1902 1897 return (0);
1903 1898 }
1904 1899
1905 1900 if (mdb_tgt_lookup_by_name(mdb.m_target,
1906 1901 MDB_TGT_OBJ_EVERY, s, &sym, NULL) == -1) {
1907 1902 mdb_warn("symbol '%s' not found\n", s);
1908 1903 return (-1);
1909 1904 }
1910 1905
1911 1906 *addr = (uintptr_t)sym.st_value;
1912 1907 return (0);
1913 1908 }
1914 1909
1915 1910 static int
1916 1911 cmd_dis(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1917 1912 {
1918 1913 mdb_tgt_t *tgt = mdb.m_target;
1919 1914 mdb_disasm_t *dis = mdb.m_disasm;
1920 1915
1921 1916 uintptr_t oaddr, naddr;
1922 1917 mdb_tgt_as_t as;
1923 1918 mdb_tgt_status_t st;
1924 1919 char buf[BUFSIZ];
1925 1920 GElf_Sym sym;
1926 1921 int i;
1927 1922
1928 1923 uint_t opt_f = FALSE; /* File-mode off by default */
1929 1924 uint_t opt_w = FALSE; /* Window mode off by default */
1930 1925 uint_t opt_a = FALSE; /* Raw-address mode off by default */
1931 1926 uint_t opt_b = FALSE; /* Address & symbols off by default */
1932 1927 uintptr_t n = -1UL; /* Length of window in instructions */
1933 1928 uintptr_t eaddr = 0; /* Ending address; 0 if limited by n */
1934 1929
1935 1930 i = mdb_getopts(argc, argv,
1936 1931 'f', MDB_OPT_SETBITS, TRUE, &opt_f,
1937 1932 'w', MDB_OPT_SETBITS, TRUE, &opt_w,
1938 1933 'a', MDB_OPT_SETBITS, TRUE, &opt_a,
1939 1934 'b', MDB_OPT_SETBITS, TRUE, &opt_b,
1940 1935 'n', MDB_OPT_UINTPTR, &n, NULL);
1941 1936
1942 1937 /*
1943 1938 * Disgusting argument post-processing ... basically the idea is to get
1944 1939 * the target address into addr, which we do by using the specified
1945 1940 * expression value, looking up a string as a symbol name, or by
1946 1941 * using the address specified as dot.
1947 1942 */
1948 1943 if (i != argc) {
1949 1944 if (argc != 0 && (argc - i) == 1) {
1950 1945 if (argv[i].a_type == MDB_TYPE_STRING) {
1951 1946 if (argv[i].a_un.a_str[0] == '-')
1952 1947 return (DCMD_USAGE);
1953 1948
1954 1949 if (dis_str2addr(argv[i].a_un.a_str, &addr))
1955 1950 return (DCMD_ERR);
1956 1951 } else
1957 1952 addr = argv[i].a_un.a_val;
1958 1953 } else
1959 1954 return (DCMD_USAGE);
1960 1955 }
1961 1956
1962 1957 /*
1963 1958 * If we're not in window mode yet, and some type of arguments were
1964 1959 * specified, see if the address corresponds nicely to a function.
1965 1960 * If not, turn on window mode; otherwise disassemble the function.
1966 1961 */
1967 1962 if (opt_w == FALSE && (argc != i || (flags & DCMD_ADDRSPEC))) {
1968 1963 if (mdb_tgt_lookup_by_addr(tgt, addr,
1969 1964 MDB_TGT_SYM_EXACT, buf, sizeof (buf), &sym, NULL) == 0 &&
1970 1965 GELF_ST_TYPE(sym.st_info) == STT_FUNC) {
1971 1966 /*
1972 1967 * If the symbol has a size then set our end address to
1973 1968 * be the end of the function symbol we just located.
1974 1969 */
1975 1970 if (sym.st_size != 0)
1976 1971 eaddr = addr + (uintptr_t)sym.st_size;
1977 1972 } else
1978 1973 opt_w = TRUE;
1979 1974 }
1980 1975
1981 1976 /*
1982 1977 * Window-mode doesn't make sense in a loop.
1983 1978 */
1984 1979 if (flags & DCMD_LOOP)
1985 1980 opt_w = FALSE;
1986 1981
1987 1982 /*
1988 1983 * If -n was explicit, limit output to n instructions;
1989 1984 * otherwise set n to some reasonable default
1990 1985 */
1991 1986 if (n != -1UL)
1992 1987 eaddr = 0;
1993 1988 else
1994 1989 n = 10;
1995 1990
1996 1991 /*
1997 1992 * If the state is IDLE (i.e. no address space), turn on -f.
1998 1993 */
1999 1994 if (mdb_tgt_status(tgt, &st) == 0 && st.st_state == MDB_TGT_IDLE)
2000 1995 opt_f = TRUE;
2001 1996
2002 1997 if (opt_f)
2003 1998 as = MDB_TGT_AS_FILE;
2004 1999 else
2005 2000 as = MDB_TGT_AS_VIRT;
2006 2001
2007 2002 if (opt_w == FALSE) {
2008 2003 n++;
2009 2004 while ((eaddr == 0 && n-- != 0) || (addr < eaddr)) {
2010 2005 naddr = mdb_dis_ins2str(dis, tgt, as,
2011 2006 buf, sizeof (buf), addr);
2012 2007 if (naddr == addr)
2013 2008 return (DCMD_ERR);
2014 2009 if (opt_a)
2015 2010 mdb_printf("%-#32p%8T%s\n", addr, buf);
2016 2011 else if (opt_b)
2017 2012 mdb_printf("%-#10p%-#32a%8T%s\n",
2018 2013 addr, addr, buf);
2019 2014 else
2020 2015 mdb_printf("%-#32a%8T%s\n", addr, buf);
2021 2016 addr = naddr;
2022 2017 }
2023 2018
2024 2019 } else {
2025 2020 #ifdef __sparc
2026 2021 if (addr & 0x3) {
2027 2022 mdb_warn("address is not properly aligned\n");
2028 2023 return (DCMD_ERR);
2029 2024 }
2030 2025 #endif
2031 2026
2032 2027 for (oaddr = mdb_dis_previns(dis, tgt, as, addr, n);
2033 2028 oaddr < addr; oaddr = naddr) {
2034 2029 naddr = mdb_dis_ins2str(dis, tgt, as,
2035 2030 buf, sizeof (buf), oaddr);
2036 2031 if (naddr == oaddr)
2037 2032 return (DCMD_ERR);
2038 2033 if (opt_a)
2039 2034 mdb_printf("%-#32p%8T%s\n", oaddr, buf);
2040 2035 else if (opt_b)
2041 2036 mdb_printf("%-#10p%-#32a%8T%s\n",
2042 2037 oaddr, oaddr, buf);
2043 2038 else
2044 2039 mdb_printf("%-#32a%8T%s\n", oaddr, buf);
2045 2040 }
2046 2041
2047 2042 if ((naddr = mdb_dis_ins2str(dis, tgt, as,
2048 2043 buf, sizeof (buf), addr)) == addr)
2049 2044 return (DCMD_ERR);
2050 2045
2051 2046 mdb_printf("%<b>");
2052 2047 mdb_flush();
2053 2048 if (opt_a)
2054 2049 mdb_printf("%-#32p%8T%s%", addr, buf);
2055 2050 else if (opt_b)
2056 2051 mdb_printf("%-#10p%-#32a%8T%s", addr, addr, buf);
2057 2052 else
2058 2053 mdb_printf("%-#32a%8T%s%", addr, buf);
2059 2054 mdb_printf("%</b>\n");
2060 2055
2061 2056 for (addr = naddr; n-- != 0; addr = naddr) {
2062 2057 naddr = mdb_dis_ins2str(dis, tgt, as,
2063 2058 buf, sizeof (buf), addr);
2064 2059 if (naddr == addr)
2065 2060 return (DCMD_ERR);
2066 2061 if (opt_a)
2067 2062 mdb_printf("%-#32p%8T%s\n", addr, buf);
2068 2063 else if (opt_b)
2069 2064 mdb_printf("%-#10p%-#32a%8T%s\n",
2070 2065 addr, addr, buf);
2071 2066 else
2072 2067 mdb_printf("%-#32a%8T%s\n", addr, buf);
2073 2068 }
2074 2069 }
2075 2070
2076 2071 mdb_set_dot(addr);
2077 2072 return (DCMD_OK);
2078 2073 }
2079 2074
2080 2075 /*ARGSUSED*/
2081 2076 static int
2082 2077 walk_step(uintptr_t addr, const void *data, void *private)
2083 2078 {
2084 2079 mdb_printf("%#lr\n", addr);
2085 2080 return (WALK_NEXT);
2086 2081 }
2087 2082
2088 2083 static int
2089 2084 cmd_walk(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2090 2085 {
2091 2086 int status;
2092 2087
2093 2088 if (argc < 1 || argc > 2 || argv[0].a_type != MDB_TYPE_STRING ||
2094 2089 argv[argc - 1].a_type != MDB_TYPE_STRING)
2095 2090 return (DCMD_USAGE);
2096 2091
2097 2092 if (argc > 1) {
2098 2093 const char *name = argv[1].a_un.a_str;
2099 2094 mdb_var_t *v = mdb_nv_lookup(&mdb.m_nv, name);
2100 2095 const char *p;
2101 2096
2102 2097 if (v != NULL && (v->v_flags & MDB_NV_RDONLY) != 0) {
2103 2098 mdb_warn("variable %s is read-only\n", name);
2104 2099 return (DCMD_ABORT);
2105 2100 }
2106 2101
2107 2102 if (v == NULL && (p = strbadid(name)) != NULL) {
2108 2103 mdb_warn("'%c' may not be used in a variable "
2109 2104 "name\n", *p);
2110 2105 return (DCMD_ABORT);
2111 2106 }
2112 2107
2113 2108 if (v == NULL && (v = mdb_nv_insert(&mdb.m_nv,
2114 2109 name, NULL, 0, 0)) == NULL)
2115 2110 return (DCMD_ERR);
2116 2111
2117 2112 /*
2118 2113 * If there already exists a vcb for this variable, we may be
2119 2114 * calling ::walk in a loop. We only create a vcb for this
2120 2115 * variable on the first invocation.
2121 2116 */
2122 2117 if (mdb_vcb_find(v, mdb.m_frame) == NULL)
2123 2118 mdb_vcb_insert(mdb_vcb_create(v), mdb.m_frame);
2124 2119 }
2125 2120
2126 2121 if (flags & DCMD_ADDRSPEC)
2127 2122 status = mdb_pwalk(argv->a_un.a_str, walk_step, NULL, addr);
2128 2123 else
2129 2124 status = mdb_walk(argv->a_un.a_str, walk_step, NULL);
2130 2125
2131 2126 if (status == -1) {
2132 2127 mdb_warn("failed to perform walk");
2133 2128 return (DCMD_ERR);
2134 2129 }
2135 2130
2136 2131 return (DCMD_OK);
2137 2132 }
2138 2133
2139 2134 static int
2140 2135 cmd_walk_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc,
2141 2136 const mdb_arg_t *argv)
2142 2137 {
2143 2138 if (argc > 1)
2144 2139 return (1);
2145 2140
2146 2141 if (argc == 1) {
2147 2142 ASSERT(argv[0].a_type == MDB_TYPE_STRING);
2148 2143 return (mdb_tab_complete_walker(mcp, argv[0].a_un.a_str));
2149 2144 }
2150 2145
2151 2146 if (argc == 0 && flags & DCMD_TAB_SPACE)
2152 2147 return (mdb_tab_complete_walker(mcp, NULL));
2153 2148
2154 2149 return (1);
2155 2150 }
2156 2151
2157 2152 static ssize_t
2158 2153 mdb_partial_xread(void *buf, size_t nbytes, uintptr_t addr, void *arg)
2159 2154 {
2160 2155 ssize_t (*fp)(mdb_tgt_t *, const void *, size_t, uintptr_t) =
2161 2156 (ssize_t (*)(mdb_tgt_t *, const void *, size_t, uintptr_t))arg;
2162 2157
2163 2158 return (fp(mdb.m_target, buf, nbytes, addr));
2164 2159 }
2165 2160
2166 2161 /* ARGSUSED3 */
2167 2162 static ssize_t
2168 2163 mdb_partial_pread(void *buf, size_t nbytes, physaddr_t addr, void *arg)
2169 2164 {
2170 2165 return (mdb_tgt_pread(mdb.m_target, buf, nbytes, addr));
2171 2166 }
2172 2167
2173 2168
2174 2169 static int
2175 2170 cmd_dump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2176 2171 {
2177 2172 uint_t dflags =
2178 2173 MDB_DUMP_ALIGN | MDB_DUMP_NEWDOT | MDB_DUMP_ASCII | MDB_DUMP_HEADER;
2179 2174 uint_t phys = FALSE;
2180 2175 uint_t file = FALSE;
2181 2176 uintptr_t group = 4;
2182 2177 uintptr_t width = 1;
2183 2178 mdb_tgt_status_t st;
2184 2179 int error;
2185 2180
2186 2181 if (mdb_getopts(argc, argv,
2187 2182 'e', MDB_OPT_SETBITS, MDB_DUMP_ENDIAN, &dflags,
2188 2183 'f', MDB_OPT_SETBITS, TRUE, &file,
2189 2184 'g', MDB_OPT_UINTPTR, &group,
2190 2185 'p', MDB_OPT_SETBITS, TRUE, &phys,
2191 2186 'q', MDB_OPT_CLRBITS, MDB_DUMP_ASCII, &dflags,
2192 2187 'r', MDB_OPT_SETBITS, MDB_DUMP_RELATIVE, &dflags,
2193 2188 's', MDB_OPT_SETBITS, MDB_DUMP_SQUISH, &dflags,
2194 2189 't', MDB_OPT_SETBITS, MDB_DUMP_TRIM, &dflags,
2195 2190 'u', MDB_OPT_CLRBITS, MDB_DUMP_ALIGN, &dflags,
2196 2191 'v', MDB_OPT_SETBITS, MDB_DUMP_PEDANT, &dflags,
2197 2192 'w', MDB_OPT_UINTPTR, &width, NULL) != argc)
2198 2193 return (DCMD_USAGE);
2199 2194
2200 2195 if ((phys && file) ||
2201 2196 (width == 0) || (width > 0x10) ||
2202 2197 (group == 0) || (group > 0x100))
2203 2198 return (DCMD_USAGE);
2204 2199
2205 2200 /*
2206 2201 * If neither -f nor -p were specified and the state is IDLE (i.e. no
2207 2202 * address space), turn on -p. This is so we can read large files.
2208 2203 */
2209 2204 if (phys == FALSE && file == FALSE && mdb_tgt_status(mdb.m_target,
2210 2205 &st) == 0 && st.st_state == MDB_TGT_IDLE)
2211 2206 phys = TRUE;
2212 2207
2213 2208 dflags |= MDB_DUMP_GROUP(group) | MDB_DUMP_WIDTH(width);
2214 2209 if (phys)
2215 2210 error = mdb_dump64(mdb_get_dot(), mdb.m_dcount, dflags,
2216 2211 mdb_partial_pread, NULL);
2217 2212 else if (file)
2218 2213 error = mdb_dumpptr(addr, mdb.m_dcount, dflags,
2219 2214 mdb_partial_xread, (void *)mdb_tgt_fread);
2220 2215 else
2221 2216 error = mdb_dumpptr(addr, mdb.m_dcount, dflags,
2222 2217 mdb_partial_xread, (void *)mdb_tgt_vread);
2223 2218
2224 2219 return (((flags & DCMD_LOOP) || (error == -1)) ? DCMD_ABORT : DCMD_OK);
2225 2220 }
2226 2221
2227 2222 /*ARGSUSED*/
2228 2223 static int
2229 2224 cmd_echo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2230 2225 {
2231 2226 if (flags & DCMD_ADDRSPEC)
2232 2227 return (DCMD_USAGE);
2233 2228
2234 2229 for (; argc-- != 0; argv++) {
2235 2230 if (argv->a_type == MDB_TYPE_STRING)
2236 2231 mdb_printf("%s ", argv->a_un.a_str);
2237 2232 else
2238 2233 mdb_printf("%llr ", argv->a_un.a_val);
2239 2234 }
2240 2235
2241 2236 mdb_printf("\n");
2242 2237 return (DCMD_OK);
2243 2238 }
2244 2239
2245 2240 /*ARGSUSED*/
2246 2241 static int
2247 2242 cmd_head(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2248 2243 {
2249 2244 uint64_t cnt = 10;
2250 2245 const char *c;
2251 2246 mdb_pipe_t p;
2252 2247
2253 2248 if (!flags & DCMD_PIPE)
2254 2249 return (DCMD_USAGE);
2255 2250
2256 2251 if (argc == 1 || argc == 2) {
2257 2252 const char *num;
2258 2253
2259 2254 if (argc == 1) {
2260 2255 if (argv[0].a_type != MDB_TYPE_STRING ||
2261 2256 *argv[0].a_un.a_str != '-')
2262 2257 return (DCMD_USAGE);
2263 2258
2264 2259 num = argv[0].a_un.a_str + 1;
2265 2260
2266 2261 } else {
2267 2262 if (argv[0].a_type != MDB_TYPE_STRING ||
2268 2263 strcmp(argv[0].a_un.a_str, "-n") != 0)
2269 2264 return (DCMD_USAGE);
2270 2265
2271 2266 num = argv[1].a_un.a_str;
2272 2267 }
2273 2268
2274 2269 for (cnt = 0, c = num; *c != '\0' && isdigit(*c); c++)
2275 2270 cnt = cnt * 10 + (*c - '0');
2276 2271
2277 2272 if (*c != '\0')
2278 2273 return (DCMD_USAGE);
2279 2274
2280 2275 } else if (argc != 0) {
2281 2276 return (DCMD_USAGE);
2282 2277 }
2283 2278
2284 2279 mdb_get_pipe(&p);
2285 2280
2286 2281 if (p.pipe_data == NULL)
2287 2282 return (DCMD_OK);
2288 2283 p.pipe_len = MIN(p.pipe_len, cnt);
2289 2284
2290 2285 if (flags & DCMD_PIPE_OUT) {
2291 2286 mdb_set_pipe(&p);
2292 2287 } else {
2293 2288 while (p.pipe_len-- > 0)
2294 2289 mdb_printf("%lx\n", *p.pipe_data++);
2295 2290 }
2296 2291
2297 2292 return (DCMD_OK);
2298 2293 }
2299 2294
2300 2295 static void
2301 2296 head_help(void)
2302 2297 {
2303 2298 mdb_printf(
2304 2299 "-n num\n or\n"
2305 2300 "-num pass only the first `num' elements in the pipe.\n"
2306 2301 "\n%<b>Note:%</b> `num' is a decimal number.\n");
2307 2302 }
2308 2303
2309 2304 static int
2310 2305 cmd_typeset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2311 2306 {
2312 2307 int add_tag = 0, del_tag = 0;
2313 2308 const char *p;
2314 2309 mdb_var_t *v;
2315 2310
2316 2311 if (argc == 0)
2317 2312 return (cmd_vars(addr, flags, argc, argv));
2318 2313
2319 2314 if (argv->a_type == MDB_TYPE_STRING && (argv->a_un.a_str[0] == '-' ||
2320 2315 argv->a_un.a_str[0] == '+')) {
2321 2316 if (argv->a_un.a_str[1] != 't')
2322 2317 return (DCMD_USAGE);
2323 2318 if (argv->a_un.a_str[0] == '-')
2324 2319 add_tag++;
2325 2320 else
2326 2321 del_tag++;
2327 2322 argc--;
2328 2323 argv++;
2329 2324 }
2330 2325
2331 2326 if (!(flags & DCMD_ADDRSPEC))
2332 2327 addr = 0; /* set variables to zero unless explicit addr given */
2333 2328
2334 2329 for (; argc-- != 0; argv++) {
2335 2330 if (argv->a_type != MDB_TYPE_STRING)
2336 2331 continue;
2337 2332
2338 2333 if (argv->a_un.a_str[0] == '-' || argv->a_un.a_str[0] == '+') {
2339 2334 mdb_warn("ignored bad option -- %s\n",
2340 2335 argv->a_un.a_str);
2341 2336 continue;
2342 2337 }
2343 2338
2344 2339 if ((p = strbadid(argv->a_un.a_str)) != NULL) {
2345 2340 mdb_warn("'%c' may not be used in a variable "
2346 2341 "name\n", *p);
2347 2342 return (DCMD_ERR);
2348 2343 }
2349 2344
2350 2345 if ((v = mdb_nv_lookup(&mdb.m_nv, argv->a_un.a_str)) == NULL) {
2351 2346 v = mdb_nv_insert(&mdb.m_nv, argv->a_un.a_str,
2352 2347 NULL, addr, 0);
2353 2348 } else if (flags & DCMD_ADDRSPEC)
2354 2349 mdb_nv_set_value(v, addr);
2355 2350
2356 2351 if (v != NULL) {
2357 2352 if (add_tag)
2358 2353 v->v_flags |= MDB_NV_TAGGED;
2359 2354 if (del_tag)
2360 2355 v->v_flags &= ~MDB_NV_TAGGED;
2361 2356 }
2362 2357 }
2363 2358
2364 2359 return (DCMD_OK);
2365 2360 }
2366 2361
2367 2362 #ifndef _KMDB
2368 2363 /*ARGSUSED*/
2369 2364 static int
2370 2365 cmd_context(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2371 2366 {
2372 2367 if (argc != 0 || !(flags & DCMD_ADDRSPEC))
2373 2368 return (DCMD_USAGE);
2374 2369
2375 2370 if (mdb_tgt_setcontext(mdb.m_target, (void *)addr) == 0)
2376 2371 return (DCMD_OK);
2377 2372
2378 2373 return (DCMD_ERR);
2379 2374 }
2380 2375 #endif
2381 2376
2382 2377 /*ARGSUSED*/
2383 2378 static int
2384 2379 cmd_prompt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2385 2380 {
2386 2381 const char *p = "";
2387 2382
2388 2383 if (argc != 0) {
2389 2384 if (argc > 1 || argv->a_type != MDB_TYPE_STRING)
2390 2385 return (DCMD_USAGE);
2391 2386 p = argv->a_un.a_str;
2392 2387 }
2393 2388
2394 2389 (void) mdb_set_prompt(p);
2395 2390 return (DCMD_OK);
2396 2391 }
2397 2392
2398 2393 /*ARGSUSED*/
2399 2394 static int
2400 2395 cmd_term(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2401 2396 {
2402 2397 mdb_printf("%s\n", mdb.m_termtype);
2403 2398
2404 2399 return (DCMD_OK);
2405 2400 }
2406 2401
2407 2402 /*ARGSUSED*/
2408 2403 static int
2409 2404 cmd_vtop(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2410 2405 {
2411 2406 physaddr_t pa;
2412 2407 mdb_tgt_as_t as = MDB_TGT_AS_VIRT;
2413 2408
2414 2409 if (mdb_getopts(argc, argv, 'a', MDB_OPT_UINTPTR, (uintptr_t *)&as,
2415 2410 NULL) != argc)
2416 2411 return (DCMD_USAGE);
2417 2412
2418 2413 if (mdb_tgt_vtop(mdb.m_target, as, addr, &pa) == -1) {
2419 2414 mdb_warn("failed to get physical mapping");
2420 2415 return (DCMD_ERR);
2421 2416 }
2422 2417
2423 2418 if (flags & DCMD_PIPE_OUT)
2424 2419 mdb_printf("%llr\n", pa);
2425 2420 else
2426 2421 mdb_printf("virtual %lr mapped to physical %llr\n", addr, pa);
2427 2422 return (DCMD_OK);
2428 2423 }
2429 2424
2430 2425 #define EVENTS_OPT_A 0x1 /* ::events -a (show all events) */
2431 2426 #define EVENTS_OPT_V 0x2 /* ::events -v (verbose display) */
2432 2427
2433 2428 static const char *
2434 2429 event_action(const mdb_tgt_spec_desc_t *sp)
2435 2430 {
2436 2431 if (!(sp->spec_flags & MDB_TGT_SPEC_HIDDEN) && sp->spec_data != NULL)
2437 2432 return (sp->spec_data);
2438 2433
2439 2434 return ("-");
2440 2435 }
2441 2436
2442 2437 static void
2443 2438 print_evsep(void)
2444 2439 {
2445 2440 static const char dash20[] = "--------------------";
2446 2441 mdb_printf("----- - -- -- -- %s%s --%s\n", dash20, dash20, dash20);
2447 2442 }
2448 2443
2449 2444 /*ARGSUSED*/
2450 2445 static int
2451 2446 print_event(mdb_tgt_t *t, void *private, int vid, void *data)
2452 2447 {
2453 2448 uint_t opts = (uint_t)(uintptr_t)private;
2454 2449 mdb_tgt_spec_desc_t sp;
2455 2450 char s1[41], s2[22];
2456 2451 const char *s2str;
2457 2452 int visible;
2458 2453
2459 2454 (void) mdb_tgt_vespec_info(t, vid, &sp, s1, sizeof (s1));
2460 2455 visible = !(sp.spec_flags & (MDB_TGT_SPEC_HIDDEN|MDB_TGT_SPEC_DELETED));
2461 2456
2462 2457 if ((opts & EVENTS_OPT_A) || visible) {
2463 2458 int encoding = (!(sp.spec_flags & MDB_TGT_SPEC_DISABLED)) |
2464 2459 (!(sp.spec_flags & MDB_TGT_SPEC_MATCHED) << 1);
2465 2460
2466 2461 char ldelim = "<<(["[encoding];
2467 2462 char rdelim = ">>)]"[encoding];
2468 2463
2469 2464 char state = "0-+*!"[sp.spec_state];
2470 2465
2471 2466 char tflag = "T "[!(sp.spec_flags & MDB_TGT_SPEC_STICKY)];
2472 2467 char aflag = "d "[!(sp.spec_flags & MDB_TGT_SPEC_AUTODIS)];
2473 2468
2474 2469 if (sp.spec_flags & MDB_TGT_SPEC_TEMPORARY)
2475 2470 tflag = 't'; /* TEMP takes precedence over STICKY */
2476 2471 if (sp.spec_flags & MDB_TGT_SPEC_AUTODEL)
2477 2472 aflag = 'D'; /* AUTODEL takes precedence over AUTODIS */
2478 2473 if (sp.spec_flags & MDB_TGT_SPEC_AUTOSTOP)
2479 2474 aflag = 's'; /* AUTOSTOP takes precedence over both */
2480 2475
2481 2476 if (opts & EVENTS_OPT_V) {
2482 2477 if (sp.spec_state == MDB_TGT_SPEC_IDLE ||
2483 2478 sp.spec_state == MDB_TGT_SPEC_ERROR)
2484 2479 s2str = mdb_strerror(sp.spec_errno);
2485 2480 else
2486 2481 s2str = "-";
2487 2482 } else
2488 2483 s2str = event_action(&sp);
2489 2484
2490 2485 if (mdb_snprintf(s2, sizeof (s2), "%s", s2str) >= sizeof (s2))
2491 2486 (void) strabbr(s2, sizeof (s2));
2492 2487
2493 2488 if (vid > -10 && vid < 10)
2494 2489 mdb_printf("%c%2d %c", ldelim, vid, rdelim);
2495 2490 else
2496 2491 mdb_printf("%c%3d%c", ldelim, vid, rdelim);
2497 2492
2498 2493 mdb_printf(" %c %c%c %2u %2u %-40s %-21s\n",
2499 2494 state, tflag, aflag, sp.spec_hits, sp.spec_limit, s1, s2);
2500 2495
2501 2496 if (opts & EVENTS_OPT_V) {
2502 2497 mdb_printf("%-17s%s\n", "", event_action(&sp));
2503 2498 print_evsep();
2504 2499 }
2505 2500 }
2506 2501
2507 2502 return (0);
2508 2503 }
2509 2504
2510 2505 /*ARGSUSED*/
2511 2506 static int
2512 2507 cmd_events(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2513 2508 {
2514 2509 uint_t opts = 0;
2515 2510
2516 2511 if ((flags & DCMD_ADDRSPEC) || mdb_getopts(argc, argv,
2517 2512 'a', MDB_OPT_SETBITS, EVENTS_OPT_A, &opts,
2518 2513 'v', MDB_OPT_SETBITS, EVENTS_OPT_V, &opts, NULL) != argc)
2519 2514 return (DCMD_USAGE);
2520 2515
2521 2516
2522 2517 if (opts & EVENTS_OPT_V) {
2523 2518 mdb_printf(" ID S TA HT LM %-40s %-21s\n%-17s%s\n",
2524 2519 "Description", "Status", "", "Action");
2525 2520 } else {
2526 2521 mdb_printf(" ID S TA HT LM %-40s %-21s\n",
2527 2522 "Description", "Action");
2528 2523 }
2529 2524
2530 2525 print_evsep();
2531 2526 return (mdb_tgt_vespec_iter(mdb.m_target, print_event,
2532 2527 (void *)(uintptr_t)opts));
2533 2528 }
2534 2529
2535 2530 static int
2536 2531 tgt_status(const mdb_tgt_status_t *tsp)
2537 2532 {
2538 2533 const char *format;
2539 2534 char buf[BUFSIZ];
2540 2535
2541 2536 if (tsp->st_flags & MDB_TGT_BUSY)
2542 2537 return (DCMD_OK);
2543 2538
2544 2539 if (tsp->st_pc != 0) {
2545 2540 if (mdb_dis_ins2str(mdb.m_disasm, mdb.m_target, MDB_TGT_AS_VIRT,
2546 2541 buf, sizeof (buf), tsp->st_pc) != tsp->st_pc)
2547 2542 format = "target stopped at:\n%-#16a%8T%s\n";
2548 2543 else
2549 2544 format = "target stopped at %a:\n";
2550 2545 mdb_warn(format, tsp->st_pc, buf);
2551 2546 }
2552 2547
2553 2548 switch (tsp->st_state) {
2554 2549 case MDB_TGT_IDLE:
2555 2550 mdb_warn("target is idle\n");
2556 2551 break;
2557 2552 case MDB_TGT_RUNNING:
2558 2553 if (tsp->st_flags & MDB_TGT_DSTOP)
2559 2554 mdb_warn("target is running, stop directive pending\n");
2560 2555 else
2561 2556 mdb_warn("target is running\n");
2562 2557 break;
2563 2558 case MDB_TGT_STOPPED:
2564 2559 if (tsp->st_pc == 0)
2565 2560 mdb_warn("target is stopped\n");
2566 2561 break;
2567 2562 case MDB_TGT_UNDEAD:
2568 2563 mdb_warn("target has terminated\n");
2569 2564 break;
2570 2565 case MDB_TGT_DEAD:
2571 2566 mdb_warn("target is a core dump\n");
2572 2567 break;
2573 2568 case MDB_TGT_LOST:
2574 2569 mdb_warn("target is no longer under debugger control\n");
2575 2570 break;
2576 2571 }
2577 2572
2578 2573 mdb_set_dot(tsp->st_pc);
2579 2574 return (DCMD_OK);
2580 2575 }
2581 2576
2582 2577 /*
2583 2578 * mdb continue/step commands take an optional signal argument, but the
2584 2579 * corresponding kmdb versions don't.
2585 2580 */
2586 2581 #ifdef _KMDB
2587 2582 #define CONT_MAXARGS 0 /* no optional SIG argument */
2588 2583 #else
2589 2584 #define CONT_MAXARGS 1
2590 2585 #endif
2591 2586
2592 2587 /*ARGSUSED*/
2593 2588 static int
2594 2589 cmd_cont_common(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
2595 2590 int (*t_cont)(mdb_tgt_t *, mdb_tgt_status_t *), const char *name)
2596 2591 {
2597 2592 mdb_tgt_t *t = mdb.m_target;
2598 2593 mdb_tgt_status_t st;
2599 2594 int sig = 0;
2600 2595
2601 2596 if ((flags & DCMD_ADDRSPEC) || argc > CONT_MAXARGS)
2602 2597 return (DCMD_USAGE);
2603 2598
2604 2599 if (argc > 0) {
2605 2600 if (argv->a_type == MDB_TYPE_STRING) {
2606 2601 if (proc_str2sig(argv->a_un.a_str, &sig) == -1) {
2607 2602 mdb_warn("invalid signal name -- %s\n",
2608 2603 argv->a_un.a_str);
2609 2604 return (DCMD_USAGE);
2610 2605 }
2611 2606 } else
2612 2607 sig = (int)(intmax_t)argv->a_un.a_val;
2613 2608 }
2614 2609
2615 2610 (void) mdb_tgt_status(t, &st);
2616 2611
2617 2612 if (st.st_state == MDB_TGT_IDLE && mdb_tgt_run(t, 0, NULL) == -1) {
2618 2613 if (errno != EMDB_TGT)
2619 2614 mdb_warn("failed to create new target");
2620 2615 return (DCMD_ERR);
2621 2616 }
2622 2617
2623 2618 if (sig != 0 && mdb_tgt_signal(t, sig) == -1) {
2624 2619 mdb_warn("failed to post signal %d", sig);
2625 2620 return (DCMD_ERR);
2626 2621 }
2627 2622
2628 2623 if (st.st_state == MDB_TGT_IDLE && t_cont == &mdb_tgt_step) {
2629 2624 (void) mdb_tgt_status(t, &st);
2630 2625 return (tgt_status(&st));
2631 2626 }
2632 2627
2633 2628 if (t_cont(t, &st) == -1) {
2634 2629 if (errno != EMDB_TGT)
2635 2630 mdb_warn("failed to %s target", name);
2636 2631 return (DCMD_ERR);
2637 2632 }
2638 2633
2639 2634 return (tgt_status(&st));
2640 2635 }
2641 2636
2642 2637 static int
2643 2638 cmd_step(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2644 2639 {
2645 2640 int (*func)(mdb_tgt_t *, mdb_tgt_status_t *) = &mdb_tgt_step;
2646 2641 const char *name = "single-step";
2647 2642
2648 2643 if (argc > 0 && argv->a_type == MDB_TYPE_STRING) {
2649 2644 if (strcmp(argv->a_un.a_str, "out") == 0) {
2650 2645 func = &mdb_tgt_step_out;
2651 2646 name = "step (out)";
2652 2647 argv++;
2653 2648 argc--;
2654 2649 } else if (strcmp(argv->a_un.a_str, "branch") == 0) {
2655 2650 func = &mdb_tgt_step_branch;
2656 2651 name = "step (branch)";
2657 2652 argv++;
2658 2653 argc--;
2659 2654 } else if (strcmp(argv->a_un.a_str, "over") == 0) {
2660 2655 func = &mdb_tgt_next;
2661 2656 name = "step (over)";
2662 2657 argv++;
2663 2658 argc--;
2664 2659 }
2665 2660 }
2666 2661
2667 2662 return (cmd_cont_common(addr, flags, argc, argv, func, name));
2668 2663 }
2669 2664
2670 2665 static int
2671 2666 cmd_step_out(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2672 2667 {
2673 2668 return (cmd_cont_common(addr, flags, argc, argv,
2674 2669 &mdb_tgt_step_out, "step (out)"));
2675 2670 }
2676 2671
2677 2672 static int
2678 2673 cmd_next(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2679 2674 {
2680 2675 return (cmd_cont_common(addr, flags, argc, argv,
2681 2676 &mdb_tgt_next, "step (over)"));
2682 2677 }
2683 2678
2684 2679 static int
2685 2680 cmd_cont(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2686 2681 {
2687 2682 return (cmd_cont_common(addr, flags, argc, argv,
2688 2683 &mdb_tgt_continue, "continue"));
2689 2684 }
2690 2685
2691 2686 #ifndef _KMDB
2692 2687 /*ARGSUSED*/
2693 2688 static int
2694 2689 cmd_run(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2695 2690 {
2696 2691 if (flags & DCMD_ADDRSPEC)
2697 2692 return (DCMD_USAGE);
2698 2693
2699 2694 if (mdb_tgt_run(mdb.m_target, argc, argv) == -1) {
2700 2695 if (errno != EMDB_TGT)
2701 2696 mdb_warn("failed to create new target");
2702 2697 return (DCMD_ERR);
2703 2698 }
2704 2699 return (cmd_cont(NULL, 0, 0, NULL));
2705 2700 }
2706 2701 #endif
2707 2702
2708 2703 /*
2709 2704 * To simplify the implementation of :d, :z, and ::delete, we use the sp
2710 2705 * parameter to store the criteria for what to delete. If spec_base is set,
2711 2706 * we delete vespecs with a matching address. If spec_id is set, we delete
2712 2707 * vespecs with a matching id. Otherwise, we delete all vespecs. We bump
2713 2708 * sp->spec_size so the caller can tell how many vespecs were deleted.
2714 2709 */
2715 2710 static int
2716 2711 ve_delete(mdb_tgt_t *t, mdb_tgt_spec_desc_t *sp, int vid, void *data)
2717 2712 {
2718 2713 mdb_tgt_spec_desc_t spec;
2719 2714 int status = -1;
2720 2715
2721 2716 if (vid < 0)
2722 2717 return (0); /* skip over target implementation events */
2723 2718
2724 2719 if (sp->spec_base != NULL) {
2725 2720 (void) mdb_tgt_vespec_info(t, vid, &spec, NULL, 0);
2726 2721 if (sp->spec_base - spec.spec_base < spec.spec_size)
2727 2722 status = mdb_tgt_vespec_delete(t, vid);
2728 2723 } else if (sp->spec_id == 0) {
2729 2724 (void) mdb_tgt_vespec_info(t, vid, &spec, NULL, 0);
2730 2725 if (!(spec.spec_flags & MDB_TGT_SPEC_STICKY))
2731 2726 status = mdb_tgt_vespec_delete(t, vid);
2732 2727 } else if (sp->spec_id == vid)
2733 2728 status = mdb_tgt_vespec_delete(t, vid);
2734 2729
2735 2730 if (status == 0) {
2736 2731 if (data != NULL)
2737 2732 strfree(data);
2738 2733 sp->spec_size++;
2739 2734 }
2740 2735
2741 2736 return (0);
2742 2737 }
2743 2738
2744 2739 static int
2745 2740 ve_delete_spec(mdb_tgt_spec_desc_t *sp)
2746 2741 {
2747 2742 (void) mdb_tgt_vespec_iter(mdb.m_target,
2748 2743 (mdb_tgt_vespec_f *)ve_delete, sp);
2749 2744
2750 2745 if (sp->spec_size == 0) {
2751 2746 if (sp->spec_id != 0 || sp->spec_base != NULL)
2752 2747 mdb_warn("no traced events matched description\n");
2753 2748 }
2754 2749
2755 2750 return (DCMD_OK);
2756 2751 }
2757 2752
2758 2753 /*ARGSUSED*/
2759 2754 static int
2760 2755 cmd_zapall(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2761 2756 {
2762 2757 mdb_tgt_spec_desc_t spec;
2763 2758
2764 2759 if ((flags & DCMD_ADDRSPEC) || argc != 0)
2765 2760 return (DCMD_USAGE);
2766 2761
2767 2762 bzero(&spec, sizeof (spec));
2768 2763 return (ve_delete_spec(&spec));
2769 2764 }
2770 2765
2771 2766 static int
2772 2767 cmd_delete(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2773 2768 {
2774 2769 mdb_tgt_spec_desc_t spec;
2775 2770
2776 2771 if (((flags & DCMD_ADDRSPEC) && argc > 0) || argc > 1)
2777 2772 return (DCMD_USAGE);
2778 2773
2779 2774 bzero(&spec, sizeof (spec));
2780 2775
2781 2776 if (flags & DCMD_ADDRSPEC)
2782 2777 spec.spec_base = addr;
2783 2778 else if (argc == 0)
2784 2779 spec.spec_base = mdb_get_dot();
2785 2780 else if (argv->a_type == MDB_TYPE_STRING &&
2786 2781 strcmp(argv->a_un.a_str, "all") != 0)
2787 2782 spec.spec_id = (int)(intmax_t)strtonum(argv->a_un.a_str, 10);
2788 2783 else if (argv->a_type == MDB_TYPE_IMMEDIATE)
2789 2784 spec.spec_id = (int)(intmax_t)argv->a_un.a_val;
2790 2785
2791 2786 return (ve_delete_spec(&spec));
2792 2787 }
2793 2788
2794 2789 static void
2795 2790 srcexec_file_help(void)
2796 2791 {
2797 2792 mdb_printf(
2798 2793 "The library of macros delivered with previous versions of Solaris have been\n"
2799 2794 "superseded by the dcmds and walkers provided by MDB. See ::help for\n"
2800 2795 "commands that can be used to list the available dcmds and walkers.\n"
2801 2796 "\n"
2802 2797 "Aliases have been created for several of the more popular macros. To see\n"
2803 2798 "the list of aliased macros, as well as their native MDB equivalents,\n"
2804 2799 "type $M.\n");
2805 2800
2806 2801 #ifdef _KMDB
2807 2802 mdb_printf(
2808 2803 "When invoked, the $< and $<< dcmds will consult the macro alias list. If an\n"
2809 2804 "alias cannot be found, an attempt will be made to locate a data type whose\n"
2810 2805 "name corresponds to the requested macro. If such a type can be found, it\n"
2811 2806 "will be displayed using the ::print dcmd.\n");
2812 2807 #else
2813 2808 mdb_printf(
2814 2809 "When invoked, the $< and $<< dcmds will first attempt to locate a macro with\n"
2815 2810 "the indicated name. If no macro can be found, and if no alias exists for\n"
2816 2811 "this macro, an attempt will be made to locate a data type whose name\n"
2817 2812 "corresponds to the requested macro. If such a type can be found, it will be\n"
2818 2813 "displayed using the ::print dcmd.\n");
2819 2814 #endif
2820 2815 }
2821 2816
2822 2817 static void
2823 2818 events_help(void)
2824 2819 {
2825 2820 mdb_printf("Options:\n"
2826 2821 "-a show all events, including internal debugger events\n"
2827 2822 "-v show verbose display, including inactivity reason\n"
2828 2823 "\nOutput Columns:\n"
2829 2824 "ID decimal event specifier id number:\n"
2830 2825 " [ ] event tracing is enabled\n"
2831 2826 " ( ) event tracing is disabled\n"
2832 2827 " < > target is currently stopped on this type of event\n\n"
2833 2828 "S event specifier state:\n"
2834 2829 " - event specifier is idle (not applicable yet)\n"
2835 2830 " + event specifier is active\n"
2836 2831 " * event specifier is armed (target program running)\n"
2837 2832 " ! error occurred while attempting to arm event\n\n"
2838 2833 "TA event specifier flags:\n"
2839 2834 " t event specifier is temporary (delete at next stop)\n"
2840 2835 " T event specifier is sticky (::delete all has no effect)\n"
2841 2836 " d event specifier will be disabled when HT = LM\n"
2842 2837 " D event specifier will be deleted when HT = LM\n"
2843 2838 " s target will automatically stop when HT = LM\n\n"
2844 2839 "HT hit count (number of times event has occurred)\n"
2845 2840 "LM hit limit (limit for autostop, disable, delete)\n");
2846 2841 }
2847 2842
2848 2843 static void
2849 2844 dump_help(void)
2850 2845 {
2851 2846 mdb_printf(
2852 2847 "-e adjust for endianness\n"
2853 2848 " (assumes 4-byte words; use -g to change word size)\n"
2854 2849 #ifdef _KMDB
2855 2850 "-f no effect\n"
2856 2851 #else
2857 2852 "-f dump from object file\n"
2858 2853 #endif
2859 2854 "-g n display bytes in groups of n\n"
2860 2855 " (default is 4; n must be a power of 2, divide line width)\n"
2861 2856 "-p dump from physical memory\n"
2862 2857 "-q don't print ASCII\n"
2863 2858 "-r use relative numbering (automatically sets -u)\n"
2864 2859 "-s elide repeated lines\n"
2865 2860 "-t only read from and display contents of specified addresses\n"
2866 2861 " (default is to read and print entire lines)\n"
2867 2862 "-u un-align output\n"
2868 2863 " (default is to align output at paragraph boundary)\n"
2869 2864 "-w n display n 16-byte paragraphs per line\n"
2870 2865 " (default is 1, maximum is 16)\n");
2871 2866 }
2872 2867
2873 2868 /*
2874 2869 * Table of built-in dcmds associated with the root 'mdb' module. Future
2875 2870 * expansion of this program should be done here, or through the external
2876 2871 * loadable module interface.
2877 2872 */
2878 2873 const mdb_dcmd_t mdb_dcmd_builtins[] = {
2879 2874
2880 2875 /*
2881 2876 * dcmds common to both mdb and kmdb
2882 2877 */
2883 2878 { ">", "variable-name", "assign variable", cmd_assign_variable },
2884 2879 { "/", "fmt-list", "format data from virtual as", cmd_print_core },
2885 2880 { "\\", "fmt-list", "format data from physical as", cmd_print_phys },
2886 2881 { "@", "fmt-list", "format data from physical as", cmd_print_phys },
2887 2882 { "=", "fmt-list", "format immediate value", cmd_print_value },
2888 2883 { "$<", "macro-name", "replace input with macro",
2889 2884 cmd_exec_file, srcexec_file_help },
2890 2885 { "$<<", "macro-name", "source macro",
2891 2886 cmd_src_file, srcexec_file_help},
2892 2887 { "$%", NULL, NULL, cmd_quit },
2893 2888 { "$?", NULL, "print status and registers", cmd_notsup },
2894 2889 { "$a", NULL, NULL, cmd_algol },
2895 2890 { "$b", "[-av]", "list traced software events",
2896 2891 cmd_events, events_help },
2897 2892 { "$c", "?[cnt]", "print stack backtrace", cmd_notsup },
2898 2893 { "$C", "?[cnt]", "print stack backtrace", cmd_notsup },
2899 2894 { "$d", NULL, "get/set default output radix", cmd_radix },
2900 2895 { "$D", "?[mode,...]", NULL, cmd_dbmode },
2901 2896 { "$e", NULL, "print listing of global symbols", cmd_globals },
2902 2897 { "$f", NULL, "print listing of source files", cmd_files },
2903 2898 { "$m", "?[name]", "print address space mappings", cmd_mappings },
2904 2899 { "$M", NULL, "list macro aliases", cmd_macalias_list },
2905 2900 { "$P", "[prompt]", "set debugger prompt string", cmd_prompt },
2906 2901 { "$q", NULL, "quit debugger", cmd_quit },
2907 2902 { "$Q", NULL, "quit debugger", cmd_quit },
2908 2903 { "$r", NULL, "print general-purpose registers", cmd_notsup },
2909 2904 { "$s", NULL, "get/set symbol matching distance", cmd_symdist },
2910 2905 { "$v", NULL, "print non-zero variables", cmd_nzvars },
2911 2906 { "$V", "[mode]", "get/set disassembly mode", cmd_dismode },
2912 2907 { "$w", NULL, "get/set output page width", cmd_pgwidth },
2913 2908 { "$W", NULL, "re-open target in write mode", cmd_reopen },
2914 2909 { ":a", ":[cmd...]", "set read access watchpoint", cmd_oldwpr },
2915 2910 { ":b", ":[cmd...]", "breakpoint at the specified address", cmd_oldbp },
2916 2911 { ":d", "?[id|all]", "delete traced software events", cmd_delete },
2917 2912 { ":p", ":[cmd...]", "set execute access watchpoint", cmd_oldwpx },
2918 2913 { ":S", NULL, NULL, cmd_step },
2919 2914 { ":w", ":[cmd...]", "set write access watchpoint", cmd_oldwpw },
2920 2915 { ":z", NULL, "delete all traced software events", cmd_zapall },
2921 2916 { "array", ":[type count] [variable]", "print each array element's "
2922 2917 "address", cmd_array },
2923 2918 { "bp", "?[+/-dDestT] [-c cmd] [-n count] sym ...", "breakpoint at the "
2924 2919 "specified addresses or symbols", cmd_bp, bp_help },
2925 2920 { "dcmds", NULL, "list available debugger commands", cmd_dcmds },
2926 2921 { "delete", "?[id|all]", "delete traced software events", cmd_delete },
2927 2922 { "dis", "?[-abfw] [-n cnt] [addr]", "disassemble near addr", cmd_dis },
2928 2923 { "disasms", NULL, "list available disassemblers", cmd_disasms },
2929 2924 { "dismode", "[mode]", "get/set disassembly mode", cmd_dismode },
2930 2925 { "dmods", "[-l] [mod]", "list loaded debugger modules", cmd_dmods },
2931 2926 { "dump", "?[-eqrstu] [-f|-p] [-g bytes] [-w paragraphs]",
2932 2927 "dump memory from specified address", cmd_dump, dump_help },
2933 2928 { "echo", "args ...", "echo arguments", cmd_echo },
2934 2929 { "enum", "?[-ex] enum [name]", "print an enumeration", cmd_enum,
2935 2930 enum_help },
2936 2931 { "eval", "command", "evaluate the specified command", cmd_eval },
2937 2932 { "events", "[-av]", "list traced software events",
2938 2933 cmd_events, events_help },
2939 2934 { "evset", "?[+/-dDestT] [-c cmd] [-n count] id ...",
2940 2935 "set software event specifier attributes", cmd_evset, evset_help },
2941 2936 { "files", "[object]", "print listing of source files", cmd_files },
2942 2937 #ifdef __sparc
2943 2938 { "findsym", "?[-g] [symbol|addr ...]", "search for symbol references "
2944 2939 "in all known functions", cmd_findsym, NULL },
2945 2940 #endif
2946 2941 { "formats", NULL, "list format specifiers", cmd_formats },
2947 2942 { "grep", "?expr", "print dot if expression is true", cmd_grep },
2948 2943 { "head", "-num|-n num", "limit number of elements in pipe", cmd_head,
2949 2944 head_help },
2950 2945 { "help", "[cmd]", "list commands/command help", cmd_help },
2951 2946 { "list", "?type member [variable]",
2952 2947 "walk list using member as link pointer", cmd_list, NULL,
2953 2948 mdb_tab_complete_mt },
2954 2949 { "map", "?expr", "print dot after evaluating expression", cmd_map },
2955 2950 { "mappings", "?[name]", "print address space mappings", cmd_mappings },
2956 2951 { "nm", "?[-DPdghnopuvx] [-f format] [-t types] [object]",
2957 2952 "print symbols", cmd_nm, nm_help },
2958 2953 { "nmadd", ":[-fo] [-e end] [-s size] name",
2959 2954 "add name to private symbol table", cmd_nmadd, nmadd_help },
2960 2955 { "nmdel", "name", "remove name from private symbol table", cmd_nmdel },
2961 2956 { "obey", NULL, NULL, cmd_obey },
2962 2957 { "objects", "[-v]", "print load objects information", cmd_objects },
2963 2958 { "offsetof", "type member", "print the offset of a given struct "
2964 2959 "or union member", cmd_offsetof, NULL, mdb_tab_complete_mt },
2965 2960 { "print", "?[-aCdhiLptx] [-c lim] [-l lim] [type] [member|offset ...]",
2966 2961 "print the contents of a data structure", cmd_print, print_help,
2967 2962 cmd_print_tab },
2968 2963 { "printf", "?format type member ...", "print and format the "
2969 2964 "member(s) of a data structure", cmd_printf, printf_help },
2970 2965 { "regs", NULL, "print general purpose registers", cmd_notsup },
2971 2966 { "set", "[-wF] [+/-o opt] [-s dist] [-I path] [-L path] [-P prompt]",
2972 2967 "get/set debugger properties", cmd_set },
2973 2968 { "showrev", "[-pv]", "print version information", cmd_showrev },
2974 2969 { "sizeof", "type", "print the size of a type", cmd_sizeof, NULL,
2975 2970 cmd_sizeof_tab },
2976 2971 { "stack", "?[cnt]", "print stack backtrace", cmd_notsup },
2977 2972 { "stackregs", "?", "print stack backtrace and registers",
2978 2973 cmd_notsup },
2979 2974 { "status", NULL, "print summary of current target", cmd_notsup },
2980 2975 { "term", NULL, "display current terminal type", cmd_term },
2981 2976 { "typeset", "[+/-t] var ...", "set variable attributes", cmd_typeset },
2982 2977 { "typedef", "[-c model | -d | -l | -r file ] [type] [name]",
2983 2978 "create synthetic types", cmd_typedef, cmd_typedef_help },
2984 2979 { "unset", "[name ...]", "unset variables", cmd_unset },
2985 2980 { "vars", "[-npt]", "print listing of variables", cmd_vars },
2986 2981 { "version", NULL, "print debugger version string", cmd_version },
2987 2982 { "vtop", ":[-a as]", "print physical mapping of virtual address",
2988 2983 cmd_vtop },
2989 2984 { "walk", "?name [variable]", "walk data structure", cmd_walk, NULL,
2990 2985 cmd_walk_tab },
2991 2986 { "walkers", NULL, "list available walkers", cmd_walkers },
2992 2987 { "whatis", ":[-aikqv]", "given an address, return information",
2993 2988 cmd_whatis, whatis_help },
2994 2989 { "whence", "[-v] name ...", "show source of walk or dcmd", cmd_which },
2995 2990 { "which", "[-v] name ...", "show source of walk or dcmd", cmd_which },
2996 2991 { "xdata", NULL, "print list of external data buffers", cmd_xdata },
2997 2992
2998 2993 #ifdef _KMDB
2999 2994 /*
3000 2995 * dcmds specific to kmdb, or which have kmdb-specific arguments
3001 2996 */
3002 2997 { "?", "fmt-list", "format data from virtual as", cmd_print_core },
3003 2998 { ":c", NULL, "continue target execution", cmd_cont },
3004 2999 { ":e", NULL, "step target over next instruction", cmd_next },
3005 3000 { ":s", NULL, "single-step target to next instruction", cmd_step },
3006 3001 { ":u", NULL, "step target out of current function", cmd_step_out },
3007 3002 { "cont", NULL, "continue target execution", cmd_cont },
3008 3003 { "load", "[-sd] module", "load debugger module", cmd_load, load_help },
3009 3004 { "next", NULL, "step target over next instruction", cmd_next },
3010 3005 { "quit", "[-u]", "quit debugger", cmd_quit, quit_help },
3011 3006 { "step", "[ over | out ]",
3012 3007 "single-step target to next instruction", cmd_step },
3013 3008 { "unload", "[-d] module", "unload debugger module", cmd_unload,
3014 3009 unload_help },
3015 3010 { "wp", ":[+/-dDelstT] [-rwx] [-pi] [-c cmd] [-n count] [-L size]",
3016 3011 "set a watchpoint at the specified address", cmd_wp, wp_help },
3017 3012
3018 3013 #else
3019 3014 /*
3020 3015 * dcmds specific to mdb, or which have mdb-specific arguments
3021 3016 */
3022 3017 { "?", "fmt-list", "format data from object file", cmd_print_object },
3023 3018 { "$>", "[file]", "log session to a file", cmd_old_log },
3024 3019 { "$g", "?", "get/set C++ demangling options", cmd_demflags },
3025 3020 { "$G", NULL, "enable/disable C++ demangling support", cmd_demangle },
3026 3021 { "$i", NULL, "print signals that are ignored", cmd_notsup },
3027 3022 { "$l", NULL, "print the representative thread's lwp id", cmd_notsup },
3028 3023 { "$p", ":", "change debugger target context", cmd_context },
3029 3024 { "$x", NULL, "print floating point registers", cmd_notsup },
3030 3025 { "$X", NULL, "print floating point registers", cmd_notsup },
3031 3026 { "$y", NULL, "print floating point registers", cmd_notsup },
3032 3027 { "$Y", NULL, "print floating point registers", cmd_notsup },
3033 3028 { ":A", "?[core|pid]", "attach to process or core file", cmd_notsup },
3034 3029 { ":c", "[SIG]", "continue target execution", cmd_cont },
3035 3030 { ":e", "[SIG]", "step target over next instruction", cmd_next },
3036 3031 { ":i", ":", "ignore signal (delete all matching events)", cmd_notsup },
3037 3032 { ":k", NULL, "forcibly kill and release target", cmd_notsup },
3038 3033 { ":t", "?[+/-dDestT] [-c cmd] [-n count] SIG ...", "stop on delivery "
3039 3034 "of the specified signals", cmd_sigbp, sigbp_help },
3040 3035 { ":r", "[ args ... ]", "run a new target process", cmd_run },
3041 3036 { ":R", NULL, "release the previously attached process", cmd_notsup },
3042 3037 { ":s", "[SIG]", "single-step target to next instruction", cmd_step },
3043 3038 { ":u", "[SIG]", "step target out of current function", cmd_step_out },
3044 3039 { "attach", "?[core|pid]",
3045 3040 "attach to process or core file", cmd_notsup },
3046 3041 { "cat", "[file ...]", "concatenate and display files", cmd_cat },
3047 3042 { "cont", "[SIG]", "continue target execution", cmd_cont },
3048 3043 { "context", ":", "change debugger target context", cmd_context },
3049 3044 { "dem", "name ...", "demangle C++ symbol names", cmd_demstr },
3050 3045 { "fltbp", "?[+/-dDestT] [-c cmd] [-n count] fault ...",
3051 3046 "stop on machine fault", cmd_fltbp, fltbp_help },
3052 3047 { "fpregs", NULL, "print floating point registers", cmd_notsup },
3053 3048 { "kill", NULL, "forcibly kill and release target", cmd_notsup },
3054 3049 { "load", "[-s] module", "load debugger module", cmd_load, load_help },
3055 3050 { "log", "[-d | [-e] file]", "log session to a file", cmd_log },
3056 3051 { "next", "[SIG]", "step target over next instruction", cmd_next },
3057 3052 { "quit", NULL, "quit debugger", cmd_quit },
3058 3053 { "release", NULL,
3059 3054 "release the previously attached process", cmd_notsup },
3060 3055 { "run", "[ args ... ]", "run a new target process", cmd_run },
3061 3056 { "sigbp", "?[+/-dDestT] [-c cmd] [-n count] SIG ...", "stop on "
3062 3057 "delivery of the specified signals", cmd_sigbp, sigbp_help },
3063 3058 { "step", "[ over | out ] [SIG]",
3064 3059 "single-step target to next instruction", cmd_step },
3065 3060 { "sysbp", "?[+/-dDestT] [-io] [-c cmd] [-n count] syscall ...",
3066 3061 "stop on entry or exit from system call", cmd_sysbp, sysbp_help },
3067 3062 { "unload", "module", "unload debugger module", cmd_unload },
3068 3063 { "wp", ":[+/-dDelstT] [-rwx] [-c cmd] [-n count] [-L size]",
3069 3064 "set a watchpoint at the specified address", cmd_wp, wp_help },
3070 3065 #endif
3071 3066
3072 3067 { NULL }
3073 3068 };
|
↓ open down ↓ |
1493 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX