Print this page
11626 introduce /etc/versions/build
11627 clean up UUID code for ::status
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/mdb/common/kmdb/kmdb_kvm.c
+++ new/usr/src/cmd/mdb/common/kmdb/kmdb_kvm.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.
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
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 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright (c) 2013 by Delphix. All rights reserved.
24 24 *
25 - * Copyright 2018 Joyent, Inc.
25 + * Copyright 2019 Joyent, Inc.
26 26 */
27 27
28 28 #include <kmdb/kmdb_kvm.h>
29 29 #include <kmdb/kvm.h>
30 30 #include <kmdb/kmdb_kdi.h>
31 31 #include <kmdb/kmdb_promif.h>
32 32 #include <kmdb/kmdb_module.h>
33 33 #include <kmdb/kmdb_asmutil.h>
34 34 #include <mdb/mdb_types.h>
35 35 #include <mdb/mdb_conf.h>
36 36 #include <mdb/mdb_err.h>
37 37 #include <mdb/mdb_modapi.h>
38 38 #include <mdb/mdb_target_impl.h>
39 39 #include <mdb/mdb_debug.h>
40 40 #include <mdb/mdb_string.h>
41 41 #include <mdb/mdb_ctf.h>
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
42 42 #include <mdb/mdb_kreg_impl.h>
43 43 #include <mdb/mdb_ks.h>
44 44 #include <mdb/mdb.h>
45 45
46 46 #include <strings.h>
47 47 #include <dlfcn.h>
48 48 #include <sys/isa_defs.h>
49 49 #include <sys/kobj.h>
50 50 #include <sys/kobj_impl.h>
51 51 #include <sys/bitmap.h>
52 +#include <sys/uuid.h>
52 53 #include <vm/as.h>
53 54
54 55 static const char KMT_RTLD_NAME[] = "krtld";
55 56 static const char KMT_MODULE[] = "mdb_ks";
56 57 static const char KMT_CTFPARENT[] = "genunix";
57 58
58 59 static mdb_list_t kmt_defbp_list; /* List of current deferred bp's */
59 60 static int kmt_defbp_lock; /* For list, running kernel holds */
60 61 static uint_t kmt_defbp_modchg_isload; /* Whether mod change is load/unload */
61 62 static struct modctl *kmt_defbp_modchg_modctl; /* modctl for defbp checking */
62 63 static uint_t kmt_defbp_num; /* Number of referenced def'd bp's */
63 64 static int kmt_defbp_bpspec; /* vespec for def'd bp activation bp */
64 65
65 66 static const mdb_se_ops_t kmt_brkpt_ops;
66 67 static const mdb_se_ops_t kmt_wapt_ops;
67 68
68 69 static void kmt_sync(mdb_tgt_t *);
69 70
70 71 typedef struct kmt_symarg {
71 72 mdb_tgt_sym_f *sym_cb; /* Caller's callback function */
72 73 void *sym_data; /* Callback function argument */
73 74 uint_t sym_type; /* Symbol type/binding filter */
74 75 mdb_syminfo_t sym_info; /* Symbol id and table id */
75 76 const char *sym_obj; /* Containing object */
76 77 } kmt_symarg_t;
77 78
78 79 typedef struct kmt_maparg {
79 80 mdb_tgt_t *map_target; /* Target used for mapping iter */
80 81 mdb_tgt_map_f *map_cb; /* Caller's callback function */
81 82 void *map_data; /* Callback function argument */
82 83 } kmt_maparg_t;
83 84
84 85 /*ARGSUSED*/
85 86 int
86 87 kmt_setflags(mdb_tgt_t *t, int flags)
87 88 {
88 89 /*
89 90 * We only handle one flag (ALLOWIO), and we can't fail to set or clear
90 91 * it, so we just blindly replace the t_flags version with the one
91 92 * passed.
92 93 */
93 94 t->t_flags = (t->t_flags & ~MDB_TGT_F_ALLOWIO) |
94 95 (flags & MDB_TGT_F_ALLOWIO);
95 96
96 97 return (0);
97 98 }
98 99
99 100 /*ARGSUSED*/
100 101 const char *
101 102 kmt_name(mdb_tgt_t *t)
102 103 {
103 104 return ("kmdb_kvm");
104 105 }
105 106
106 107 /*ARGSUSED*/
107 108 static const char *
108 109 kmt_platform(mdb_tgt_t *t)
109 110 {
110 111 static char platform[SYS_NMLN];
111 112
112 113 if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT)
113 114 return (mdb_conf_platform());
114 115
115 116 if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, platform,
116 117 sizeof (platform), "unix", "platform") != sizeof (platform)) {
117 118 warn("'platform' symbol is missing from kernel\n");
118 119 return ("unknown");
119 120 }
120 121
121 122 return (platform);
122 123 }
123 124
124 125 static int
125 126 kmt_uname(mdb_tgt_t *t, struct utsname *utsp)
126 127 {
127 128 return (mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, utsp,
128 129 sizeof (struct utsname), MDB_TGT_OBJ_EXEC, "utsname"));
129 130 }
130 131
131 132 /*ARGSUSED*/
132 133 static int
133 134 kmt_dmodel(mdb_tgt_t *t)
134 135 {
135 136 return (MDB_TGT_MODEL_NATIVE);
136 137 }
137 138
138 139 /*ARGSUSED*/
139 140 ssize_t
140 141 kmt_rw(mdb_tgt_t *t, void *buf, size_t nbytes, uint64_t addr,
141 142 ssize_t (*rw)(void *, size_t, uint64_t))
142 143 {
143 144 /*
144 145 * chunksz needs to be volatile because of the use of setjmp() in this
145 146 * function.
146 147 */
147 148 volatile size_t chunksz;
148 149 size_t n, ndone;
149 150 jmp_buf *oldpcb = NULL;
150 151 jmp_buf pcb;
151 152 ssize_t res;
152 153
153 154 kmdb_prom_check_interrupt();
154 155
155 156 if (nbytes == 0)
156 157 return (0);
157 158
158 159 /*
159 160 * Try to process the entire buffer, as requested. If we catch a fault,
160 161 * try smaller chunks. This allows us to handle regions that cross
161 162 * mapping boundaries.
162 163 */
163 164 chunksz = nbytes;
164 165 ndone = 0;
165 166 if (setjmp(pcb) != 0) {
166 167 if (chunksz == 1) {
167 168 /* We failed with the smallest chunk - give up */
168 169 kmdb_dpi_restore_fault_hdlr(oldpcb);
169 170 return (ndone > 0 ? ndone : -1); /* errno set for us */
170 171 } else if (chunksz > 4)
171 172 chunksz = 4;
172 173 else
173 174 chunksz = 1;
174 175 }
175 176
176 177 oldpcb = kmdb_dpi_set_fault_hdlr(&pcb);
177 178 while (nbytes > 0) {
178 179 n = MIN(chunksz, nbytes);
179 180
180 181 if ((res = rw(buf, n, addr)) != n)
181 182 return (res < 0 ? res : ndone + res);
182 183
183 184 addr += n;
184 185 nbytes -= n;
185 186 ndone += n;
186 187 buf = ((caddr_t)buf + n);
187 188 }
188 189
189 190 kmdb_dpi_restore_fault_hdlr(oldpcb);
190 191
191 192 return (ndone);
192 193 }
193 194
194 195 static void
195 196 kmt_bcopy(const void *s1, void *s2, size_t n)
196 197 {
197 198 /*
198 199 * We need to guarantee atomic accesses for certain sizes. bcopy won't
199 200 * make that guarantee, so we need to do it ourselves.
200 201 */
201 202 #ifdef _LP64
202 203 if (n == 8 && ((uintptr_t)s1 & 7) == 0 && ((uintptr_t)s2 & 7) == 0)
203 204 *(uint64_t *)s2 = *(uint64_t *)s1;
204 205 else
205 206 #endif
206 207 if (n == 4 && ((uintptr_t)s1 & 3) == 0 && ((uintptr_t)s2 & 3) == 0)
207 208 *(uint32_t *)s2 = *(uint32_t *)s1;
208 209 else if (n == 2 && ((uintptr_t)s1 & 1) == 0 && ((uintptr_t)s2 & 1) == 0)
209 210 *(uint16_t *)s2 = *(uint16_t *)s1;
210 211 else if (n == 1)
211 212 *(uint8_t *)s2 = *(uint8_t *)s1;
212 213 else
213 214 bcopy(s1, s2, n);
214 215 }
215 216
216 217 static ssize_t
217 218 kmt_reader(void *buf, size_t nbytes, uint64_t addr)
218 219 {
219 220 kmt_bcopy((void *)(uintptr_t)addr, buf, nbytes);
220 221 return (nbytes);
221 222 }
222 223
223 224 ssize_t
224 225 kmt_writer(void *buf, size_t nbytes, uint64_t addr)
225 226 {
226 227 kmt_bcopy(buf, (void *)(uintptr_t)addr, nbytes);
227 228 return (nbytes);
228 229 }
229 230
230 231 /*ARGSUSED*/
231 232 static ssize_t
232 233 kmt_read(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
233 234 {
234 235 /*
235 236 * We don't want to allow reads of I/O-mapped memory. Multi-page reads
236 237 * that cross into I/O-mapped memory should be restricted to the initial
237 238 * non-I/O region. Reads that begin in I/O-mapped memory are failed
238 239 * outright.
239 240 */
240 241 if (!(t->t_flags & MDB_TGT_F_ALLOWIO) &&
241 242 (nbytes = kmdb_kdi_range_is_nontoxic(addr, nbytes, 0)) == 0)
242 243 return (set_errno(EMDB_NOMAP));
243 244
244 245 return (kmt_rw(t, buf, nbytes, addr, kmt_reader));
245 246 }
246 247
247 248 /*ARGSUSED*/
248 249 static ssize_t
249 250 kmt_pread(mdb_tgt_t *t, void *buf, size_t nbytes, physaddr_t addr)
250 251 {
251 252 return (kmt_rw(t, buf, nbytes, addr, kmdb_kdi_pread));
252 253 }
253 254
254 255 /*ARGSUSED*/
255 256 ssize_t
256 257 kmt_pwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, physaddr_t addr)
257 258 {
258 259 return (kmt_rw(t, (void *)buf, nbytes, addr, kmdb_kdi_pwrite));
259 260 }
260 261
261 262 static uintptr_t
262 263 kmt_read_kas(mdb_tgt_t *t)
263 264 {
264 265 GElf_Sym sym;
265 266
266 267 if (mdb_tgt_lookup_by_name(t, "unix", "kas", &sym, NULL) < 0) {
267 268 warn("'kas' symbol is missing from kernel\n");
268 269 (void) set_errno(EMDB_NOSYM);
269 270 return (0);
270 271 }
271 272
272 273 return ((uintptr_t)sym.st_value);
273 274 }
274 275
275 276 static int
276 277 kmt_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap)
277 278 {
278 279 mdb_module_t *mod;
279 280 struct as *asp;
280 281 mdb_var_t *v;
281 282
282 283 switch ((uintptr_t)as) {
283 284 case (uintptr_t)MDB_TGT_AS_PHYS:
284 285 case (uintptr_t)MDB_TGT_AS_FILE:
285 286 case (uintptr_t)MDB_TGT_AS_IO:
286 287 return (set_errno(EINVAL));
287 288 case (uintptr_t)MDB_TGT_AS_VIRT:
288 289 if ((asp = (struct as *)kmt_read_kas(t)) == NULL)
289 290 return (-1); /* errno is set for us */
290 291 break;
291 292 default:
292 293 asp = (struct as *)as;
293 294
294 295 /* We don't support non-kas vtop */
295 296 if (asp != (struct as *)kmt_read_kas(t))
296 297 return (set_errno(EMDB_TGTNOTSUP));
297 298 }
298 299
299 300 if (kmdb_prom_vtop(va, pap) == 0)
300 301 return (0);
301 302
302 303 if ((v = mdb_nv_lookup(&mdb.m_modules, "unix")) != NULL &&
303 304 (mod = mdb_nv_get_cookie(v)) != NULL) {
304 305 int (*fptr)(uintptr_t, struct as *, physaddr_t *);
305 306
306 307 fptr = (int (*)(uintptr_t, struct as *, physaddr_t *))
307 308 dlsym(mod->mod_hdl, "platform_vtop");
308 309
309 310 if ((fptr != NULL) && ((*fptr)(va, asp, pap) == 0))
310 311 return (0);
311 312 }
312 313
313 314 return (set_errno(EMDB_NOMAP));
314 315 }
315 316
316 317 /*ARGSUSED*/
317 318 static int
318 319 kmt_cpuregs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
319 320 {
320 321 const mdb_tgt_gregset_t *gregs;
321 322 intptr_t cpuid = DPI_MASTER_CPUID;
322 323 int i;
323 324
324 325 if (flags & DCMD_ADDRSPEC) {
325 326 if (argc != 0)
326 327 return (DCMD_USAGE);
327 328 if ((cpuid = mdb_cpu2cpuid(addr)) < 0) {
328 329 (void) set_errno(EMDB_NOMAP);
329 330 mdb_warn("failed to find cpuid for cpu at %p", addr);
330 331 return (DCMD_ERR);
331 332 }
332 333 }
333 334
334 335 i = mdb_getopts(argc, argv,
335 336 'c', MDB_OPT_UINTPTR, &cpuid,
336 337 NULL);
337 338
338 339 argc -= i;
339 340 argv += i;
340 341
341 342 if (argc != 0)
342 343 return (DCMD_USAGE);
343 344
344 345 if ((gregs = kmdb_dpi_get_gregs(cpuid)) == NULL) {
345 346 warn("failed to retrieve registers for cpu %d", (int)cpuid);
346 347 return (DCMD_ERR);
347 348 }
348 349
349 350 kmt_printregs(gregs);
350 351
351 352 return (DCMD_OK);
352 353 }
353 354
354 355 static int
355 356 kmt_regs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
356 357 {
357 358 if (flags & DCMD_ADDRSPEC)
358 359 return (DCMD_USAGE);
359 360
360 361 return (kmt_cpuregs(addr, flags, argc, argv));
361 362 }
362 363
363 364 static int
364 365 kmt_cpustack_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
365 366 {
366 367 intptr_t cpuid = DPI_MASTER_CPUID;
367 368 uint_t verbose = 0;
368 369 int i;
369 370
370 371 if (flags & DCMD_ADDRSPEC) {
371 372 if ((cpuid = mdb_cpu2cpuid(addr)) < 0) {
372 373 (void) set_errno(EMDB_NOMAP);
373 374 mdb_warn("failed to find cpuid for cpu at %p", addr);
374 375 return (DCMD_ERR);
375 376 }
376 377 flags &= ~DCMD_ADDRSPEC;
377 378 }
378 379
379 380 i = mdb_getopts(argc, argv,
380 381 'c', MDB_OPT_UINTPTR, &cpuid,
381 382 'v', MDB_OPT_SETBITS, 1, &verbose,
382 383 NULL);
383 384
384 385 argc -= i;
385 386 argv += i;
386 387
387 388 return (kmt_cpustack(addr, flags, argc, argv, cpuid, verbose));
388 389 }
389 390
390 391 /*
391 392 * Lasciate ogne speranza, voi ch'intrate.
392 393 */
393 394 static int
394 395 kmt_call(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
395 396 {
396 397 uintptr_t *call_argv, rval;
397 398 int parse_strings = 1;
398 399 GElf_Sym sym;
399 400 jmp_buf *oldpcb = NULL;
400 401 jmp_buf pcb;
401 402 int i;
402 403
403 404 if (!(flags & DCMD_ADDRSPEC))
404 405 return (DCMD_USAGE);
405 406
406 407 if (mdb_tgt_lookup_by_addr(mdb.m_target, addr, MDB_TGT_SYM_EXACT,
407 408 NULL, 0, &sym, NULL) == 0 && GELF_ST_TYPE(sym.st_info) !=
408 409 STT_FUNC) {
409 410 warn("%a is not a function\n", addr);
410 411 return (DCMD_ERR);
411 412 }
412 413
413 414 if (argc > 1 && argv[0].a_type == MDB_TYPE_STRING &&
414 415 strcmp(argv[0].a_un.a_str, "-s") == 0) {
415 416 parse_strings = 0;
416 417 argc--;
417 418 argv++;
418 419 }
419 420
420 421 call_argv = mdb_alloc(sizeof (uintptr_t) * argc, UM_SLEEP);
421 422
422 423 for (i = 0; i < argc; i++) {
423 424 switch (argv[i].a_type) {
424 425 case MDB_TYPE_STRING:
425 426 /*
426 427 * mdb_strtoull doesn't return on error, so we have to
427 428 * pre-check strings suspected to contain numbers.
428 429 */
429 430 if (parse_strings && strisbasenum(argv[i].a_un.a_str)) {
430 431 call_argv[i] = (uintptr_t)mdb_strtoull(
431 432 argv[i].a_un.a_str);
432 433 } else
433 434 call_argv[i] = (uintptr_t)argv[i].a_un.a_str;
434 435
435 436 break;
436 437
437 438 case MDB_TYPE_IMMEDIATE:
438 439 call_argv[i] = argv[i].a_un.a_val;
439 440 break;
440 441
441 442 default:
442 443 mdb_free(call_argv,
443 444 sizeof (uintptr_t) * argc);
444 445 return (DCMD_USAGE);
445 446 }
446 447 }
447 448
448 449 if (setjmp(pcb) != 0) {
449 450 warn("call failed: caught a trap\n");
450 451
451 452 kmdb_dpi_restore_fault_hdlr(oldpcb);
452 453 mdb_free(call_argv, sizeof (uintptr_t) * argc);
453 454 return (DCMD_ERR);
454 455 }
455 456
456 457 oldpcb = kmdb_dpi_set_fault_hdlr(&pcb);
457 458 rval = kmdb_dpi_call(addr, argc, call_argv);
458 459 kmdb_dpi_restore_fault_hdlr(oldpcb);
459 460
460 461 if (flags & DCMD_PIPE_OUT) {
461 462 mdb_printf("%p\n", rval);
462 463 } else {
463 464 /* pretty-print the results */
464 465 mdb_printf("%p = %a(", rval, addr);
465 466 for (i = 0; i < argc; i++) {
466 467 if (i > 0)
467 468 mdb_printf(", ");
468 469 if (argv[i].a_type == MDB_TYPE_STRING) {
469 470 /* I'm ashamed but amused */
470 471 char *quote = &("\""[parse_strings &&
471 472 strisbasenum(argv[i].a_un.a_str)]);
472 473
473 474 mdb_printf("%s%s%s", quote, argv[i].a_un.a_str,
474 475 quote);
475 476 } else
476 477 mdb_printf("%p", argv[i].a_un.a_val);
477 478 }
478 479 mdb_printf(");\n");
479 480 }
480 481
481 482 mdb_free(call_argv, sizeof (uintptr_t) * argc);
482 483
483 484 return (DCMD_OK);
484 485 }
485 486
486 487 /*ARGSUSED*/
487 488 int
488 489 kmt_dump_crumbs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
489 490 {
490 491 intptr_t cpu = -1;
491 492
492 493 if (flags & DCMD_ADDRSPEC) {
493 494 if (argc != 0)
494 495 return (DCMD_USAGE);
495 496 } else {
496 497 addr = 0;
497 498
498 499 if (mdb_getopts(argc, argv,
499 500 'c', MDB_OPT_UINTPTR, &cpu,
500 501 NULL) != argc)
501 502 return (DCMD_USAGE);
502 503 }
503 504
504 505 kmdb_dpi_dump_crumbs(addr, cpu);
505 506
506 507 return (DCMD_OK);
507 508 }
508 509
509 510 /*ARGSUSED*/
510 511 static int
511 512 kmt_noducttape(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
512 513 {
513 514 int a = 0;
514 515
515 516 return (a/a);
516 517 }
517 518
518 519 static int
519 520 kmt_dmod_status(char *msg, int state)
520 521 {
521 522 kmdb_modctl_t *kmc;
522 523 mdb_var_t *v;
523 524 int first = 1, n = 0;
524 525
525 526 mdb_nv_rewind(&mdb.m_dmodctl);
526 527 while ((v = mdb_nv_advance(&mdb.m_dmodctl)) != NULL) {
527 528 kmc = MDB_NV_COOKIE(v);
528 529
529 530 if (kmc->kmc_state != state)
530 531 continue;
531 532
532 533 n++;
533 534
534 535 if (msg != NULL) {
535 536 if (first) {
536 537 mdb_printf(msg, NULL);
537 538 first = 0;
538 539 }
539 540
540 541 mdb_printf(" %s", kmc->kmc_modname);
541 542 }
542 543 }
543 544
544 545 if (!first && msg != NULL)
|
↓ open down ↓ |
483 lines elided |
↑ open up ↑ |
545 546 mdb_printf("\n");
546 547
547 548 return (n);
548 549 }
549 550
550 551 /*ARGSUSED*/
551 552 static int
552 553 kmt_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
553 554 {
554 555 struct utsname uts;
555 - char uuid[37];
556 + char uuid[UUID_PRINTABLE_STRING_LENGTH];
556 557 kreg_t tt;
557 558
558 559 if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, &uts, sizeof (uts),
559 560 "unix", "utsname") != sizeof (uts)) {
560 561 warn("failed to read 'utsname' struct from kernel\n");
561 562 bzero(&uts, sizeof (uts));
562 563 (void) strcpy(uts.nodename, "unknown machine");
563 564 }
564 565
565 566 mdb_printf("debugging live kernel (%d-bit) on %s\n",
566 567 (int)(sizeof (void *) * NBBY),
567 568 (*uts.nodename == '\0' ? "(not set)" : uts.nodename));
568 569 mdb_printf("operating system: %s %s (%s)\n",
569 570 uts.release, uts.version, uts.machine);
570 571
571 - if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, uuid, sizeof (uuid),
572 - "genunix", "dump_osimage_uuid") != sizeof (uuid)) {
573 - warn("failed to read 'dump_osimage_uuid' string from kernel\n");
574 - (void) strcpy(uuid, "(error)");
575 - } else if (*uuid == '\0') {
576 - (void) strcpy(uuid, "(not set)");
577 - } else if (uuid[36] != '\0') {
578 - (void) strcpy(uuid, "(invalid)");
572 + mdb_print_buildversion();
573 +
574 + if (mdb_readsym(uuid, sizeof (uuid),
575 + "dump_osimage_uuid") == sizeof (uuid) &&
576 + uuid[sizeof (uuid) - 1] == '\0') {
577 + mdb_printf("image uuid: %s\n", uuid[0] != '\0' ?
578 + uuid : "(not set)");
579 579 }
580 - mdb_printf("image uuid: %s\n", uuid);
581 580
582 581 mdb_printf("DTrace state: %s\n", (kmdb_kdi_dtrace_get_state() ==
583 582 KDI_DTSTATE_DTRACE_ACTIVE ? "active (debugger breakpoints cannot "
584 583 "be armed)" : "inactive"));
585 584
586 585 (void) kmdb_dpi_get_register("tt", &tt);
587 586 mdb_printf("stopped on: %s\n", kmt_trapname(tt));
588 587
589 588 (void) kmt_dmod_status("pending dmod loads:", KMDB_MC_STATE_LOADING);
590 589 (void) kmt_dmod_status("pending dmod unloads:",
591 590 KMDB_MC_STATE_UNLOADING);
592 591
593 592 return (DCMD_OK);
594 593 }
595 594
596 595 /*ARGSUSED*/
597 596 static int
598 597 kmt_switch(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
599 598 {
600 599 if (!(flags & DCMD_ADDRSPEC) || argc != 0)
601 600 return (DCMD_USAGE);
602 601
603 602 if (kmdb_dpi_switch_master((int)addr) < 0) {
604 603 warn("failed to switch to CPU %d", (int)addr);
605 604 return (DCMD_ERR);
606 605 }
607 606
608 607 return (DCMD_OK);
609 608 }
610 609
611 610 static const mdb_dcmd_t kmt_dcmds[] = {
612 611 { "$c", "?[cnt]", "print stack backtrace", kmt_stack },
613 612 { "$C", "?[cnt]", "print stack backtrace", kmt_stackv },
614 613 { "$r", NULL, "print general-purpose registers", kmt_regs },
615 614 { "$?", NULL, "print status and registers", kmt_regs },
616 615 { ":x", ":", "change the active CPU", kmt_switch },
617 616 { "call", ":[arg ...]", "call a kernel function", kmt_call },
618 617 { "cpustack", "?[-v] [-c cpuid] [cnt]", "print stack backtrace for a "
619 618 "specific CPU", kmt_cpustack_dcmd },
620 619 { "cpuregs", "?[-c cpuid]", "print general-purpose registers for a "
621 620 "specific CPU", kmt_cpuregs },
622 621 { "crumbs", NULL, NULL, kmt_dump_crumbs },
623 622 #if defined(__i386) || defined(__amd64)
624 623 { "in", ":[-L len]", "read from I/O port", kmt_in_dcmd },
625 624 { "out", ":[-L len] val", "write to I/O port", kmt_out_dcmd },
626 625 { "rdmsr", ":", "read an MSR", kmt_rdmsr },
627 626 { "wrmsr", ": val", "write an MSR", kmt_wrmsr },
628 627 { "rdpcicfg", ": bus dev func", "read a register in PCI config space",
629 628 kmt_rdpcicfg },
630 629 { "wrpcicfg", ": bus dev func val", "write a register in PCI config "
631 630 "space", kmt_wrpcicfg },
632 631 #endif
633 632 { "noducttape", NULL, NULL, kmt_noducttape },
634 633 { "regs", NULL, "print general-purpose registers", kmt_regs },
635 634 { "stack", "?[cnt]", "print stack backtrace", kmt_stack },
636 635 { "stackregs", "?", "print stack backtrace and registers", kmt_stackr },
637 636 { "status", NULL, "print summary of current target", kmt_status_dcmd },
638 637 { "switch", ":", "change the active CPU", kmt_switch },
639 638 { NULL }
640 639 };
641 640
642 641 static uintmax_t
643 642 kmt_reg_disc_get(const mdb_var_t *v)
644 643 {
645 644 mdb_tgt_reg_t r = 0;
646 645
647 646 (void) mdb_tgt_getareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), &r);
648 647
649 648 return (r);
650 649 }
651 650
652 651 static void
653 652 kmt_reg_disc_set(mdb_var_t *v, uintmax_t r)
654 653 {
655 654 if (mdb_tgt_putareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), r) == -1)
656 655 warn("failed to modify %%%s register", mdb_nv_get_name(v));
657 656 }
658 657
659 658 static const mdb_nv_disc_t kmt_reg_disc = {
660 659 kmt_reg_disc_set,
661 660 kmt_reg_disc_get
662 661 };
663 662
664 663 /*ARGSUSED*/
665 664 static int
666 665 kmt_getareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname,
667 666 mdb_tgt_reg_t *rp)
668 667 {
669 668 kreg_t val;
670 669
671 670 if (kmdb_dpi_get_register(rname, &val) < 0)
672 671 return (set_errno(EMDB_BADREG));
673 672
674 673 *rp = val;
675 674 return (0);
676 675 }
677 676
678 677 /*ARGSUSED*/
679 678 static int
680 679 kmt_putareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname, mdb_tgt_reg_t r)
681 680 {
682 681 if (kmdb_dpi_set_register(rname, r) < 0)
683 682 return (set_errno(EMDB_BADREG));
684 683
685 684 return (0);
686 685 }
687 686
688 687 static void
689 688 kmt_mod_destroy(kmt_module_t *km)
690 689 {
691 690 if (km->km_name != NULL)
692 691 strfree(km->km_name);
693 692 if (km->km_symtab != NULL)
694 693 mdb_gelf_symtab_destroy(km->km_symtab);
695 694 if (km->km_ctfp != NULL)
696 695 mdb_ctf_close(km->km_ctfp);
697 696 }
698 697
699 698 static kmt_module_t *
700 699 kmt_mod_create(mdb_tgt_t *t, struct modctl *ctlp, char *name)
701 700 {
702 701 kmt_module_t *km = mdb_zalloc(sizeof (kmt_module_t), UM_SLEEP);
703 702 struct module *mod;
704 703
705 704 km->km_name = mdb_alloc(strlen(name) + 1, UM_SLEEP);
706 705 (void) strcpy(km->km_name, name);
707 706
708 707 bcopy(ctlp, &km->km_modctl, sizeof (struct modctl));
709 708
710 709 if (mdb_tgt_vread(t, &km->km_module, sizeof (struct module),
711 710 (uintptr_t)km->km_modctl.mod_mp) != sizeof (struct module))
712 711 goto create_module_cleanup;
713 712 mod = &km->km_module;
714 713
715 714 if (mod->symhdr != NULL && mod->strhdr != NULL && mod->symtbl != NULL &&
716 715 mod->strings != NULL) {
717 716 mdb_gelf_ehdr_to_gehdr(&mod->hdr, &km->km_ehdr);
718 717
719 718 km->km_symtab = mdb_gelf_symtab_create_raw(&km->km_ehdr,
720 719 mod->symhdr, mod->symtbl, mod->strhdr, mod->strings,
721 720 MDB_TGT_SYMTAB);
722 721
723 722 km->km_symtab_va = mod->symtbl;
724 723 km->km_strtab_va = mod->strings;
725 724
726 725 if (mdb_tgt_vread(t, &km->km_symtab_hdr, sizeof (Shdr),
727 726 (uintptr_t)mod->symhdr) != sizeof (Shdr) ||
728 727 mdb_tgt_vread(t, &km->km_strtab_hdr, sizeof (Shdr),
729 728 (uintptr_t)mod->strhdr) != sizeof (Shdr))
730 729 goto create_module_cleanup;
731 730 }
732 731
733 732 /*
734 733 * We don't want everyone rooting around in the module structure, so we
735 734 * make copies of the interesting members.
736 735 */
737 736 km->km_text_va = (uintptr_t)mod->text;
738 737 km->km_text_size = mod->text_size;
739 738 km->km_data_va = (uintptr_t)mod->data;
740 739 km->km_data_size = mod->data_size;
741 740 km->km_bss_va = (uintptr_t)mod->bss;
742 741 km->km_bss_size = mod->bss_size;
743 742 km->km_ctf_va = mod->ctfdata;
744 743 km->km_ctf_size = mod->ctfsize;
745 744
746 745 if (mod->flags & KOBJ_PRIM)
747 746 km->km_flags |= KM_F_PRIMARY;
748 747
749 748 return (km);
750 749
751 750 create_module_cleanup:
752 751 warn("failed to read module %s\n", name);
753 752 kmt_mod_destroy(km);
754 753 return (NULL);
755 754 }
756 755
757 756 static void
758 757 kmt_mod_remove(kmt_data_t *kmt, kmt_module_t *km)
759 758 {
760 759 mdb_var_t *v = mdb_nv_lookup(&kmt->kmt_modules, km->km_name);
761 760
762 761 ASSERT(v != NULL);
763 762
764 763 mdb_dprintf(MDB_DBG_KMOD, "removing module %s\n", km->km_name);
765 764
766 765 mdb_list_delete(&kmt->kmt_modlist, km);
767 766 mdb_nv_remove(&kmt->kmt_modules, v);
768 767 kmt_mod_destroy(km);
769 768 }
770 769
771 770 static int
772 771 kmt_modlist_update_cb(struct modctl *modp, void *arg)
773 772 {
774 773 mdb_tgt_t *t = arg;
775 774 kmt_data_t *kmt = t->t_data;
776 775 kmt_module_t *km;
777 776 mdb_var_t *v;
778 777 char name[MAXNAMELEN];
779 778
780 779 if (mdb_tgt_readstr(t, MDB_TGT_AS_VIRT, name, MAXNAMELEN,
781 780 (uintptr_t)modp->mod_modname) <= 0) {
782 781 warn("failed to read module name at %p",
783 782 (void *)modp->mod_modname);
784 783 }
785 784
786 785 /* We only care about modules that are actually loaded */
787 786 if (!kmdb_kdi_mod_isloaded(modp))
788 787 return (0);
789 788
790 789 /*
791 790 * Skip the modules we already know about and that haven't
792 791 * changed since last time we were here.
793 792 */
794 793 if ((v = mdb_nv_lookup(&kmt->kmt_modules, name)) != NULL) {
795 794 km = MDB_NV_COOKIE(v);
796 795
797 796 if (kmdb_kdi_mod_haschanged(&km->km_modctl, &km->km_module,
798 797 modp, modp->mod_mp)) {
799 798 /*
800 799 * The module has changed since last we saw it. For
801 800 * safety, remove our old version, and treat it as a
802 801 * new module.
803 802 */
804 803 mdb_dprintf(MDB_DBG_KMOD, "stutter module %s\n", name);
805 804 kmt_mod_remove(kmt, km);
806 805 } else {
807 806 km->km_seen = 1;
808 807 return (0);
809 808 }
810 809 }
811 810
812 811 mdb_dprintf(MDB_DBG_KMOD, "found new module %s\n", name);
813 812
814 813 if ((km = kmt_mod_create(t, modp, name)) != NULL) {
815 814 mdb_list_append(&kmt->kmt_modlist, km);
816 815 (void) mdb_nv_insert(&kmt->kmt_modules, name, NULL,
817 816 (uintptr_t)km, 0);
818 817 km->km_seen = 1;
819 818 }
820 819
821 820 return (0);
822 821 }
823 822
824 823 static void
825 824 kmt_modlist_update(mdb_tgt_t *t)
826 825 {
827 826 kmt_data_t *kmt = t->t_data;
828 827 kmt_module_t *km, *kmn;
829 828
830 829 if (kmdb_kdi_mod_iter(kmt_modlist_update_cb, t) < 0) {
831 830 warn("failed to complete update of kernel module list\n");
832 831 return;
833 832 }
834 833
835 834 km = mdb_list_next(&kmt->kmt_modlist);
836 835 while (km != NULL) {
837 836 kmn = mdb_list_next(km);
838 837
839 838 if (km->km_seen == 1) {
840 839 /* Reset the mark for next time */
841 840 km->km_seen = 0;
842 841 } else {
843 842 /*
844 843 * We didn't see it on the kernel's module list, so
845 844 * remove it from our view of the world.
846 845 */
847 846 kmt_mod_remove(kmt, km);
848 847 }
849 848
850 849 km = kmn;
851 850 }
852 851 }
853 852
854 853 static void
855 854 kmt_periodic(mdb_tgt_t *t)
856 855 {
857 856 (void) mdb_tgt_status(t, &t->t_status);
858 857 }
859 858
860 859 int
861 860 kmt_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags,
862 861 char *buf, size_t nbytes, GElf_Sym *symp, mdb_syminfo_t *sip)
863 862 {
864 863 kmt_data_t *kmt = t->t_data;
865 864 kmt_module_t *km = mdb_list_next(&kmt->kmt_modlist);
866 865 kmt_module_t *sym_km = NULL;
867 866 kmt_module_t prmod;
868 867 GElf_Sym sym;
869 868 uint_t symid;
870 869 const char *name;
871 870
872 871 /*
873 872 * We look through the private symbols (if any), then through the module
874 873 * symbols. We can simplify the loop if we pretend the private symbols
875 874 * come from a module.
876 875 */
877 876 if (mdb.m_prsym != NULL) {
878 877 bzero(&prmod, sizeof (kmt_module_t));
879 878 prmod.km_name = "<<<prmod>>>";
880 879 prmod.km_symtab = mdb.m_prsym;
881 880 prmod.km_list.ml_next = (mdb_list_t *)km;
882 881 km = &prmod;
883 882 }
884 883
885 884 /* Symbol resolution isn't available during initialization */
886 885 if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT)
887 886 return (set_errno(EMDB_NOSYM));
888 887
889 888 for (; km != NULL; km = mdb_list_next(km)) {
890 889 if (km != &prmod && !kmt->kmt_symavail)
891 890 continue;
892 891
893 892 if (km->km_symtab == NULL)
894 893 continue;
895 894
896 895 if (mdb_gelf_symtab_lookup_by_addr(km->km_symtab, addr, flags,
897 896 buf, nbytes, symp, &sip->sym_id) != 0 ||
898 897 symp->st_value == 0)
899 898 continue;
900 899
901 900 if (flags & MDB_TGT_SYM_EXACT) {
902 901 sym_km = km;
903 902 goto found;
904 903 }
905 904
906 905 /*
907 906 * If this is the first match we've found, or if this symbol is
908 907 * closer to the specified address than the last one we found,
909 908 * use it.
910 909 */
911 910 if (sym_km == NULL || mdb_gelf_sym_closer(symp, &sym, addr)) {
912 911 sym_km = km;
913 912 sym = *symp;
914 913 symid = sip->sym_id;
915 914 }
916 915 }
917 916
918 917 /*
919 918 * kmdb dmods are normal kernel modules, loaded by krtld as such. To
920 919 * avoid polluting modinfo, and to keep from confusing the module
921 920 * subsystem (many dmods have the same names as real kernel modules),
922 921 * kmdb keeps their modctls separate, and doesn't allow their loading
923 922 * to be broadcast via the krtld module load/unload mechanism. As a
924 923 * result, kmdb_kvm doesn't find out about them, and can't turn their
925 924 * addresses into symbols. This can be most inconvenient during
926 925 * debugger faults, as the dmod frames will show up without names.
927 926 * We weren't able to turn the requested address into a symbol, so we'll
928 927 * take a spin through the dmods, trying to match our address against
929 928 * their symbols.
930 929 */
931 930 if (sym_km == NULL) {
932 931 return (kmdb_module_lookup_by_addr(addr, flags, buf, nbytes,
933 932 symp, sip));
934 933 }
935 934
936 935 *symp = sym;
937 936 sip->sym_id = symid;
938 937
939 938 found:
940 939 /*
941 940 * Once we've found something, copy the final name into the caller's
942 941 * buffer and prefix it with the load object name if appropriate.
943 942 */
944 943 name = mdb_gelf_sym_name(sym_km->km_symtab, symp);
945 944
946 945 if (sym_km == &prmod) {
947 946 if (buf != NULL) {
948 947 (void) strncpy(buf, name, nbytes);
949 948 buf[nbytes - 1] = '\0';
950 949 }
951 950 sip->sym_table = MDB_TGT_PRVSYM;
952 951 } else {
953 952 if (buf != NULL) {
954 953 if (sym_km->km_flags & KM_F_PRIMARY) {
955 954 (void) strncpy(buf, name, nbytes);
956 955 buf[nbytes - 1] = '\0';
957 956 } else {
958 957 (void) mdb_snprintf(buf, nbytes, "%s`%s",
959 958 sym_km->km_name, name);
960 959 }
961 960 }
962 961 sip->sym_table = MDB_TGT_SYMTAB;
963 962 }
964 963
965 964 return (0);
966 965 }
967 966
968 967 static int
969 968 kmt_lookup_by_name(mdb_tgt_t *t, const char *obj, const char *name,
970 969 GElf_Sym *symp, mdb_syminfo_t *sip)
971 970 {
972 971 kmt_data_t *kmt = t->t_data;
973 972 kmt_module_t *km;
974 973 mdb_var_t *v;
975 974 GElf_Sym sym;
976 975 uint_t symid;
977 976 int n;
978 977
979 978 if (!kmt->kmt_symavail)
980 979 return (set_errno(EMDB_NOSYM));
981 980
982 981 switch ((uintptr_t)obj) {
983 982 case (uintptr_t)MDB_TGT_OBJ_EXEC:
984 983 case (uintptr_t)MDB_TGT_OBJ_EVERY:
985 984 km = mdb_list_next(&kmt->kmt_modlist);
986 985 n = mdb_nv_size(&kmt->kmt_modules);
987 986 break;
988 987
989 988 case (uintptr_t)MDB_TGT_OBJ_RTLD:
990 989 obj = kmt->kmt_rtld_name;
991 990 /*FALLTHROUGH*/
992 991
993 992 default:
994 993 /*
995 994 * If this is a request for a dmod symbol, let kmdb_module
996 995 * handle it.
997 996 */
998 997 if (obj != NULL && strncmp(obj, "DMOD`", 5) == 0) {
999 998 return (kmdb_module_lookup_by_name(obj + 5, name,
1000 999 symp, sip));
1001 1000 }
1002 1001
1003 1002 if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL)
1004 1003 return (set_errno(EMDB_NOOBJ));
1005 1004
1006 1005 km = mdb_nv_get_cookie(v);
1007 1006 n = 1;
1008 1007 }
1009 1008
1010 1009 /*
1011 1010 * kmdb's kvm target is at a bit of a disadvantage compared to mdb's
1012 1011 * kvm target when it comes to global symbol lookups. mdb has ksyms,
1013 1012 * which hides pesky things like symbols that are undefined in unix,
1014 1013 * but which are defined in genunix. We don't have such a facility -
1015 1014 * we simply iterate through the modules, looking for a given symbol
1016 1015 * in each. Unless we're careful, we'll return the undef in the
1017 1016 * aforementioned case.
1018 1017 */
1019 1018 for (; n > 0; n--, km = mdb_list_next(km)) {
1020 1019 if (mdb_gelf_symtab_lookup_by_name(km->km_symtab, name,
1021 1020 &sym, &symid) == 0 && sym.st_shndx != SHN_UNDEF)
1022 1021 break;
1023 1022 }
1024 1023
1025 1024 if (n == 0)
1026 1025 return (set_errno(EMDB_NOSYM));
1027 1026
1028 1027 found:
1029 1028 bcopy(&sym, symp, sizeof (GElf_Sym));
1030 1029 sip->sym_id = symid;
1031 1030 sip->sym_table = MDB_TGT_SYMTAB;
1032 1031
1033 1032 return (0);
1034 1033 }
1035 1034
1036 1035 static int
1037 1036 kmt_symtab_func(void *data, const GElf_Sym *sym, const char *name, uint_t id)
1038 1037 {
1039 1038 kmt_symarg_t *arg = data;
1040 1039
1041 1040 if (mdb_tgt_sym_match(sym, arg->sym_type)) {
1042 1041 arg->sym_info.sym_id = id;
1043 1042
1044 1043 return (arg->sym_cb(arg->sym_data, sym, name, &arg->sym_info,
1045 1044 arg->sym_obj));
1046 1045 }
1047 1046
1048 1047 return (0);
1049 1048 }
1050 1049
1051 1050 static void
1052 1051 kmt_symtab_iter(mdb_gelf_symtab_t *gst, uint_t type, const char *obj,
1053 1052 mdb_tgt_sym_f *cb, void *p)
1054 1053 {
1055 1054 kmt_symarg_t arg;
1056 1055
1057 1056 arg.sym_cb = cb;
1058 1057 arg.sym_data = p;
1059 1058 arg.sym_type = type;
1060 1059 arg.sym_info.sym_table = gst->gst_tabid;
1061 1060 arg.sym_obj = obj;
1062 1061
1063 1062 mdb_gelf_symtab_iter(gst, kmt_symtab_func, &arg);
1064 1063 }
1065 1064
1066 1065 static int
1067 1066 kmt_symbol_iter(mdb_tgt_t *t, const char *obj, uint_t which, uint_t type,
1068 1067 mdb_tgt_sym_f *cb, void *data)
1069 1068 {
1070 1069 kmt_data_t *kmt = t->t_data;
1071 1070 kmt_module_t *km;
1072 1071
1073 1072 mdb_gelf_symtab_t *symtab = NULL;
1074 1073 mdb_var_t *v;
1075 1074
1076 1075 if (which == MDB_TGT_DYNSYM)
1077 1076 return (set_errno(EMDB_TGTNOTSUP));
1078 1077
1079 1078 switch ((uintptr_t)obj) {
1080 1079 case (uintptr_t)MDB_TGT_OBJ_EXEC:
1081 1080 case (uintptr_t)MDB_TGT_OBJ_EVERY:
1082 1081 mdb_nv_rewind(&kmt->kmt_modules);
1083 1082 while ((v = mdb_nv_advance(&kmt->kmt_modules)) != NULL) {
1084 1083 km = mdb_nv_get_cookie(v);
1085 1084
1086 1085 if (km->km_symtab != NULL) {
1087 1086 kmt_symtab_iter(km->km_symtab, type,
1088 1087 km->km_name, cb, data);
1089 1088 }
1090 1089 }
1091 1090 return (0);
1092 1091
1093 1092 case (uintptr_t)MDB_TGT_OBJ_RTLD:
1094 1093 obj = kmt->kmt_rtld_name;
1095 1094 /*FALLTHROUGH*/
1096 1095
1097 1096 default:
1098 1097 if (strncmp(obj, "DMOD`", 5) == 0) {
1099 1098 return (kmdb_module_symbol_iter(obj + 5, type,
1100 1099 cb, data));
1101 1100 }
1102 1101
1103 1102 if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL)
1104 1103 return (set_errno(EMDB_NOOBJ));
1105 1104 km = mdb_nv_get_cookie(v);
1106 1105
1107 1106 symtab = km->km_symtab;
1108 1107 }
1109 1108
1110 1109 if (symtab != NULL)
1111 1110 kmt_symtab_iter(symtab, type, obj, cb, data);
1112 1111
1113 1112 return (0);
1114 1113 }
1115 1114
1116 1115 static int
1117 1116 kmt_mapping_walk(uintptr_t addr, const void *data, kmt_maparg_t *marg)
1118 1117 {
1119 1118 /*
1120 1119 * This is a bit sketchy but avoids problematic compilation of this
1121 1120 * target against the current VM implementation. Now that we have
1122 1121 * vmem, we can make this less broken and more informative by changing
1123 1122 * this code to invoke the vmem walker in the near future.
1124 1123 */
1125 1124 const struct kmt_seg {
1126 1125 caddr_t s_base;
1127 1126 size_t s_size;
1128 1127 } *segp = (const struct kmt_seg *)data;
1129 1128
1130 1129 mdb_map_t map;
1131 1130 GElf_Sym sym;
1132 1131 mdb_syminfo_t info;
1133 1132
1134 1133 map.map_base = (uintptr_t)segp->s_base;
1135 1134 map.map_size = segp->s_size;
1136 1135 map.map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X;
1137 1136
1138 1137 if (kmt_lookup_by_addr(marg->map_target, addr, MDB_TGT_SYM_EXACT,
1139 1138 map.map_name, MDB_TGT_MAPSZ, &sym, &info) == -1) {
1140 1139
1141 1140 (void) mdb_iob_snprintf(map.map_name, MDB_TGT_MAPSZ,
1142 1141 "%lr", addr);
1143 1142 }
1144 1143
1145 1144 return (marg->map_cb(marg->map_data, &map, map.map_name));
1146 1145 }
1147 1146
1148 1147 static int
1149 1148 kmt_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
1150 1149 {
1151 1150 kmt_maparg_t m;
1152 1151 uintptr_t kas;
1153 1152
1154 1153 m.map_target = t;
1155 1154 m.map_cb = func;
1156 1155 m.map_data = private;
1157 1156
1158 1157 if ((kas = kmt_read_kas(t)) == 0)
1159 1158 return (-1); /* errno is set for us */
1160 1159
1161 1160 return (mdb_pwalk("seg", (mdb_walk_cb_t)kmt_mapping_walk, &m, kas));
1162 1161 }
1163 1162
1164 1163 static const mdb_map_t *
1165 1164 kmt_mod_to_map(kmt_module_t *km, mdb_map_t *map)
1166 1165 {
1167 1166 (void) strncpy(map->map_name, km->km_name, MDB_TGT_MAPSZ);
1168 1167 map->map_name[MDB_TGT_MAPSZ - 1] = '\0';
1169 1168 map->map_base = km->km_text_va;
1170 1169 map->map_size = km->km_text_size;
1171 1170 map->map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X;
1172 1171
1173 1172 return (map);
1174 1173 }
1175 1174
1176 1175 static int
1177 1176 kmt_object_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
1178 1177 {
1179 1178 kmt_data_t *kmt = t->t_data;
1180 1179 kmt_module_t *km;
1181 1180 mdb_map_t m;
1182 1181
1183 1182 for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
1184 1183 km = mdb_list_next(km)) {
1185 1184 if (func(private, kmt_mod_to_map(km, &m), km->km_name) == -1)
1186 1185 break;
1187 1186 }
1188 1187
1189 1188 return (0);
1190 1189 }
1191 1190
1192 1191 static const mdb_map_t *
1193 1192 kmt_addr_to_map(mdb_tgt_t *t, uintptr_t addr)
1194 1193 {
1195 1194 kmt_data_t *kmt = t->t_data;
1196 1195 kmt_module_t *km;
1197 1196
1198 1197 for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
1199 1198 km = mdb_list_next(km)) {
1200 1199 if (addr - km->km_text_va < km->km_text_size ||
1201 1200 addr - km->km_data_va < km->km_data_size ||
1202 1201 addr - km->km_bss_va < km->km_bss_size)
1203 1202 return (kmt_mod_to_map(km, &kmt->kmt_map));
1204 1203 }
1205 1204
1206 1205 (void) set_errno(EMDB_NOMAP);
1207 1206 return (NULL);
1208 1207 }
1209 1208
1210 1209 static kmt_module_t *
1211 1210 kmt_module_by_name(kmt_data_t *kmt, const char *name)
1212 1211 {
1213 1212 kmt_module_t *km;
1214 1213
1215 1214 for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
1216 1215 km = mdb_list_next(km)) {
1217 1216 if (strcmp(name, km->km_name) == 0)
1218 1217 return (km);
1219 1218 }
1220 1219
1221 1220 return (NULL);
1222 1221 }
1223 1222
1224 1223 static const mdb_map_t *
1225 1224 kmt_name_to_map(mdb_tgt_t *t, const char *name)
1226 1225 {
1227 1226 kmt_data_t *kmt = t->t_data;
1228 1227 kmt_module_t *km;
1229 1228 mdb_map_t m;
1230 1229
1231 1230 /*
1232 1231 * If name is MDB_TGT_OBJ_EXEC, return the first module on the list,
1233 1232 * which will be unix since we keep kmt_modlist in load order.
1234 1233 */
1235 1234 if (name == MDB_TGT_OBJ_EXEC) {
1236 1235 return (kmt_mod_to_map(mdb_list_next(&kmt->kmt_modlist),
1237 1236 &m));
1238 1237 }
1239 1238
1240 1239 if (name == MDB_TGT_OBJ_RTLD)
1241 1240 name = kmt->kmt_rtld_name;
1242 1241
1243 1242 if ((km = kmt_module_by_name(kmt, name)) != NULL)
1244 1243 return (kmt_mod_to_map(km, &m));
1245 1244
1246 1245 (void) set_errno(EMDB_NOOBJ);
1247 1246 return (NULL);
1248 1247 }
1249 1248
1250 1249 static ctf_file_t *
1251 1250 kmt_load_ctfdata(mdb_tgt_t *t, kmt_module_t *km)
1252 1251 {
1253 1252 kmt_data_t *kmt = t->t_data;
1254 1253 int err;
1255 1254
1256 1255 if (km->km_ctfp != NULL)
1257 1256 return (km->km_ctfp);
1258 1257
1259 1258 if (km->km_ctf_va == NULL || km->km_symtab == NULL) {
1260 1259 (void) set_errno(EMDB_NOCTF);
1261 1260 return (NULL);
1262 1261 }
1263 1262
1264 1263 if ((km->km_ctfp = mdb_ctf_bufopen(km->km_ctf_va, km->km_ctf_size,
1265 1264 km->km_symtab_va, &km->km_symtab_hdr, km->km_strtab_va,
1266 1265 &km->km_strtab_hdr, &err)) == NULL) {
1267 1266 (void) set_errno(ctf_to_errno(err));
1268 1267 return (NULL);
1269 1268 }
1270 1269
1271 1270 mdb_dprintf(MDB_DBG_KMOD, "loaded %lu bytes of CTF data for %s\n",
1272 1271 (ulong_t)km->km_ctf_size, km->km_name);
1273 1272
1274 1273 if (ctf_parent_name(km->km_ctfp) != NULL) {
1275 1274 mdb_var_t *v;
1276 1275
1277 1276 if ((v = mdb_nv_lookup(&kmt->kmt_modules,
1278 1277 ctf_parent_name(km->km_ctfp))) != NULL) {
1279 1278 kmt_module_t *pm = mdb_nv_get_cookie(v);
1280 1279
1281 1280 if (pm->km_ctfp == NULL)
1282 1281 (void) kmt_load_ctfdata(t, pm);
1283 1282
1284 1283 if (pm->km_ctfp != NULL && ctf_import(km->km_ctfp,
1285 1284 pm->km_ctfp) == CTF_ERR) {
1286 1285 warn("failed to import parent types into "
1287 1286 "%s: %s\n", km->km_name,
1288 1287 ctf_errmsg(ctf_errno(km->km_ctfp)));
1289 1288 }
1290 1289 } else {
1291 1290 warn("failed to load CTF data for %s - parent %s not "
1292 1291 "loaded\n", km->km_name,
1293 1292 ctf_parent_name(km->km_ctfp));
1294 1293 }
1295 1294 }
1296 1295
1297 1296 return (km->km_ctfp);
1298 1297 }
1299 1298
1300 1299 ctf_file_t *
1301 1300 kmt_addr_to_ctf(mdb_tgt_t *t, uintptr_t addr)
1302 1301 {
1303 1302 kmt_data_t *kmt = t->t_data;
1304 1303 kmt_module_t *km;
1305 1304
1306 1305 for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
1307 1306 km = mdb_list_next(km)) {
1308 1307 if (addr - km->km_text_va < km->km_text_size ||
1309 1308 addr - km->km_data_va < km->km_data_size ||
1310 1309 addr - km->km_bss_va < km->km_bss_size)
1311 1310 return (kmt_load_ctfdata(t, km));
1312 1311 }
1313 1312
1314 1313 return (kmdb_module_addr_to_ctf(addr));
1315 1314 }
1316 1315
1317 1316 ctf_file_t *
1318 1317 kmt_name_to_ctf(mdb_tgt_t *t, const char *name)
1319 1318 {
1320 1319 kmt_data_t *kt = t->t_data;
1321 1320 kmt_module_t *km;
1322 1321
1323 1322 if (name == MDB_TGT_OBJ_EXEC) {
1324 1323 name = KMT_CTFPARENT;
1325 1324 } else if (name == MDB_TGT_OBJ_RTLD) {
1326 1325 name = kt->kmt_rtld_name;
1327 1326 } else if (strncmp(name, "DMOD`", 5) == 0) {
1328 1327 /* Request for CTF data for a DMOD symbol */
1329 1328 return (kmdb_module_name_to_ctf(name + 5));
1330 1329 }
1331 1330
1332 1331 if ((km = kmt_module_by_name(kt, name)) != NULL)
1333 1332 return (kmt_load_ctfdata(t, km));
1334 1333
1335 1334 (void) set_errno(EMDB_NOOBJ);
1336 1335 return (NULL);
1337 1336 }
1338 1337
1339 1338 /*ARGSUSED*/
1340 1339 static int
1341 1340 kmt_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1342 1341 {
1343 1342 int state;
1344 1343
1345 1344 bzero(tsp, sizeof (mdb_tgt_status_t));
1346 1345
1347 1346 switch ((state = kmdb_dpi_get_state(NULL))) {
1348 1347 case DPI_STATE_INIT:
1349 1348 tsp->st_state = MDB_TGT_RUNNING;
1350 1349 tsp->st_pc = 0;
1351 1350 break;
1352 1351
1353 1352 case DPI_STATE_STOPPED:
1354 1353 tsp->st_state = MDB_TGT_STOPPED;
1355 1354
1356 1355 (void) kmdb_dpi_get_register("pc", &tsp->st_pc);
1357 1356 break;
1358 1357
1359 1358 case DPI_STATE_FAULTED:
1360 1359 tsp->st_state = MDB_TGT_STOPPED;
1361 1360
1362 1361 (void) kmdb_dpi_get_register("pc", &tsp->st_pc);
1363 1362
1364 1363 tsp->st_flags |= MDB_TGT_ISTOP;
1365 1364 break;
1366 1365
1367 1366 case DPI_STATE_LOST:
1368 1367 tsp->st_state = MDB_TGT_LOST;
1369 1368
1370 1369 (void) kmdb_dpi_get_register("pc", &tsp->st_pc);
1371 1370 break;
1372 1371 }
1373 1372
1374 1373 mdb_dprintf(MDB_DBG_KMOD, "kmt_status, dpi: %d tsp: %d, pc = %p %A\n",
1375 1374 state, tsp->st_state, (void *)tsp->st_pc, tsp->st_pc);
1376 1375
1377 1376 return (0);
1378 1377 }
1379 1378
1380 1379 /*
1381 1380 * Invoked when kmt_defbp_enter_debugger is called, this routine activates and
1382 1381 * deactivates deferred breakpoints in response to module load and unload
1383 1382 * events.
1384 1383 */
1385 1384 /*ARGSUSED*/
1386 1385 static void
1387 1386 kmt_defbp_event(mdb_tgt_t *t, int vid, void *private)
1388 1387 {
1389 1388 if (kmt_defbp_modchg_isload) {
1390 1389 if (!mdb_tgt_sespec_activate_all(t) &&
1391 1390 (mdb.m_flags & MDB_FL_BPTNOSYMSTOP)) {
1392 1391 /*
1393 1392 * We weren't able to activate the breakpoints.
1394 1393 * If so requested, we'll return without calling
1395 1394 * continue, thus throwing the user into the debugger.
1396 1395 */
1397 1396 return;
1398 1397 }
1399 1398
1400 1399 } else {
1401 1400 mdb_sespec_t *sep, *nsep;
1402 1401 const mdb_map_t *map, *bpmap;
1403 1402 mdb_map_t modmap;
1404 1403
1405 1404 if ((map = kmt_addr_to_map(t,
1406 1405 (uintptr_t)kmt_defbp_modchg_modctl->mod_text)) == NULL) {
1407 1406 warn("module unload notification for unknown module %s",
1408 1407 kmt_defbp_modchg_modctl->mod_modname);
1409 1408 return; /* drop into the debugger */
1410 1409 }
1411 1410
1412 1411 bcopy(map, &modmap, sizeof (mdb_map_t));
1413 1412
1414 1413 for (sep = mdb_list_next(&t->t_active); sep; sep = nsep) {
1415 1414 nsep = mdb_list_next(sep);
1416 1415
1417 1416 if (sep->se_ops == &kmt_brkpt_ops) {
1418 1417 kmt_brkpt_t *kb = sep->se_data;
1419 1418
1420 1419 if ((bpmap = kmt_addr_to_map(t,
1421 1420 kb->kb_addr)) == NULL ||
1422 1421 (bpmap->map_base == modmap.map_base &&
1423 1422 bpmap->map_size == modmap.map_size)) {
1424 1423 mdb_tgt_sespec_idle_one(t, sep,
1425 1424 EMDB_NOMAP);
1426 1425 }
1427 1426 }
1428 1427 }
1429 1428 }
1430 1429
1431 1430 (void) mdb_tgt_continue(t, NULL);
1432 1431 }
1433 1432
1434 1433 static void
1435 1434 kmt_defbp_enter_debugger(void)
1436 1435 {
1437 1436 /*
1438 1437 * The debugger places a breakpoint here. We can't have a simple
1439 1438 * nop function here, because GCC knows much more than we do, and
1440 1439 * will optimize away the call to it.
1441 1440 */
1442 1441 (void) get_fp();
1443 1442 }
1444 1443
1445 1444 /*
1446 1445 * This routine is called while the kernel is running. It attempts to determine
1447 1446 * whether any deferred breakpoints exist for the module being changed (loaded
1448 1447 * or unloaded). If any such breakpoints exist, the debugger will be entered to
1449 1448 * process them.
1450 1449 */
1451 1450 static void
1452 1451 kmt_defbp_modchg(struct modctl *mctl, int isload)
1453 1452 {
1454 1453 kmt_defbp_t *dbp;
1455 1454
1456 1455 kmt_defbp_lock = 1;
1457 1456
1458 1457 for (dbp = mdb_list_next(&kmt_defbp_list); dbp;
1459 1458 dbp = mdb_list_next(dbp)) {
1460 1459 if (!dbp->dbp_ref)
1461 1460 continue;
1462 1461
1463 1462 if (strcmp(mctl->mod_modname, dbp->dbp_objname) == 0) {
1464 1463 /*
1465 1464 * Activate the breakpoint
1466 1465 */
1467 1466 kmt_defbp_modchg_isload = isload;
1468 1467 kmt_defbp_modchg_modctl = mctl;
1469 1468
1470 1469 kmt_defbp_enter_debugger();
1471 1470 break;
1472 1471 }
1473 1472 }
1474 1473
1475 1474 kmt_defbp_lock = 0;
1476 1475 }
1477 1476
1478 1477 /*ARGSUSED*/
1479 1478 static int
1480 1479 kmt_continue(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1481 1480 {
1482 1481 int n;
1483 1482
1484 1483 kmdb_dpi_resume();
1485 1484
1486 1485 /*
1487 1486 * The order of the following two calls is important. If there are
1488 1487 * load acks on the work queue, we'll initialize the dmods they
1489 1488 * represent. This will involve a call to _mdb_init, which may very
1490 1489 * well result in a symbol lookup. If we haven't resynced our view
1491 1490 * of symbols with the current state of the world, this lookup could
1492 1491 * end very badly. We therefore make sure to sync before processing
1493 1492 * the work queue.
1494 1493 */
1495 1494 kmt_sync(t);
1496 1495 kmdb_dpi_process_work_queue();
1497 1496
1498 1497 if (kmdb_kdi_get_unload_request())
1499 1498 t->t_flags |= MDB_TGT_F_UNLOAD;
1500 1499
1501 1500 (void) mdb_tgt_status(t, &t->t_status);
1502 1501
1503 1502 if ((n = kmt_dmod_status(NULL, KMDB_MC_STATE_LOADING) +
1504 1503 kmt_dmod_status(NULL, KMDB_MC_STATE_UNLOADING)) != 0) {
1505 1504 mdb_warn("%d dmod load%c/unload%c pending\n", n,
1506 1505 "s"[n == 1], "s"[n == 1]);
1507 1506 }
1508 1507
1509 1508 return (0);
1510 1509 }
1511 1510
1512 1511 /*ARGSUSED*/
1513 1512 static int
1514 1513 kmt_step(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1515 1514 {
1516 1515 int rc;
1517 1516
1518 1517 if ((rc = kmdb_dpi_step()) == 0)
1519 1518 (void) mdb_tgt_status(t, &t->t_status);
1520 1519
1521 1520 return (rc);
1522 1521 }
1523 1522
1524 1523 static int
1525 1524 kmt_defbp_activate(mdb_tgt_t *t)
1526 1525 {
1527 1526 kmdb_dpi_modchg_register(kmt_defbp_modchg);
1528 1527
1529 1528 /*
1530 1529 * The routines that add and arm breakpoints will check for the proper
1531 1530 * DTrace state, but they'll just put this breakpoint on the idle list
1532 1531 * if DTrace is active. It'll correctly move to the active list when
1533 1532 * DTrace deactivates, but that's insufficient for our purposes -- we
1534 1533 * need to do extra processing at that point. We won't get to do said
1535 1534 * processing with with a normal idle->active transition, so we just
1536 1535 * won't add it add it until we're sure that it'll stick.
1537 1536 */
1538 1537
1539 1538 if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE)
1540 1539 return (set_errno(EMDB_DTACTIVE));
1541 1540
1542 1541 kmt_defbp_bpspec = mdb_tgt_add_vbrkpt(t,
1543 1542 (uintptr_t)kmt_defbp_enter_debugger,
1544 1543 MDB_TGT_SPEC_HIDDEN, kmt_defbp_event, NULL);
1545 1544
1546 1545 return (0);
1547 1546 }
1548 1547
1549 1548 static void
1550 1549 kmt_defbp_deactivate(mdb_tgt_t *t)
1551 1550 {
1552 1551 kmdb_dpi_modchg_cancel();
1553 1552
1554 1553 if (kmt_defbp_bpspec != 0) {
1555 1554 if (t != NULL)
1556 1555 (void) mdb_tgt_vespec_delete(t, kmt_defbp_bpspec);
1557 1556
1558 1557 kmt_defbp_bpspec = 0;
1559 1558 }
1560 1559 }
1561 1560
1562 1561 static kmt_defbp_t *
1563 1562 kmt_defbp_create(mdb_tgt_t *t, const char *objname, const char *symname)
1564 1563 {
1565 1564 kmt_defbp_t *dbp = mdb_alloc(sizeof (kmt_defbp_t), UM_SLEEP);
1566 1565
1567 1566 mdb_dprintf(MDB_DBG_KMOD, "defbp_create %s`%s\n", objname, symname);
1568 1567
1569 1568 dbp->dbp_objname = strdup(objname);
1570 1569 dbp->dbp_symname = strdup(symname);
1571 1570 dbp->dbp_ref = 1;
1572 1571
1573 1572 kmt_defbp_num++;
1574 1573
1575 1574 if (kmt_defbp_num == 1 || kmt_defbp_bpspec == 0) {
1576 1575 if (kmt_defbp_activate(t) < 0)
1577 1576 warn("failed to activate deferred breakpoints");
1578 1577 }
1579 1578
1580 1579 mdb_list_append(&kmt_defbp_list, dbp);
1581 1580
1582 1581 return (dbp);
1583 1582 }
1584 1583
1585 1584 static void
1586 1585 kmt_defbp_destroy(kmt_defbp_t *dbp)
1587 1586 {
1588 1587 mdb_dprintf(MDB_DBG_KMOD, "defbp_destroy %s`%s\n", dbp->dbp_objname,
1589 1588 dbp->dbp_symname);
1590 1589
1591 1590 mdb_list_delete(&kmt_defbp_list, dbp);
1592 1591
1593 1592 strfree(dbp->dbp_objname);
1594 1593 strfree(dbp->dbp_symname);
1595 1594 mdb_free(dbp, sizeof (kmt_defbp_t));
1596 1595 }
1597 1596
1598 1597 static void
1599 1598 kmt_defbp_prune_common(int all)
1600 1599 {
1601 1600 kmt_defbp_t *dbp, *ndbp;
1602 1601
1603 1602 /* We can't remove items from the list while the driver is using it. */
1604 1603 if (kmt_defbp_lock)
1605 1604 return;
1606 1605
1607 1606 for (dbp = mdb_list_next(&kmt_defbp_list); dbp != NULL; dbp = ndbp) {
1608 1607 ndbp = mdb_list_next(dbp);
1609 1608
1610 1609 if (!all && dbp->dbp_ref)
1611 1610 continue;
1612 1611
1613 1612 kmt_defbp_destroy(dbp);
1614 1613 }
1615 1614 }
1616 1615
1617 1616 static void
1618 1617 kmt_defbp_prune(void)
1619 1618 {
1620 1619 kmt_defbp_prune_common(0);
1621 1620 }
1622 1621
1623 1622 static void
1624 1623 kmt_defbp_destroy_all(void)
1625 1624 {
1626 1625 kmt_defbp_prune_common(1);
1627 1626 }
1628 1627
1629 1628 static void
1630 1629 kmt_defbp_delete(mdb_tgt_t *t, kmt_defbp_t *dbp)
1631 1630 {
1632 1631 dbp->dbp_ref = 0;
1633 1632
1634 1633 ASSERT(kmt_defbp_num > 0);
1635 1634 kmt_defbp_num--;
1636 1635
1637 1636 if (kmt_defbp_num == 0)
1638 1637 kmt_defbp_deactivate(t);
1639 1638
1640 1639 kmt_defbp_prune();
1641 1640 }
1642 1641
1643 1642 static int
1644 1643 kmt_brkpt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
1645 1644 {
1646 1645 mdb_tgt_status_t tsp;
1647 1646 kmt_bparg_t *ka = args;
1648 1647 kmt_brkpt_t *kb;
1649 1648 GElf_Sym s;
1650 1649 mdb_instr_t instr;
1651 1650
1652 1651 (void) mdb_tgt_status(t, &tsp);
1653 1652 if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED)
1654 1653 return (set_errno(EMDB_NOPROC));
1655 1654
1656 1655 if (ka->ka_symbol != NULL) {
1657 1656 if (mdb_tgt_lookup_by_scope(t, ka->ka_symbol, &s, NULL) == -1) {
1658 1657 if (errno != EMDB_NOOBJ && !(errno == EMDB_NOSYM &&
1659 1658 !(mdb.m_flags & MDB_FL_BPTNOSYMSTOP))) {
1660 1659 warn("breakpoint %s activation failed",
1661 1660 ka->ka_symbol);
1662 1661 }
1663 1662 return (-1); /* errno is set for us */
1664 1663 }
1665 1664
1666 1665 ka->ka_addr = (uintptr_t)s.st_value;
1667 1666 }
1668 1667
1669 1668 #ifdef __sparc
1670 1669 if (ka->ka_addr & 3)
1671 1670 return (set_errno(EMDB_BPALIGN));
1672 1671 #endif
1673 1672
1674 1673 if (mdb_vread(&instr, sizeof (instr), ka->ka_addr) != sizeof (instr))
1675 1674 return (-1); /* errno is set for us */
1676 1675
1677 1676 if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE)
1678 1677 warn("breakpoint will not arm until DTrace is inactive\n");
1679 1678
1680 1679 kb = mdb_zalloc(sizeof (kmt_brkpt_t), UM_SLEEP);
1681 1680 kb->kb_addr = ka->ka_addr;
1682 1681 sep->se_data = kb;
1683 1682
1684 1683 return (0);
1685 1684 }
1686 1685
1687 1686 /*ARGSUSED*/
1688 1687 static void
1689 1688 kmt_brkpt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep)
1690 1689 {
1691 1690 mdb_free(sep->se_data, sizeof (kmt_brkpt_t));
1692 1691 }
1693 1692
1694 1693 /*ARGSUSED*/
1695 1694 static char *
1696 1695 kmt_brkpt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep,
1697 1696 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes)
1698 1697 {
1699 1698 uintptr_t addr = 0;
1700 1699
1701 1700 if (vep != NULL) {
1702 1701 kmt_bparg_t *ka = vep->ve_args;
1703 1702
1704 1703 if (ka->ka_symbol != NULL) {
1705 1704 (void) mdb_iob_snprintf(buf, nbytes, "stop at %s",
1706 1705 ka->ka_symbol);
1707 1706 } else {
1708 1707 (void) mdb_iob_snprintf(buf, nbytes, "stop at %a",
1709 1708 ka->ka_addr);
1710 1709 addr = ka->ka_addr;
1711 1710 }
1712 1711
1713 1712 } else {
1714 1713 addr = ((kmt_brkpt_t *)sep->se_data)->kb_addr;
1715 1714 (void) mdb_iob_snprintf(buf, nbytes, "stop at %a", addr);
1716 1715 }
1717 1716
1718 1717 sp->spec_base = addr;
1719 1718 sp->spec_size = sizeof (mdb_instr_t);
1720 1719
1721 1720 return (buf);
1722 1721 }
1723 1722
1724 1723 static int
1725 1724 kmt_brkpt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
1726 1725 {
1727 1726 kmt_brkpt_t *kb = sep->se_data;
1728 1727 kmt_bparg_t *ka = args;
1729 1728 GElf_Sym sym;
1730 1729
1731 1730 if (ka->ka_symbol != NULL) {
1732 1731 return (mdb_tgt_lookup_by_scope(t, ka->ka_symbol,
1733 1732 &sym, NULL) == 0 && sym.st_value == kb->kb_addr);
1734 1733 }
1735 1734
1736 1735 return (ka->ka_addr == kb->kb_addr);
1737 1736 }
1738 1737
1739 1738 /*ARGSUSED*/
1740 1739 static int
1741 1740 kmt_brkpt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args)
1742 1741 {
1743 1742 kmt_bparg_t *ka1 = vep->ve_args;
1744 1743 kmt_bparg_t *ka2 = args;
1745 1744
1746 1745 if (ka1->ka_symbol != NULL && ka2->ka_symbol != NULL)
1747 1746 return (strcmp(ka1->ka_symbol, ka2->ka_symbol) == 0);
1748 1747
1749 1748 if (ka1->ka_symbol == NULL && ka2->ka_symbol == NULL)
1750 1749 return (ka1->ka_addr == ka2->ka_addr);
1751 1750
1752 1751 return (0); /* fail if one is symbolic, other is an explicit address */
1753 1752 }
1754 1753
1755 1754 static int
1756 1755 kmt_brkpt_arm(mdb_tgt_t *t, mdb_sespec_t *sep)
1757 1756 {
1758 1757 kmt_data_t *kmt = t->t_data;
1759 1758 kmt_brkpt_t *kb = sep->se_data;
1760 1759 int rv;
1761 1760
1762 1761 if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE)
1763 1762 return (set_errno(EMDB_DTACTIVE));
1764 1763
1765 1764 if ((rv = kmdb_dpi_brkpt_arm(kb->kb_addr, &kb->kb_oinstr)) != 0)
1766 1765 return (rv);
1767 1766
1768 1767 if (kmt->kmt_narmedbpts++ == 0)
1769 1768 (void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_ACTIVATE);
1770 1769
1771 1770 return (0);
1772 1771 }
1773 1772
1774 1773 static int
1775 1774 kmt_brkpt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep)
1776 1775 {
1777 1776 kmt_data_t *kmt = t->t_data;
1778 1777 kmt_brkpt_t *kb = sep->se_data;
1779 1778 int rv;
1780 1779
1781 1780 ASSERT(kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_KMDB_BPT_ACTIVE);
1782 1781
1783 1782 if ((rv = kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr)) != 0)
1784 1783 return (rv);
1785 1784
1786 1785 if (--kmt->kmt_narmedbpts == 0)
1787 1786 (void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_DEACTIVATE);
1788 1787
1789 1788 return (0);
1790 1789 }
1791 1790
1792 1791 /*
1793 1792 * Determine whether the specified sespec is an armed watchpoint that overlaps
1794 1793 * with the given breakpoint and has the given flags set. We use this to find
1795 1794 * conflicts with breakpoints, below.
1796 1795 */
1797 1796 static int
1798 1797 kmt_wp_overlap(mdb_sespec_t *sep, kmt_brkpt_t *kb, int flags)
1799 1798 {
1800 1799 const kmdb_wapt_t *wp = sep->se_data;
1801 1800
1802 1801 return (sep->se_state == MDB_TGT_SPEC_ARMED &&
1803 1802 sep->se_ops == &kmt_wapt_ops && (wp->wp_wflags & flags) &&
1804 1803 kb->kb_addr - wp->wp_addr < wp->wp_size);
1805 1804 }
1806 1805
1807 1806 /*
1808 1807 * We step over breakpoints using our single-stepper. If a conflicting
1809 1808 * watchpoint is present, we must temporarily remove it before stepping over the
1810 1809 * breakpoint so we don't immediately re-trigger the watchpoint. We know the
1811 1810 * watchpoint has already triggered on our trap instruction as part of fetching
1812 1811 * it. Before we return, we must re-install any disabled watchpoints.
1813 1812 */
1814 1813 static int
1815 1814 kmt_brkpt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
1816 1815 {
1817 1816 kmt_brkpt_t *kb = sep->se_data;
1818 1817 int status = -1;
1819 1818 int error;
1820 1819
1821 1820 for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) {
1822 1821 if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X))
1823 1822 (void) kmdb_dpi_wapt_disarm(sep->se_data);
1824 1823 }
1825 1824
1826 1825 if (kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr) == 0 &&
1827 1826 kmt_step(t, tsp) == 0)
1828 1827 status = kmt_status(t, tsp);
1829 1828
1830 1829 error = errno; /* save errno from disarm, step, or status */
1831 1830
1832 1831 for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) {
1833 1832 if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X))
1834 1833 kmdb_dpi_wapt_arm(sep->se_data);
1835 1834 }
1836 1835
1837 1836 (void) set_errno(error);
1838 1837 return (status);
1839 1838 }
1840 1839
1841 1840 /*ARGSUSED*/
1842 1841 static int
1843 1842 kmt_brkpt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
1844 1843 {
1845 1844 kmt_brkpt_t *kb = sep->se_data;
1846 1845 int state, why;
1847 1846 kreg_t pc;
1848 1847
1849 1848 state = kmdb_dpi_get_state(&why);
1850 1849 (void) kmdb_dpi_get_register("pc", &pc);
1851 1850
1852 1851 return (state == DPI_STATE_FAULTED && why == DPI_STATE_WHY_BKPT &&
1853 1852 pc == kb->kb_addr);
1854 1853 }
1855 1854
1856 1855 static const mdb_se_ops_t kmt_brkpt_ops = {
1857 1856 kmt_brkpt_ctor, /* se_ctor */
1858 1857 kmt_brkpt_dtor, /* se_dtor */
1859 1858 kmt_brkpt_info, /* se_info */
1860 1859 kmt_brkpt_secmp, /* se_secmp */
1861 1860 kmt_brkpt_vecmp, /* se_vecmp */
1862 1861 kmt_brkpt_arm, /* se_arm */
1863 1862 kmt_brkpt_disarm, /* se_disarm */
1864 1863 kmt_brkpt_cont, /* se_cont */
1865 1864 kmt_brkpt_match /* se_match */
1866 1865 };
1867 1866
1868 1867 static int
1869 1868 kmt_wapt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
1870 1869 {
1871 1870 mdb_tgt_status_t tsp;
1872 1871 kmdb_wapt_t *vwp = args;
1873 1872 kmdb_wapt_t *swp;
1874 1873
1875 1874 (void) mdb_tgt_status(t, &tsp);
1876 1875 if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED)
1877 1876 return (set_errno(EMDB_NOPROC));
1878 1877
1879 1878 swp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP);
1880 1879 bcopy(vwp, swp, sizeof (kmdb_wapt_t));
1881 1880
1882 1881 if (kmdb_dpi_wapt_reserve(swp) < 0) {
1883 1882 mdb_free(swp, sizeof (kmdb_wapt_t));
1884 1883 return (-1); /* errno is set for us */
1885 1884 }
1886 1885
1887 1886 sep->se_data = swp;
1888 1887
1889 1888 return (0);
1890 1889 }
1891 1890
1892 1891 /*ARGSUSED*/
1893 1892 static void
1894 1893 kmt_wapt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep)
1895 1894 {
1896 1895 kmdb_wapt_t *wp = sep->se_data;
1897 1896
1898 1897 kmdb_dpi_wapt_release(wp);
1899 1898 mdb_free(wp, sizeof (kmdb_wapt_t));
1900 1899 }
1901 1900
1902 1901 /*ARGSUSED*/
1903 1902 static char *
1904 1903 kmt_wapt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep,
1905 1904 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes)
1906 1905 {
1907 1906 kmdb_wapt_t *wp = vep != NULL ? vep->ve_args : sep->se_data;
1908 1907 const char *fmt;
1909 1908 char desc[24];
1910 1909
1911 1910 ASSERT(wp->wp_wflags != 0);
1912 1911 desc[0] = '\0';
1913 1912
1914 1913 switch (wp->wp_wflags) {
1915 1914 case MDB_TGT_WA_R:
1916 1915 (void) strcat(desc, "/read");
1917 1916 break;
1918 1917 case MDB_TGT_WA_W:
1919 1918 (void) strcat(desc, "/write");
1920 1919 break;
1921 1920 case MDB_TGT_WA_X:
1922 1921 (void) strcat(desc, "/exec");
1923 1922 break;
1924 1923 default:
1925 1924 if (wp->wp_wflags & MDB_TGT_WA_R)
1926 1925 (void) strcat(desc, "/r");
1927 1926 if (wp->wp_wflags & MDB_TGT_WA_W)
1928 1927 (void) strcat(desc, "/w");
1929 1928 if (wp->wp_wflags & MDB_TGT_WA_X)
1930 1929 (void) strcat(desc, "/x");
1931 1930 }
1932 1931
1933 1932 switch (wp->wp_type) {
1934 1933 case DPI_WAPT_TYPE_PHYS:
1935 1934 fmt = "stop on %s of phys [%p, %p)";
1936 1935 break;
1937 1936
1938 1937 case DPI_WAPT_TYPE_VIRT:
1939 1938 fmt = "stop on %s of [%la, %la)";
1940 1939 break;
1941 1940
1942 1941 case DPI_WAPT_TYPE_IO:
1943 1942 if (wp->wp_size == 1)
1944 1943 fmt = "stop on %s of I/O port %p";
1945 1944 else
1946 1945 fmt = "stop on %s of I/O port [%p, %p)";
1947 1946 break;
1948 1947 }
1949 1948
1950 1949 (void) mdb_iob_snprintf(buf, nbytes, fmt, desc + 1, wp->wp_addr,
1951 1950 wp->wp_addr + wp->wp_size);
1952 1951
1953 1952 sp->spec_base = wp->wp_addr;
1954 1953 sp->spec_size = wp->wp_size;
1955 1954
1956 1955 return (buf);
1957 1956 }
1958 1957
1959 1958 /*ARGSUSED*/
1960 1959 static int
1961 1960 kmt_wapt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
1962 1961 {
1963 1962 kmdb_wapt_t *wp1 = sep->se_data;
1964 1963 kmdb_wapt_t *wp2 = args;
1965 1964
1966 1965 return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size &&
1967 1966 wp1->wp_wflags == wp2->wp_wflags);
1968 1967 }
1969 1968
1970 1969 /*ARGSUSED*/
1971 1970 static int
1972 1971 kmt_wapt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args)
1973 1972 {
1974 1973 kmdb_wapt_t *wp1 = vep->ve_args;
1975 1974 kmdb_wapt_t *wp2 = args;
1976 1975
1977 1976 return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size &&
1978 1977 wp1->wp_wflags == wp2->wp_wflags);
1979 1978 }
1980 1979
1981 1980 /*ARGSUSED*/
1982 1981 static int
1983 1982 kmt_wapt_arm(mdb_tgt_t *t, mdb_sespec_t *sep)
1984 1983 {
1985 1984 kmdb_dpi_wapt_arm(sep->se_data);
1986 1985
1987 1986 return (0);
1988 1987 }
1989 1988
1990 1989 /*ARGSUSED*/
1991 1990 static int
1992 1991 kmt_wapt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep)
1993 1992 {
1994 1993 kmdb_dpi_wapt_disarm(sep->se_data);
1995 1994
1996 1995 return (0);
1997 1996 }
1998 1997
1999 1998 /*
2000 1999 * Determine whether the specified sespec is an armed breakpoint at the given
2001 2000 * %pc. We use this to find conflicts with watchpoints below.
2002 2001 */
2003 2002 static int
2004 2003 kmt_bp_overlap(mdb_sespec_t *sep, uintptr_t pc)
2005 2004 {
2006 2005 kmt_brkpt_t *kb = sep->se_data;
2007 2006
2008 2007 return (sep->se_state == MDB_TGT_SPEC_ARMED &&
2009 2008 sep->se_ops == &kmt_brkpt_ops && kb->kb_addr == pc);
2010 2009 }
2011 2010
2012 2011 /*
2013 2012 * We step over watchpoints using our single-stepper. If a conflicting
2014 2013 * breakpoint is present, we must temporarily disarm it before stepping over
2015 2014 * the watchpoint so we do not immediately re-trigger the breakpoint. This is
2016 2015 * similar to the case handled in kmt_brkpt_cont(), above.
2017 2016 */
2018 2017 static int
2019 2018 kmt_wapt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
2020 2019 {
2021 2020 mdb_sespec_t *bep = NULL;
2022 2021 int status = -1;
2023 2022 int error, why;
2024 2023
2025 2024 /*
2026 2025 * If we stopped for anything other than a watchpoint, check to see
2027 2026 * if there's a breakpoint here.
2028 2027 */
2029 2028 if (!(kmdb_dpi_get_state(&why) == DPI_STATE_FAULTED &&
2030 2029 (why == DPI_STATE_WHY_V_WAPT || why == DPI_STATE_WHY_P_WAPT))) {
2031 2030 kreg_t pc;
2032 2031
2033 2032 (void) kmdb_dpi_get_register("pc", &pc);
2034 2033
2035 2034 for (bep = mdb_list_next(&t->t_active); bep != NULL;
2036 2035 bep = mdb_list_next(bep)) {
2037 2036 if (kmt_bp_overlap(bep, pc)) {
2038 2037 (void) bep->se_ops->se_disarm(t, bep);
2039 2038 bep->se_state = MDB_TGT_SPEC_ACTIVE;
2040 2039 break;
2041 2040 }
2042 2041 }
2043 2042 }
2044 2043
2045 2044 kmdb_dpi_wapt_disarm(sep->se_data);
2046 2045 if (kmt_step(t, tsp) == 0)
2047 2046 status = kmt_status(t, tsp);
2048 2047
2049 2048 error = errno; /* save errno from step or status */
2050 2049
2051 2050 if (bep != NULL)
2052 2051 mdb_tgt_sespec_arm_one(t, bep);
2053 2052
2054 2053 (void) set_errno(error);
2055 2054 return (status);
2056 2055 }
2057 2056
2058 2057 /*ARGSUSED*/
2059 2058 static int
2060 2059 kmt_wapt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
2061 2060 {
2062 2061 return (kmdb_dpi_wapt_match(sep->se_data));
2063 2062 }
2064 2063
2065 2064 static const mdb_se_ops_t kmt_wapt_ops = {
2066 2065 kmt_wapt_ctor, /* se_ctor */
2067 2066 kmt_wapt_dtor, /* se_dtor */
2068 2067 kmt_wapt_info, /* se_info */
2069 2068 kmt_wapt_secmp, /* se_secmp */
2070 2069 kmt_wapt_vecmp, /* se_vecmp */
2071 2070 kmt_wapt_arm, /* se_arm */
2072 2071 kmt_wapt_disarm, /* se_disarm */
2073 2072 kmt_wapt_cont, /* se_cont */
2074 2073 kmt_wapt_match /* se_match */
2075 2074 };
2076 2075
2077 2076 /*ARGSUSED*/
2078 2077 static int
2079 2078 kmt_trap_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
2080 2079 {
2081 2080 sep->se_data = args; /* trap number */
2082 2081
2083 2082 return (0);
2084 2083 }
2085 2084
2086 2085 /*ARGSUSED*/
2087 2086 static char *
2088 2087 kmt_trap_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep,
2089 2088 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes)
2090 2089 {
2091 2090 const char *name;
2092 2091 int trapnum;
2093 2092
2094 2093 if (vep != NULL)
2095 2094 trapnum = (intptr_t)vep->ve_args;
2096 2095 else
2097 2096 trapnum = (intptr_t)sep->se_data;
2098 2097
2099 2098 if (trapnum == KMT_TRAP_ALL)
2100 2099 name = "any trap";
2101 2100 else if (trapnum == KMT_TRAP_NOTENUM)
2102 2101 name = "miscellaneous trap";
2103 2102 else
2104 2103 name = kmt_trapname(trapnum);
2105 2104
2106 2105 (void) mdb_iob_snprintf(buf, nbytes, "single-step stop on %s", name);
2107 2106
2108 2107 return (buf);
2109 2108 }
2110 2109
2111 2110 /*ARGSUSED2*/
2112 2111 static int
2113 2112 kmt_trap_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
2114 2113 {
2115 2114 int spectt = (intptr_t)sep->se_data;
2116 2115 kmt_data_t *kmt = t->t_data;
2117 2116 kreg_t tt;
2118 2117
2119 2118 (void) kmdb_dpi_get_register("tt", &tt);
2120 2119
2121 2120 switch (spectt) {
2122 2121 case KMT_TRAP_ALL:
2123 2122 return (1);
2124 2123 case KMT_TRAP_NOTENUM:
2125 2124 return (tt > kmt->kmt_trapmax ||
2126 2125 !BT_TEST(kmt->kmt_trapmap, tt));
2127 2126 default:
2128 2127 return (tt == spectt);
2129 2128 }
2130 2129 }
2131 2130
2132 2131 static const mdb_se_ops_t kmt_trap_ops = {
2133 2132 kmt_trap_ctor, /* se_ctor */
2134 2133 no_se_dtor, /* se_dtor */
2135 2134 kmt_trap_info, /* se_info */
2136 2135 no_se_secmp, /* se_secmp */
2137 2136 no_se_vecmp, /* se_vecmp */
2138 2137 no_se_arm, /* se_arm */
2139 2138 no_se_disarm, /* se_disarm */
2140 2139 no_se_cont, /* se_cont */
2141 2140 kmt_trap_match /* se_match */
2142 2141 };
2143 2142
2144 2143 static void
2145 2144 kmt_bparg_dtor(mdb_vespec_t *vep)
2146 2145 {
2147 2146 kmt_bparg_t *ka = vep->ve_args;
2148 2147
2149 2148 if (ka->ka_symbol != NULL)
2150 2149 strfree(ka->ka_symbol);
2151 2150
2152 2151 if (ka->ka_defbp != NULL)
2153 2152 kmt_defbp_delete(mdb.m_target, ka->ka_defbp);
2154 2153
2155 2154 mdb_free(ka, sizeof (kmt_bparg_t));
2156 2155 }
2157 2156
2158 2157 static int
2159 2158 kmt_add_vbrkpt(mdb_tgt_t *t, uintptr_t addr,
2160 2159 int spec_flags, mdb_tgt_se_f *func, void *data)
2161 2160 {
2162 2161 kmt_bparg_t *ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP);
2163 2162
2164 2163 ka->ka_addr = addr;
2165 2164 ka->ka_symbol = NULL;
2166 2165 ka->ka_defbp = NULL;
2167 2166
2168 2167 return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags,
2169 2168 func, data, ka, kmt_bparg_dtor));
2170 2169 }
2171 2170
2172 2171 static int
2173 2172 kmt_add_sbrkpt(mdb_tgt_t *t, const char *fullname,
2174 2173 int spec_flags, mdb_tgt_se_f *func, void *data)
2175 2174 {
2176 2175 kmt_bparg_t *ka;
2177 2176 kmt_defbp_t *dbp;
2178 2177 GElf_Sym sym;
2179 2178 char *tick, *objname, *symname;
2180 2179 int serrno;
2181 2180
2182 2181 if ((tick = strchr(fullname, '`')) == fullname) {
2183 2182 (void) set_errno(EMDB_NOOBJ);
2184 2183 return (0);
2185 2184 }
2186 2185
2187 2186 /*
2188 2187 * Deferred breakpoints are always scoped. If we didn't find a tick,
2189 2188 * there's no scope. We'll create a vbrkpt, but only if we can turn the
2190 2189 * provided string into an address.
2191 2190 */
2192 2191 if (tick == NULL) {
2193 2192 uintptr_t addr;
2194 2193
2195 2194 if (strisbasenum(fullname)) {
2196 2195 addr = mdb_strtoull(fullname); /* a bare address */
2197 2196 } else if (mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EVERY,
2198 2197 fullname, &sym, NULL) < 0) {
2199 2198 (void) set_errno(EMDB_NOSYM);
2200 2199 return (0);
2201 2200 } else {
2202 2201 addr = (uintptr_t)sym.st_value; /* unscoped sym name */
2203 2202 }
2204 2203
2205 2204 return (kmt_add_vbrkpt(t, addr, spec_flags, func, data));
2206 2205 }
2207 2206
2208 2207 if (*(tick + 1) == '\0') {
2209 2208 (void) set_errno(EMDB_NOSYM);
2210 2209 return (0);
2211 2210 }
2212 2211
2213 2212 objname = strndup(fullname, tick - fullname);
2214 2213 symname = tick + 1;
2215 2214
2216 2215 if (mdb_tgt_lookup_by_name(t, objname, symname, NULL, NULL) < 0 &&
2217 2216 errno != EMDB_NOOBJ) {
2218 2217 serrno = errno;
2219 2218 strfree(objname);
2220 2219
2221 2220 (void) set_errno(serrno);
2222 2221 return (0); /* errno is set for us */
2223 2222 }
2224 2223
2225 2224 dbp = kmt_defbp_create(t, objname, symname);
2226 2225 strfree(objname);
2227 2226
2228 2227 ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP);
2229 2228 ka->ka_symbol = strdup(fullname);
2230 2229 ka->ka_addr = 0;
2231 2230 ka->ka_defbp = dbp;
2232 2231
2233 2232 return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags,
2234 2233 func, data, ka, kmt_bparg_dtor));
2235 2234 }
2236 2235
2237 2236 static int
2238 2237 kmt_wparg_overlap(const kmdb_wapt_t *wp1, const kmdb_wapt_t *wp2)
2239 2238 {
2240 2239 /* Assume the watchpoint spaces don't overlap */
2241 2240 if (wp1->wp_type != wp2->wp_type)
2242 2241 return (0);
2243 2242
2244 2243 if (wp2->wp_addr + wp2->wp_size <= wp1->wp_addr)
2245 2244 return (0); /* no range overlap */
2246 2245
2247 2246 if (wp1->wp_addr + wp1->wp_size <= wp2->wp_addr)
2248 2247 return (0); /* no range overlap */
2249 2248
2250 2249 return (wp1->wp_addr != wp2->wp_addr || wp1->wp_size != wp2->wp_size ||
2251 2250 wp1->wp_wflags != wp2->wp_wflags);
2252 2251 }
2253 2252
2254 2253 static void
2255 2254 kmt_wparg_dtor(mdb_vespec_t *vep)
2256 2255 {
2257 2256 mdb_free(vep->ve_args, sizeof (kmdb_wapt_t));
2258 2257 }
2259 2258
2260 2259 static int
2261 2260 kmt_add_wapt_common(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags,
2262 2261 int spec_flags, mdb_tgt_se_f *func, void *data, int type)
2263 2262 {
2264 2263 kmdb_wapt_t *wp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP);
2265 2264 mdb_sespec_t *sep;
2266 2265
2267 2266 wp->wp_addr = addr;
2268 2267 wp->wp_size = len;
2269 2268 wp->wp_type = type;
2270 2269 wp->wp_wflags = wflags;
2271 2270
2272 2271 if (kmdb_dpi_wapt_validate(wp) < 0)
2273 2272 return (0); /* errno is set for us */
2274 2273
2275 2274 for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) {
2276 2275 if (sep->se_ops == &kmt_wapt_ops &&
2277 2276 mdb_list_next(&sep->se_velist) != NULL &&
2278 2277 kmt_wparg_overlap(wp, sep->se_data))
2279 2278 goto wapt_dup;
2280 2279 }
2281 2280
2282 2281 for (sep = mdb_list_next(&t->t_idle); sep; sep = mdb_list_next(sep)) {
2283 2282 if (sep->se_ops == &kmt_wapt_ops && kmt_wparg_overlap(wp,
2284 2283 ((mdb_vespec_t *)mdb_list_next(&sep->se_velist))->ve_args))
2285 2284 goto wapt_dup;
2286 2285 }
2287 2286
2288 2287 return (mdb_tgt_vespec_insert(t, &kmt_wapt_ops, spec_flags,
2289 2288 func, data, wp, kmt_wparg_dtor));
2290 2289
2291 2290 wapt_dup:
2292 2291 mdb_free(wp, sizeof (kmdb_wapt_t));
2293 2292 (void) set_errno(EMDB_WPDUP);
2294 2293 return (0);
2295 2294 }
2296 2295
2297 2296 static int
2298 2297 kmt_add_pwapt(mdb_tgt_t *t, physaddr_t addr, size_t len, uint_t wflags,
2299 2298 int spec_flags, mdb_tgt_se_f *func, void *data)
2300 2299 {
2301 2300 return (kmt_add_wapt_common(t, (uintptr_t)addr, len, wflags, spec_flags,
2302 2301 func, data, DPI_WAPT_TYPE_PHYS));
2303 2302 }
2304 2303
2305 2304 static int
2306 2305 kmt_add_vwapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags,
2307 2306 int spec_flags, mdb_tgt_se_f *func, void *data)
2308 2307 {
2309 2308 return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func,
2310 2309 data, DPI_WAPT_TYPE_VIRT));
2311 2310 }
2312 2311
2313 2312 static int
2314 2313 kmt_add_iowapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags,
2315 2314 int spec_flags, mdb_tgt_se_f *func, void *data)
2316 2315 {
2317 2316 return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func,
2318 2317 data, DPI_WAPT_TYPE_IO));
2319 2318 }
2320 2319
2321 2320 static int
2322 2321 kmt_add_trap(mdb_tgt_t *t, int trapnum, int spec_flags, mdb_tgt_se_f *func,
2323 2322 void *data)
2324 2323 {
2325 2324 kmt_data_t *kmt = t->t_data;
2326 2325
2327 2326 if (trapnum != KMT_TRAP_ALL && trapnum != KMT_TRAP_NOTENUM) {
2328 2327 if (trapnum < 0 || trapnum > kmt->kmt_trapmax) {
2329 2328 (void) set_errno(EMDB_BADFLTNUM);
2330 2329 return (0);
2331 2330 }
2332 2331
2333 2332 BT_SET(kmt->kmt_trapmap, trapnum);
2334 2333 }
2335 2334
2336 2335 return (mdb_tgt_vespec_insert(t, &kmt_trap_ops, spec_flags, func, data,
2337 2336 (void *)(uintptr_t)trapnum, no_ve_dtor));
2338 2337 }
2339 2338
2340 2339 /*ARGSUSED*/
2341 2340 static uintmax_t
2342 2341 kmt_cpuid_disc_get(const mdb_var_t *v)
2343 2342 {
2344 2343 return (kmdb_dpi_get_master_cpuid());
2345 2344 }
2346 2345
2347 2346 static const mdb_nv_disc_t kmt_cpuid_disc = {
2348 2347 NULL,
2349 2348 kmt_cpuid_disc_get
2350 2349 };
2351 2350
2352 2351 /*
2353 2352 * This routine executes while the kernel is running.
2354 2353 */
2355 2354 void
2356 2355 kmt_activate(mdb_tgt_t *t)
2357 2356 {
2358 2357 kmt_data_t *kmt = t->t_data;
2359 2358
2360 2359 mdb_prop_postmortem = FALSE;
2361 2360 mdb_prop_kernel = TRUE;
2362 2361
2363 2362 (void) mdb_tgt_register_dcmds(t, &kmt_dcmds[0], MDB_MOD_FORCE);
2364 2363 mdb_tgt_register_regvars(t, kmt->kmt_rds, &kmt_reg_disc, 0);
2365 2364
2366 2365 /*
2367 2366 * Force load of the MDB krtld module, in case it's been rolled into
2368 2367 * unix.
2369 2368 */
2370 2369 (void) mdb_module_load(KMT_RTLD_NAME, MDB_MOD_SILENT | MDB_MOD_DEFER);
2371 2370 }
2372 2371
2373 2372 static void
2374 2373 kmt_destroy(mdb_tgt_t *t)
2375 2374 {
2376 2375 kmt_data_t *kmt = t->t_data;
2377 2376 kmt_module_t *km, *pkm;
2378 2377
2379 2378 mdb_nv_destroy(&kmt->kmt_modules);
2380 2379 for (km = mdb_list_prev(&kmt->kmt_modlist); km != NULL; km = pkm) {
2381 2380 pkm = mdb_list_prev(km);
2382 2381 mdb_free(km, sizeof (kmt_module_t));
2383 2382 }
2384 2383
2385 2384 if (!kmt_defbp_lock)
2386 2385 kmt_defbp_destroy_all();
2387 2386
2388 2387 if (kmt->kmt_trapmap != NULL)
2389 2388 mdb_free(kmt->kmt_trapmap, BT_SIZEOFMAP(kmt->kmt_trapmax));
2390 2389
2391 2390 mdb_free(kmt, sizeof (kmt_data_t));
2392 2391 }
2393 2392
2394 2393 static const mdb_tgt_ops_t kmt_ops = {
2395 2394 kmt_setflags, /* t_setflags */
2396 2395 (int (*)()) mdb_tgt_notsup, /* t_setcontext */
2397 2396 kmt_activate, /* t_activate */
2398 2397 (void (*)()) mdb_tgt_nop, /* t_deactivate */
2399 2398 kmt_periodic, /* t_periodic */
2400 2399 kmt_destroy, /* t_destroy */
2401 2400 kmt_name, /* t_name */
2402 2401 (const char *(*)()) mdb_conf_isa, /* t_isa */
2403 2402 kmt_platform, /* t_platform */
2404 2403 kmt_uname, /* t_uname */
2405 2404 kmt_dmodel, /* t_dmodel */
2406 2405 (ssize_t (*)()) mdb_tgt_notsup, /* t_aread */
2407 2406 (ssize_t (*)()) mdb_tgt_notsup, /* t_awrite */
2408 2407 kmt_read, /* t_vread */
2409 2408 kmt_write, /* t_vwrite */
2410 2409 kmt_pread, /* t_pread */
2411 2410 kmt_pwrite, /* t_pwrite */
2412 2411 kmt_read, /* t_fread */
2413 2412 kmt_write, /* t_fwrite */
2414 2413 kmt_ioread, /* t_ioread */
2415 2414 kmt_iowrite, /* t_iowrite */
2416 2415 kmt_vtop, /* t_vtop */
2417 2416 kmt_lookup_by_name, /* t_lookup_by_name */
2418 2417 kmt_lookup_by_addr, /* t_lookup_by_addr */
2419 2418 kmt_symbol_iter, /* t_symbol_iter */
2420 2419 kmt_mapping_iter, /* t_mapping_iter */
2421 2420 kmt_object_iter, /* t_object_iter */
2422 2421 kmt_addr_to_map, /* t_addr_to_map */
2423 2422 kmt_name_to_map, /* t_name_to_map */
2424 2423 kmt_addr_to_ctf, /* t_addr_to_ctf */
2425 2424 kmt_name_to_ctf, /* t_name_to_ctf */
2426 2425 kmt_status, /* t_status */
2427 2426 (int (*)()) mdb_tgt_notsup, /* t_run */
2428 2427 kmt_step, /* t_step */
2429 2428 kmt_step_out, /* t_step_out */
2430 2429 kmt_next, /* t_next */
2431 2430 kmt_continue, /* t_cont */
2432 2431 (int (*)()) mdb_tgt_notsup, /* t_signal */
2433 2432 kmt_add_vbrkpt, /* t_add_vbrkpt */
2434 2433 kmt_add_sbrkpt, /* t_add_sbrkpt */
2435 2434 kmt_add_pwapt, /* t_add_pwapt */
2436 2435 kmt_add_vwapt, /* t_add_vwapt */
2437 2436 kmt_add_iowapt, /* t_add_iowapt */
2438 2437 (int (*)()) mdb_tgt_null, /* t_add_sysenter */
2439 2438 (int (*)()) mdb_tgt_null, /* t_add_sysexit */
2440 2439 (int (*)()) mdb_tgt_null, /* t_add_signal */
2441 2440 kmt_add_trap, /* t_add_fault */
2442 2441 kmt_getareg, /* t_getareg */
2443 2442 kmt_putareg, /* t_putareg */
2444 2443 (int (*)()) mdb_tgt_nop, /* XXX t_stack_iter */
2445 2444 (int (*)()) mdb_tgt_notsup /* t_auxv */
2446 2445 };
2447 2446
2448 2447 /*
2449 2448 * Called immediately upon resumption of the system after a step or continue.
2450 2449 * Allows us to synchronize kmt's view of the world with reality.
2451 2450 */
2452 2451 /*ARGSUSED*/
2453 2452 static void
2454 2453 kmt_sync(mdb_tgt_t *t)
2455 2454 {
2456 2455 kmt_data_t *kmt = t->t_data;
2457 2456 int symavail;
2458 2457
2459 2458 mdb_dprintf(MDB_DBG_KMOD, "synchronizing with kernel\n");
2460 2459
2461 2460 symavail = kmt->kmt_symavail;
2462 2461 kmt->kmt_symavail = FALSE;
2463 2462
2464 2463 /*
2465 2464 * Resync our view of the world if the modules have changed, or if we
2466 2465 * didn't have any symbols coming into this function. The latter will
2467 2466 * only happen on startup.
2468 2467 */
2469 2468 if (kmdb_kdi_mods_changed() || !symavail)
2470 2469 kmt_modlist_update(t);
2471 2470
2472 2471 /*
2473 2472 * It would be nice if we could run this less frequently, perhaps
2474 2473 * after a dvec-initiated trigger.
2475 2474 */
2476 2475 kmdb_module_sync();
2477 2476
2478 2477 kmt->kmt_symavail = TRUE;
2479 2478
2480 2479 mdb_dprintf(MDB_DBG_KMOD, "synchronization complete\n");
2481 2480
2482 2481 kmt_defbp_prune();
2483 2482
2484 2483 if (kmt_defbp_num > 0 && kmt_defbp_bpspec == 0 &&
2485 2484 kmdb_kdi_dtrace_get_state() != KDI_DTSTATE_DTRACE_ACTIVE) {
2486 2485 /*
2487 2486 * Deferred breakpoints were created while DTrace was active,
2488 2487 * and consequently the deferred breakpoint enabling mechanism
2489 2488 * wasn't activated. Activate it now, and then try to activate
2490 2489 * the deferred breakpoints. We do this so that we can catch
2491 2490 * the ones which may apply to modules that have been loaded
2492 2491 * while they were waiting for DTrace to deactivate.
2493 2492 */
2494 2493 (void) kmt_defbp_activate(t);
2495 2494 (void) mdb_tgt_sespec_activate_all(t);
2496 2495 }
2497 2496
2498 2497 (void) mdb_tgt_status(t, &t->t_status);
2499 2498 }
2500 2499
2501 2500 /*
2502 2501 * This routine executes while the kernel is running.
2503 2502 */
2504 2503 /*ARGSUSED*/
2505 2504 int
2506 2505 kmdb_kvm_create(mdb_tgt_t *t, int argc, const char *argv[])
2507 2506 {
2508 2507 kmt_data_t *kmt;
2509 2508
2510 2509 if (argc != 0)
2511 2510 return (set_errno(EINVAL));
2512 2511
2513 2512 kmt = mdb_zalloc(sizeof (kmt_data_t), UM_SLEEP);
2514 2513 t->t_data = kmt;
2515 2514 t->t_ops = &kmt_ops;
2516 2515 t->t_flags |= MDB_TGT_F_RDWR; /* kmdb is always r/w */
2517 2516
2518 2517 (void) mdb_nv_insert(&mdb.m_nv, "cpuid", &kmt_cpuid_disc, 0,
2519 2518 MDB_NV_PERSIST | MDB_NV_RDONLY);
2520 2519
2521 2520 (void) mdb_nv_create(&kmt->kmt_modules, UM_SLEEP);
2522 2521
2523 2522 kmt_init_isadep(t);
2524 2523
2525 2524 kmt->kmt_symavail = FALSE;
2526 2525
2527 2526 bzero(&kmt_defbp_list, sizeof (mdb_list_t));
2528 2527
2529 2528 return (0);
2530 2529
2531 2530 create_err:
2532 2531 kmt_destroy(t);
2533 2532
2534 2533 return (-1);
2535 2534 }
2536 2535
2537 2536 /*
2538 2537 * This routine is called once, when kmdb first has control of the world.
2539 2538 */
2540 2539 void
2541 2540 kmdb_kvm_startup(void)
2542 2541 {
2543 2542 kmt_data_t *kmt = mdb.m_target->t_data;
2544 2543
2545 2544 mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm startup\n");
2546 2545
2547 2546 kmt_sync(mdb.m_target);
2548 2547 (void) mdb_module_load_builtin(KMT_MODULE);
2549 2548 kmt_startup_isadep(mdb.m_target);
2550 2549
2551 2550 /*
2552 2551 * This is here because we need to write the deferred breakpoint
2553 2552 * breakpoint when the debugger starts. Our normal r/o write routines
2554 2553 * don't work when the kernel is running, so we have to do it during
2555 2554 * startup.
2556 2555 */
2557 2556 (void) mdb_tgt_sespec_activate_all(mdb.m_target);
2558 2557
2559 2558 kmt->kmt_rtld_name = KMT_RTLD_NAME;
2560 2559
2561 2560 if (kmt_module_by_name(kmt, KMT_RTLD_NAME) == NULL)
2562 2561 kmt->kmt_rtld_name = "unix";
2563 2562 }
2564 2563
2565 2564 /*
2566 2565 * This routine is called after kmdb has loaded its initial set of modules.
2567 2566 */
2568 2567 void
2569 2568 kmdb_kvm_poststartup(void)
2570 2569 {
2571 2570 mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm post-startup\n");
2572 2571
2573 2572 (void) mdb_dis_select(kmt_def_dismode());
2574 2573 }
|
↓ open down ↓ |
1984 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX