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