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