xref: /illumos-gate/usr/src/cmd/mdb/common/kmdb/kmdb_kvm.c (revision 0c1b95be)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5ae115bc7Smrj  * Common Development and Distribution License (the "License").
6ae115bc7Smrj  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
22f6e214c7SGavin Maltby  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
23982e63f0SJeremy Jones  * Copyright (c) 2013 by Delphix. All rights reserved.
24399ca3a7SJohn Levon  *
258eb8717cSJohn Levon  * Copyright 2019 Joyent, Inc.
26a48fdbefSBryan Cantrill  * Copyright 2024 Oxide Computer Company
277c478bd9Sstevel@tonic-gate  */
287c478bd9Sstevel@tonic-gate 
297c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_kvm.h>
307c478bd9Sstevel@tonic-gate #include <kmdb/kvm.h>
317c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_kdi.h>
327c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_promif.h>
337c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_module.h>
347c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_asmutil.h>
357c478bd9Sstevel@tonic-gate #include <mdb/mdb_types.h>
367c478bd9Sstevel@tonic-gate #include <mdb/mdb_conf.h>
377c478bd9Sstevel@tonic-gate #include <mdb/mdb_err.h>
387c478bd9Sstevel@tonic-gate #include <mdb/mdb_modapi.h>
397c478bd9Sstevel@tonic-gate #include <mdb/mdb_target_impl.h>
407c478bd9Sstevel@tonic-gate #include <mdb/mdb_debug.h>
417c478bd9Sstevel@tonic-gate #include <mdb/mdb_string.h>
427c478bd9Sstevel@tonic-gate #include <mdb/mdb_ctf.h>
437c478bd9Sstevel@tonic-gate #include <mdb/mdb_kreg_impl.h>
44acbc304dSjohnlev #include <mdb/mdb_ks.h>
457c478bd9Sstevel@tonic-gate #include <mdb/mdb.h>
467c478bd9Sstevel@tonic-gate 
477c478bd9Sstevel@tonic-gate #include <strings.h>
487c478bd9Sstevel@tonic-gate #include <dlfcn.h>
497c478bd9Sstevel@tonic-gate #include <sys/isa_defs.h>
507c478bd9Sstevel@tonic-gate #include <sys/kobj.h>
517c478bd9Sstevel@tonic-gate #include <sys/kobj_impl.h>
527c478bd9Sstevel@tonic-gate #include <sys/bitmap.h>
538eb8717cSJohn Levon #include <sys/uuid.h>
547c478bd9Sstevel@tonic-gate #include <vm/as.h>
557c478bd9Sstevel@tonic-gate 
567c478bd9Sstevel@tonic-gate static const char KMT_RTLD_NAME[] = "krtld";
577c478bd9Sstevel@tonic-gate static const char KMT_MODULE[] = "mdb_ks";
587c478bd9Sstevel@tonic-gate static const char KMT_CTFPARENT[] = "genunix";
597c478bd9Sstevel@tonic-gate 
607c478bd9Sstevel@tonic-gate static mdb_list_t kmt_defbp_list;	/* List of current deferred bp's */
617c478bd9Sstevel@tonic-gate static int kmt_defbp_lock;		/* For list, running kernel holds */
627c478bd9Sstevel@tonic-gate static uint_t kmt_defbp_modchg_isload;	/* Whether mod change is load/unload */
637c478bd9Sstevel@tonic-gate static struct modctl *kmt_defbp_modchg_modctl; /* modctl for defbp checking */
647c478bd9Sstevel@tonic-gate static uint_t kmt_defbp_num;		/* Number of referenced def'd bp's */
657c478bd9Sstevel@tonic-gate static int kmt_defbp_bpspec;		/* vespec for def'd bp activation bp */
667c478bd9Sstevel@tonic-gate 
677c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_brkpt_ops;
687c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_wapt_ops;
697c478bd9Sstevel@tonic-gate 
707c478bd9Sstevel@tonic-gate static void kmt_sync(mdb_tgt_t *);
717c478bd9Sstevel@tonic-gate 
727c478bd9Sstevel@tonic-gate typedef struct kmt_symarg {
737c478bd9Sstevel@tonic-gate 	mdb_tgt_sym_f *sym_cb;		/* Caller's callback function */
747c478bd9Sstevel@tonic-gate 	void *sym_data;			/* Callback function argument */
757c478bd9Sstevel@tonic-gate 	uint_t sym_type;		/* Symbol type/binding filter */
767c478bd9Sstevel@tonic-gate 	mdb_syminfo_t sym_info;		/* Symbol id and table id */
777c478bd9Sstevel@tonic-gate 	const char *sym_obj;		/* Containing object */
787c478bd9Sstevel@tonic-gate } kmt_symarg_t;
797c478bd9Sstevel@tonic-gate 
807c478bd9Sstevel@tonic-gate typedef struct kmt_maparg {
817c478bd9Sstevel@tonic-gate 	mdb_tgt_t *map_target;		/* Target used for mapping iter */
827c478bd9Sstevel@tonic-gate 	mdb_tgt_map_f *map_cb;		/* Caller's callback function */
837c478bd9Sstevel@tonic-gate 	void *map_data;			/* Callback function argument */
847c478bd9Sstevel@tonic-gate } kmt_maparg_t;
857c478bd9Sstevel@tonic-gate 
867c478bd9Sstevel@tonic-gate /*ARGSUSED*/
877c478bd9Sstevel@tonic-gate int
kmt_setflags(mdb_tgt_t * t,int flags)887c478bd9Sstevel@tonic-gate kmt_setflags(mdb_tgt_t *t, int flags)
897c478bd9Sstevel@tonic-gate {
907c478bd9Sstevel@tonic-gate 	/*
917c478bd9Sstevel@tonic-gate 	 * We only handle one flag (ALLOWIO), and we can't fail to set or clear
927c478bd9Sstevel@tonic-gate 	 * it, so we just blindly replace the t_flags version with the one
937c478bd9Sstevel@tonic-gate 	 * passed.
947c478bd9Sstevel@tonic-gate 	 */
957c478bd9Sstevel@tonic-gate 	t->t_flags = (t->t_flags & ~MDB_TGT_F_ALLOWIO) |
967c478bd9Sstevel@tonic-gate 	    (flags & MDB_TGT_F_ALLOWIO);
977c478bd9Sstevel@tonic-gate 
987c478bd9Sstevel@tonic-gate 	return (0);
997c478bd9Sstevel@tonic-gate }
1007c478bd9Sstevel@tonic-gate 
1017c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1027c478bd9Sstevel@tonic-gate const char *
kmt_name(mdb_tgt_t * t)1037c478bd9Sstevel@tonic-gate kmt_name(mdb_tgt_t *t)
1047c478bd9Sstevel@tonic-gate {
1057c478bd9Sstevel@tonic-gate 	return ("kmdb_kvm");
1067c478bd9Sstevel@tonic-gate }
1077c478bd9Sstevel@tonic-gate 
1087c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1097c478bd9Sstevel@tonic-gate static const char *
kmt_platform(mdb_tgt_t * t)1107c478bd9Sstevel@tonic-gate kmt_platform(mdb_tgt_t *t)
1117c478bd9Sstevel@tonic-gate {
1127c478bd9Sstevel@tonic-gate 	static char platform[SYS_NMLN];
1137c478bd9Sstevel@tonic-gate 
1147c478bd9Sstevel@tonic-gate 	if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT)
1157c478bd9Sstevel@tonic-gate 		return (mdb_conf_platform());
1167c478bd9Sstevel@tonic-gate 
1177c478bd9Sstevel@tonic-gate 	if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, platform,
1187c478bd9Sstevel@tonic-gate 	    sizeof (platform), "unix", "platform") != sizeof (platform)) {
1197c478bd9Sstevel@tonic-gate 		warn("'platform' symbol is missing from kernel\n");
1207c478bd9Sstevel@tonic-gate 		return ("unknown");
1217c478bd9Sstevel@tonic-gate 	}
1227c478bd9Sstevel@tonic-gate 
1237c478bd9Sstevel@tonic-gate 	return (platform);
1247c478bd9Sstevel@tonic-gate }
1257c478bd9Sstevel@tonic-gate 
1267c478bd9Sstevel@tonic-gate static int
kmt_uname(mdb_tgt_t * t,struct utsname * utsp)1277c478bd9Sstevel@tonic-gate kmt_uname(mdb_tgt_t *t, struct utsname *utsp)
1287c478bd9Sstevel@tonic-gate {
1297c478bd9Sstevel@tonic-gate 	return (mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, utsp,
1307c478bd9Sstevel@tonic-gate 	    sizeof (struct utsname), MDB_TGT_OBJ_EXEC, "utsname"));
1317c478bd9Sstevel@tonic-gate }
1327c478bd9Sstevel@tonic-gate 
1337c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1347c478bd9Sstevel@tonic-gate static int
kmt_dmodel(mdb_tgt_t * t)1357c478bd9Sstevel@tonic-gate kmt_dmodel(mdb_tgt_t *t)
1367c478bd9Sstevel@tonic-gate {
1377c478bd9Sstevel@tonic-gate 	return (MDB_TGT_MODEL_NATIVE);
1387c478bd9Sstevel@tonic-gate }
1397c478bd9Sstevel@tonic-gate 
1407c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1417c478bd9Sstevel@tonic-gate ssize_t
kmt_rw(mdb_tgt_t * t,void * buf,size_t nbytes,uint64_t addr,ssize_t (* rw)(void *,size_t,uint64_t))1427c478bd9Sstevel@tonic-gate kmt_rw(mdb_tgt_t *t, void *buf, size_t nbytes, uint64_t addr,
1437c478bd9Sstevel@tonic-gate     ssize_t (*rw)(void *, size_t, uint64_t))
1447c478bd9Sstevel@tonic-gate {
145982e63f0SJeremy Jones 	/*
146982e63f0SJeremy Jones 	 * chunksz needs to be volatile because of the use of setjmp() in this
147982e63f0SJeremy Jones 	 * function.
148982e63f0SJeremy Jones 	 */
149982e63f0SJeremy Jones 	volatile size_t chunksz;
150982e63f0SJeremy Jones 	size_t n, ndone;
1517c478bd9Sstevel@tonic-gate 	jmp_buf *oldpcb = NULL;
1527c478bd9Sstevel@tonic-gate 	jmp_buf pcb;
1537c478bd9Sstevel@tonic-gate 	ssize_t res;
1547c478bd9Sstevel@tonic-gate 
1557c478bd9Sstevel@tonic-gate 	kmdb_prom_check_interrupt();
1567c478bd9Sstevel@tonic-gate 
1577c478bd9Sstevel@tonic-gate 	if (nbytes == 0)
1587c478bd9Sstevel@tonic-gate 		return (0);
1597c478bd9Sstevel@tonic-gate 
1607c478bd9Sstevel@tonic-gate 	/*
1617c478bd9Sstevel@tonic-gate 	 * Try to process the entire buffer, as requested.  If we catch a fault,
1627c478bd9Sstevel@tonic-gate 	 * try smaller chunks.  This allows us to handle regions that cross
1637c478bd9Sstevel@tonic-gate 	 * mapping boundaries.
1647c478bd9Sstevel@tonic-gate 	 */
1657c478bd9Sstevel@tonic-gate 	chunksz = nbytes;
1667c478bd9Sstevel@tonic-gate 	ndone = 0;
1677c478bd9Sstevel@tonic-gate 	if (setjmp(pcb) != 0) {
1687c478bd9Sstevel@tonic-gate 		if (chunksz == 1) {
1697c478bd9Sstevel@tonic-gate 			/* We failed with the smallest chunk - give up */
1707c478bd9Sstevel@tonic-gate 			kmdb_dpi_restore_fault_hdlr(oldpcb);
1717c478bd9Sstevel@tonic-gate 			return (ndone > 0 ? ndone : -1); /* errno set for us */
1727c478bd9Sstevel@tonic-gate 		} else if (chunksz > 4)
1737c478bd9Sstevel@tonic-gate 			chunksz = 4;
1747c478bd9Sstevel@tonic-gate 		else
1757c478bd9Sstevel@tonic-gate 			chunksz = 1;
1767c478bd9Sstevel@tonic-gate 	}
1777c478bd9Sstevel@tonic-gate 
1787c478bd9Sstevel@tonic-gate 	oldpcb = kmdb_dpi_set_fault_hdlr(&pcb);
1797c478bd9Sstevel@tonic-gate 	while (nbytes > 0) {
1807c478bd9Sstevel@tonic-gate 		n = MIN(chunksz, nbytes);
1817c478bd9Sstevel@tonic-gate 
1827c478bd9Sstevel@tonic-gate 		if ((res = rw(buf, n, addr)) != n)
1837c478bd9Sstevel@tonic-gate 			return (res < 0 ? res : ndone + res);
1847c478bd9Sstevel@tonic-gate 
1857c478bd9Sstevel@tonic-gate 		addr += n;
1867c478bd9Sstevel@tonic-gate 		nbytes -= n;
1877c478bd9Sstevel@tonic-gate 		ndone += n;
1887c478bd9Sstevel@tonic-gate 		buf = ((caddr_t)buf + n);
1897c478bd9Sstevel@tonic-gate 	}
1907c478bd9Sstevel@tonic-gate 
1917c478bd9Sstevel@tonic-gate 	kmdb_dpi_restore_fault_hdlr(oldpcb);
1927c478bd9Sstevel@tonic-gate 
1937c478bd9Sstevel@tonic-gate 	return (ndone);
1947c478bd9Sstevel@tonic-gate }
1957c478bd9Sstevel@tonic-gate 
1967c478bd9Sstevel@tonic-gate static void
kmt_bcopy(const void * s1,void * s2,size_t n)1977c478bd9Sstevel@tonic-gate kmt_bcopy(const void *s1, void *s2, size_t n)
1987c478bd9Sstevel@tonic-gate {
1997c478bd9Sstevel@tonic-gate 	/*
2007c478bd9Sstevel@tonic-gate 	 * We need to guarantee atomic accesses for certain sizes.  bcopy won't
2017c478bd9Sstevel@tonic-gate 	 * make that guarantee, so we need to do it ourselves.
2027c478bd9Sstevel@tonic-gate 	 */
2037c478bd9Sstevel@tonic-gate #ifdef	_LP64
2047c478bd9Sstevel@tonic-gate 	if (n == 8 && ((uintptr_t)s1 & 7) == 0 && ((uintptr_t)s2 & 7) == 0)
2057c478bd9Sstevel@tonic-gate 		*(uint64_t *)s2 = *(uint64_t *)s1;
2067c478bd9Sstevel@tonic-gate 	else
2077c478bd9Sstevel@tonic-gate #endif
2087c478bd9Sstevel@tonic-gate 	if (n == 4 && ((uintptr_t)s1 & 3) == 0 && ((uintptr_t)s2 & 3) == 0)
2097c478bd9Sstevel@tonic-gate 		*(uint32_t *)s2 = *(uint32_t *)s1;
2107c478bd9Sstevel@tonic-gate 	else if (n == 2 && ((uintptr_t)s1 & 1) == 0 && ((uintptr_t)s2 & 1) == 0)
2117c478bd9Sstevel@tonic-gate 		*(uint16_t *)s2 = *(uint16_t *)s1;
2127c478bd9Sstevel@tonic-gate 	else if (n == 1)
2137c478bd9Sstevel@tonic-gate 		*(uint8_t *)s2 = *(uint8_t *)s1;
2147c478bd9Sstevel@tonic-gate 	else
2157c478bd9Sstevel@tonic-gate 		bcopy(s1, s2, n);
2167c478bd9Sstevel@tonic-gate }
2177c478bd9Sstevel@tonic-gate 
2187c478bd9Sstevel@tonic-gate static ssize_t
kmt_reader(void * buf,size_t nbytes,uint64_t addr)2197c478bd9Sstevel@tonic-gate kmt_reader(void *buf, size_t nbytes, uint64_t addr)
2207c478bd9Sstevel@tonic-gate {
2217c478bd9Sstevel@tonic-gate 	kmt_bcopy((void *)(uintptr_t)addr, buf, nbytes);
2227c478bd9Sstevel@tonic-gate 	return (nbytes);
2237c478bd9Sstevel@tonic-gate }
2247c478bd9Sstevel@tonic-gate 
2257c478bd9Sstevel@tonic-gate ssize_t
kmt_writer(void * buf,size_t nbytes,uint64_t addr)2267c478bd9Sstevel@tonic-gate kmt_writer(void *buf, size_t nbytes, uint64_t addr)
2277c478bd9Sstevel@tonic-gate {
2287c478bd9Sstevel@tonic-gate 	kmt_bcopy(buf, (void *)(uintptr_t)addr, nbytes);
2297c478bd9Sstevel@tonic-gate 	return (nbytes);
2307c478bd9Sstevel@tonic-gate }
2317c478bd9Sstevel@tonic-gate 
2327c478bd9Sstevel@tonic-gate /*ARGSUSED*/
2337c478bd9Sstevel@tonic-gate static ssize_t
kmt_read(mdb_tgt_t * t,void * buf,size_t nbytes,uintptr_t addr)2347c478bd9Sstevel@tonic-gate kmt_read(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
2357c478bd9Sstevel@tonic-gate {
2367c478bd9Sstevel@tonic-gate 	/*
2377c478bd9Sstevel@tonic-gate 	 * We don't want to allow reads of I/O-mapped memory.  Multi-page reads
2387c478bd9Sstevel@tonic-gate 	 * that cross into I/O-mapped memory should be restricted to the initial
2397c478bd9Sstevel@tonic-gate 	 * non-I/O region.  Reads that begin in I/O-mapped memory are failed
2407c478bd9Sstevel@tonic-gate 	 * outright.
2417c478bd9Sstevel@tonic-gate 	 */
2427c478bd9Sstevel@tonic-gate 	if (!(t->t_flags & MDB_TGT_F_ALLOWIO) &&
2437c478bd9Sstevel@tonic-gate 	    (nbytes = kmdb_kdi_range_is_nontoxic(addr, nbytes, 0)) == 0)
2447c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_NOMAP));
2457c478bd9Sstevel@tonic-gate 
2467c478bd9Sstevel@tonic-gate 	return (kmt_rw(t, buf, nbytes, addr, kmt_reader));
2477c478bd9Sstevel@tonic-gate }
2487c478bd9Sstevel@tonic-gate 
2497c478bd9Sstevel@tonic-gate /*ARGSUSED*/
2507c478bd9Sstevel@tonic-gate static ssize_t
kmt_pread(mdb_tgt_t * t,void * buf,size_t nbytes,physaddr_t addr)2517c478bd9Sstevel@tonic-gate kmt_pread(mdb_tgt_t *t, void *buf, size_t nbytes, physaddr_t addr)
2527c478bd9Sstevel@tonic-gate {
2537c478bd9Sstevel@tonic-gate 	return (kmt_rw(t, buf, nbytes, addr, kmdb_kdi_pread));
2547c478bd9Sstevel@tonic-gate }
2557c478bd9Sstevel@tonic-gate 
2567c478bd9Sstevel@tonic-gate /*ARGSUSED*/
2577c478bd9Sstevel@tonic-gate ssize_t
kmt_pwrite(mdb_tgt_t * t,const void * buf,size_t nbytes,physaddr_t addr)2587c478bd9Sstevel@tonic-gate kmt_pwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, physaddr_t addr)
2597c478bd9Sstevel@tonic-gate {
2607c478bd9Sstevel@tonic-gate 	return (kmt_rw(t, (void *)buf, nbytes, addr, kmdb_kdi_pwrite));
2617c478bd9Sstevel@tonic-gate }
2627c478bd9Sstevel@tonic-gate 
2637c478bd9Sstevel@tonic-gate static uintptr_t
kmt_read_kas(mdb_tgt_t * t)2647c478bd9Sstevel@tonic-gate kmt_read_kas(mdb_tgt_t *t)
2657c478bd9Sstevel@tonic-gate {
2667c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
2677c478bd9Sstevel@tonic-gate 
2687c478bd9Sstevel@tonic-gate 	if (mdb_tgt_lookup_by_name(t, "unix", "kas", &sym, NULL) < 0) {
2697c478bd9Sstevel@tonic-gate 		warn("'kas' symbol is missing from kernel\n");
2707c478bd9Sstevel@tonic-gate 		(void) set_errno(EMDB_NOSYM);
2717c478bd9Sstevel@tonic-gate 		return (0);
2727c478bd9Sstevel@tonic-gate 	}
2737c478bd9Sstevel@tonic-gate 
2747c478bd9Sstevel@tonic-gate 	return ((uintptr_t)sym.st_value);
2757c478bd9Sstevel@tonic-gate }
2767c478bd9Sstevel@tonic-gate 
2777c478bd9Sstevel@tonic-gate static int
kmt_vtop(mdb_tgt_t * t,mdb_tgt_as_t as,uintptr_t va,physaddr_t * pap)2787c478bd9Sstevel@tonic-gate kmt_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap)
2797c478bd9Sstevel@tonic-gate {
2807c478bd9Sstevel@tonic-gate 	mdb_module_t *mod;
2817c478bd9Sstevel@tonic-gate 	struct as *asp;
2827c478bd9Sstevel@tonic-gate 	mdb_var_t *v;
2837c478bd9Sstevel@tonic-gate 
2847c478bd9Sstevel@tonic-gate 	switch ((uintptr_t)as) {
2857c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_AS_PHYS:
2867c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_AS_FILE:
2877c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_AS_IO:
2887c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
2897c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_AS_VIRT:
2909c3024a3SHans Rosenfeld 	case (uintptr_t)MDB_TGT_AS_VIRT_I:
2919c3024a3SHans Rosenfeld 	case (uintptr_t)MDB_TGT_AS_VIRT_S:
2927c478bd9Sstevel@tonic-gate 		if ((asp = (struct as *)kmt_read_kas(t)) == NULL)
2937c478bd9Sstevel@tonic-gate 			return (-1); /* errno is set for us */
2947c478bd9Sstevel@tonic-gate 		break;
2957c478bd9Sstevel@tonic-gate 	default:
2967c478bd9Sstevel@tonic-gate 		asp = (struct as *)as;
2977c478bd9Sstevel@tonic-gate 
2987c478bd9Sstevel@tonic-gate 		/* We don't support non-kas vtop */
2997c478bd9Sstevel@tonic-gate 		if (asp != (struct as *)kmt_read_kas(t))
3007c478bd9Sstevel@tonic-gate 			return (set_errno(EMDB_TGTNOTSUP));
3017c478bd9Sstevel@tonic-gate 	}
3027c478bd9Sstevel@tonic-gate 
3037c478bd9Sstevel@tonic-gate 	if (kmdb_prom_vtop(va, pap) == 0)
3047c478bd9Sstevel@tonic-gate 		return (0);
3057c478bd9Sstevel@tonic-gate 
3067c478bd9Sstevel@tonic-gate 	if ((v = mdb_nv_lookup(&mdb.m_modules, "unix")) != NULL &&
3077c478bd9Sstevel@tonic-gate 	    (mod = mdb_nv_get_cookie(v)) != NULL) {
3087c478bd9Sstevel@tonic-gate 		int (*fptr)(uintptr_t, struct as *, physaddr_t *);
3097c478bd9Sstevel@tonic-gate 
3107c478bd9Sstevel@tonic-gate 		fptr = (int (*)(uintptr_t, struct as *, physaddr_t *))
3117c478bd9Sstevel@tonic-gate 		    dlsym(mod->mod_hdl, "platform_vtop");
3127c478bd9Sstevel@tonic-gate 
3137c478bd9Sstevel@tonic-gate 		if ((fptr != NULL) && ((*fptr)(va, asp, pap) == 0))
3147c478bd9Sstevel@tonic-gate 			return (0);
3157c478bd9Sstevel@tonic-gate 	}
3167c478bd9Sstevel@tonic-gate 
3177c478bd9Sstevel@tonic-gate 	return (set_errno(EMDB_NOMAP));
3187c478bd9Sstevel@tonic-gate }
3197c478bd9Sstevel@tonic-gate 
3207c478bd9Sstevel@tonic-gate /*ARGSUSED*/
3217c478bd9Sstevel@tonic-gate static int
kmt_cpuregs(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3227c478bd9Sstevel@tonic-gate kmt_cpuregs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3237c478bd9Sstevel@tonic-gate {
3247c478bd9Sstevel@tonic-gate 	const mdb_tgt_gregset_t *gregs;
325acbc304dSjohnlev 	intptr_t cpuid = DPI_MASTER_CPUID;
3267c478bd9Sstevel@tonic-gate 	int i;
3277c478bd9Sstevel@tonic-gate 
3287c478bd9Sstevel@tonic-gate 	if (flags & DCMD_ADDRSPEC) {
3297c478bd9Sstevel@tonic-gate 		if (argc != 0)
3307c478bd9Sstevel@tonic-gate 			return (DCMD_USAGE);
331acbc304dSjohnlev 		if ((cpuid = mdb_cpu2cpuid(addr)) < 0) {
332acbc304dSjohnlev 			(void) set_errno(EMDB_NOMAP);
333acbc304dSjohnlev 			mdb_warn("failed to find cpuid for cpu at %p", addr);
334acbc304dSjohnlev 			return (DCMD_ERR);
335acbc304dSjohnlev 		}
3367c478bd9Sstevel@tonic-gate 	}
3377c478bd9Sstevel@tonic-gate 
3387c478bd9Sstevel@tonic-gate 	i = mdb_getopts(argc, argv,
339acbc304dSjohnlev 	    'c', MDB_OPT_UINTPTR, &cpuid,
3407c478bd9Sstevel@tonic-gate 	    NULL);
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate 	argc -= i;
3437c478bd9Sstevel@tonic-gate 	argv += i;
3447c478bd9Sstevel@tonic-gate 
3457c478bd9Sstevel@tonic-gate 	if (argc != 0)
3467c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
3477c478bd9Sstevel@tonic-gate 
348acbc304dSjohnlev 	if ((gregs = kmdb_dpi_get_gregs(cpuid)) == NULL) {
349acbc304dSjohnlev 		warn("failed to retrieve registers for cpu %d", (int)cpuid);
3507c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
3517c478bd9Sstevel@tonic-gate 	}
3527c478bd9Sstevel@tonic-gate 
3537c478bd9Sstevel@tonic-gate 	kmt_printregs(gregs);
3547c478bd9Sstevel@tonic-gate 
3557c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
3567c478bd9Sstevel@tonic-gate }
3577c478bd9Sstevel@tonic-gate 
3587c478bd9Sstevel@tonic-gate static int
kmt_regs(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3597c478bd9Sstevel@tonic-gate kmt_regs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3607c478bd9Sstevel@tonic-gate {
3617c478bd9Sstevel@tonic-gate 	if (flags & DCMD_ADDRSPEC)
3627c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 	return (kmt_cpuregs(addr, flags, argc, argv));
3657c478bd9Sstevel@tonic-gate }
3667c478bd9Sstevel@tonic-gate 
367acbc304dSjohnlev static int
kmt_cpustack_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)368acbc304dSjohnlev kmt_cpustack_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
369acbc304dSjohnlev {
370acbc304dSjohnlev 	intptr_t cpuid = DPI_MASTER_CPUID;
371acbc304dSjohnlev 	uint_t verbose = 0;
372acbc304dSjohnlev 	int i;
373acbc304dSjohnlev 
374acbc304dSjohnlev 	if (flags & DCMD_ADDRSPEC) {
375acbc304dSjohnlev 		if ((cpuid = mdb_cpu2cpuid(addr)) < 0) {
376acbc304dSjohnlev 			(void) set_errno(EMDB_NOMAP);
377acbc304dSjohnlev 			mdb_warn("failed to find cpuid for cpu at %p", addr);
378acbc304dSjohnlev 			return (DCMD_ERR);
379acbc304dSjohnlev 		}
380acbc304dSjohnlev 		flags &= ~DCMD_ADDRSPEC;
381acbc304dSjohnlev 	}
382acbc304dSjohnlev 
383acbc304dSjohnlev 	i = mdb_getopts(argc, argv,
384acbc304dSjohnlev 	    'c', MDB_OPT_UINTPTR, &cpuid,
385acbc304dSjohnlev 	    'v', MDB_OPT_SETBITS, 1, &verbose,
386acbc304dSjohnlev 	    NULL);
387acbc304dSjohnlev 
388acbc304dSjohnlev 	argc -= i;
389acbc304dSjohnlev 	argv += i;
390acbc304dSjohnlev 
391acbc304dSjohnlev 	return (kmt_cpustack(addr, flags, argc, argv, cpuid, verbose));
392acbc304dSjohnlev }
393acbc304dSjohnlev 
3947c478bd9Sstevel@tonic-gate /*
3957c478bd9Sstevel@tonic-gate  * Lasciate ogne speranza, voi ch'intrate.
3967c478bd9Sstevel@tonic-gate  */
3977c478bd9Sstevel@tonic-gate static int
kmt_call(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3987c478bd9Sstevel@tonic-gate kmt_call(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3997c478bd9Sstevel@tonic-gate {
4007c478bd9Sstevel@tonic-gate 	uintptr_t *call_argv, rval;
4017c478bd9Sstevel@tonic-gate 	int parse_strings = 1;
4027c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
4037c478bd9Sstevel@tonic-gate 	jmp_buf *oldpcb = NULL;
4047c478bd9Sstevel@tonic-gate 	jmp_buf pcb;
4057c478bd9Sstevel@tonic-gate 	int i;
4067c478bd9Sstevel@tonic-gate 
4077c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC))
4087c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
4097c478bd9Sstevel@tonic-gate 
4107c478bd9Sstevel@tonic-gate 	if (mdb_tgt_lookup_by_addr(mdb.m_target, addr, MDB_TGT_SYM_EXACT,
4117c478bd9Sstevel@tonic-gate 	    NULL, 0, &sym, NULL) == 0 && GELF_ST_TYPE(sym.st_info) !=
4127c478bd9Sstevel@tonic-gate 	    STT_FUNC) {
4137c478bd9Sstevel@tonic-gate 		warn("%a is not a function\n", addr);
4147c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
4157c478bd9Sstevel@tonic-gate 	}
4167c478bd9Sstevel@tonic-gate 
4177c478bd9Sstevel@tonic-gate 	if (argc > 1 && argv[0].a_type == MDB_TYPE_STRING &&
4187c478bd9Sstevel@tonic-gate 	    strcmp(argv[0].a_un.a_str, "-s") == 0) {
4197c478bd9Sstevel@tonic-gate 		parse_strings = 0;
4207c478bd9Sstevel@tonic-gate 		argc--;
4217c478bd9Sstevel@tonic-gate 		argv++;
4227c478bd9Sstevel@tonic-gate 	}
4237c478bd9Sstevel@tonic-gate 
4247c478bd9Sstevel@tonic-gate 	call_argv = mdb_alloc(sizeof (uintptr_t) * argc, UM_SLEEP);
4257c478bd9Sstevel@tonic-gate 
4267c478bd9Sstevel@tonic-gate 	for (i = 0; i < argc; i++) {
4277c478bd9Sstevel@tonic-gate 		switch (argv[i].a_type) {
4287c478bd9Sstevel@tonic-gate 		case MDB_TYPE_STRING:
4297c478bd9Sstevel@tonic-gate 			/*
4307c478bd9Sstevel@tonic-gate 			 * mdb_strtoull doesn't return on error, so we have to
4317c478bd9Sstevel@tonic-gate 			 * pre-check strings suspected to contain numbers.
4327c478bd9Sstevel@tonic-gate 			 */
4337c478bd9Sstevel@tonic-gate 			if (parse_strings && strisbasenum(argv[i].a_un.a_str)) {
4347c478bd9Sstevel@tonic-gate 				call_argv[i] = (uintptr_t)mdb_strtoull(
4357c478bd9Sstevel@tonic-gate 				    argv[i].a_un.a_str);
4367c478bd9Sstevel@tonic-gate 			} else
4377c478bd9Sstevel@tonic-gate 				call_argv[i] = (uintptr_t)argv[i].a_un.a_str;
4387c478bd9Sstevel@tonic-gate 
4397c478bd9Sstevel@tonic-gate 			break;
4407c478bd9Sstevel@tonic-gate 
4417c478bd9Sstevel@tonic-gate 		case MDB_TYPE_IMMEDIATE:
4427c478bd9Sstevel@tonic-gate 			call_argv[i] = argv[i].a_un.a_val;
4437c478bd9Sstevel@tonic-gate 			break;
4447c478bd9Sstevel@tonic-gate 
4457c478bd9Sstevel@tonic-gate 		default:
4467c478bd9Sstevel@tonic-gate 			mdb_free(call_argv,
4477c478bd9Sstevel@tonic-gate 			    sizeof (uintptr_t) * argc);
4487c478bd9Sstevel@tonic-gate 			return (DCMD_USAGE);
4497c478bd9Sstevel@tonic-gate 		}
4507c478bd9Sstevel@tonic-gate 	}
4517c478bd9Sstevel@tonic-gate 
4527c478bd9Sstevel@tonic-gate 	if (setjmp(pcb) != 0) {
4537c478bd9Sstevel@tonic-gate 		warn("call failed: caught a trap\n");
4547c478bd9Sstevel@tonic-gate 
4557c478bd9Sstevel@tonic-gate 		kmdb_dpi_restore_fault_hdlr(oldpcb);
4567c478bd9Sstevel@tonic-gate 		mdb_free(call_argv, sizeof (uintptr_t) * argc);
4577c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
4587c478bd9Sstevel@tonic-gate 	}
4597c478bd9Sstevel@tonic-gate 
4607c478bd9Sstevel@tonic-gate 	oldpcb = kmdb_dpi_set_fault_hdlr(&pcb);
4617c478bd9Sstevel@tonic-gate 	rval = kmdb_dpi_call(addr, argc, call_argv);
4627c478bd9Sstevel@tonic-gate 	kmdb_dpi_restore_fault_hdlr(oldpcb);
4637c478bd9Sstevel@tonic-gate 
4647c478bd9Sstevel@tonic-gate 	if (flags & DCMD_PIPE_OUT) {
4657c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", rval);
4667c478bd9Sstevel@tonic-gate 	} else {
4677c478bd9Sstevel@tonic-gate 		/* pretty-print the results */
4687c478bd9Sstevel@tonic-gate 		mdb_printf("%p = %a(", rval, addr);
4697c478bd9Sstevel@tonic-gate 		for (i = 0; i < argc; i++) {
4707c478bd9Sstevel@tonic-gate 			if (i > 0)
4717c478bd9Sstevel@tonic-gate 				mdb_printf(", ");
4727c478bd9Sstevel@tonic-gate 			if (argv[i].a_type == MDB_TYPE_STRING) {
4737c478bd9Sstevel@tonic-gate 				/* I'm ashamed but amused */
4747c478bd9Sstevel@tonic-gate 				char *quote = &("\""[parse_strings &&
4757c478bd9Sstevel@tonic-gate 				    strisbasenum(argv[i].a_un.a_str)]);
4767c478bd9Sstevel@tonic-gate 
4777c478bd9Sstevel@tonic-gate 				mdb_printf("%s%s%s", quote, argv[i].a_un.a_str,
4787c478bd9Sstevel@tonic-gate 				    quote);
4797c478bd9Sstevel@tonic-gate 			} else
4807c478bd9Sstevel@tonic-gate 				mdb_printf("%p", argv[i].a_un.a_val);
4817c478bd9Sstevel@tonic-gate 		}
4827c478bd9Sstevel@tonic-gate 		mdb_printf(");\n");
4837c478bd9Sstevel@tonic-gate 	}
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate 	mdb_free(call_argv, sizeof (uintptr_t) * argc);
4867c478bd9Sstevel@tonic-gate 
4877c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
4887c478bd9Sstevel@tonic-gate }
4897c478bd9Sstevel@tonic-gate 
4907c478bd9Sstevel@tonic-gate /*ARGSUSED*/
4917c478bd9Sstevel@tonic-gate int
kmt_dump_crumbs(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)4927c478bd9Sstevel@tonic-gate kmt_dump_crumbs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4937c478bd9Sstevel@tonic-gate {
4947c478bd9Sstevel@tonic-gate 	intptr_t cpu = -1;
4957c478bd9Sstevel@tonic-gate 
4967c478bd9Sstevel@tonic-gate 	if (flags & DCMD_ADDRSPEC) {
4977c478bd9Sstevel@tonic-gate 		if (argc != 0)
4987c478bd9Sstevel@tonic-gate 			return (DCMD_USAGE);
4997c478bd9Sstevel@tonic-gate 	} else {
5007c478bd9Sstevel@tonic-gate 		addr = 0;
5017c478bd9Sstevel@tonic-gate 
5027c478bd9Sstevel@tonic-gate 		if (mdb_getopts(argc, argv,
5037c478bd9Sstevel@tonic-gate 		    'c', MDB_OPT_UINTPTR, &cpu,
5047c478bd9Sstevel@tonic-gate 		    NULL) != argc)
5057c478bd9Sstevel@tonic-gate 			return (DCMD_USAGE);
5067c478bd9Sstevel@tonic-gate 	}
5077c478bd9Sstevel@tonic-gate 
5087c478bd9Sstevel@tonic-gate 	kmdb_dpi_dump_crumbs(addr, cpu);
5097c478bd9Sstevel@tonic-gate 
5107c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
5117c478bd9Sstevel@tonic-gate }
5127c478bd9Sstevel@tonic-gate 
5137c478bd9Sstevel@tonic-gate /*ARGSUSED*/
5147c478bd9Sstevel@tonic-gate static int
kmt_noducttape(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)5157c478bd9Sstevel@tonic-gate kmt_noducttape(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
5167c478bd9Sstevel@tonic-gate {
5177c478bd9Sstevel@tonic-gate 	int a = 0;
5187c478bd9Sstevel@tonic-gate 
5197c478bd9Sstevel@tonic-gate 	return (a/a);
5207c478bd9Sstevel@tonic-gate }
5217c478bd9Sstevel@tonic-gate 
5227c478bd9Sstevel@tonic-gate static int
kmt_dmod_status(char * msg,int state)5237c478bd9Sstevel@tonic-gate kmt_dmod_status(char *msg, int state)
5247c478bd9Sstevel@tonic-gate {
5257c478bd9Sstevel@tonic-gate 	kmdb_modctl_t *kmc;
5267c478bd9Sstevel@tonic-gate 	mdb_var_t *v;
5277c478bd9Sstevel@tonic-gate 	int first = 1, n = 0;
5287c478bd9Sstevel@tonic-gate 
5297c478bd9Sstevel@tonic-gate 	mdb_nv_rewind(&mdb.m_dmodctl);
5307c478bd9Sstevel@tonic-gate 	while ((v = mdb_nv_advance(&mdb.m_dmodctl)) != NULL) {
5317c478bd9Sstevel@tonic-gate 		kmc = MDB_NV_COOKIE(v);
5327c478bd9Sstevel@tonic-gate 
5337c478bd9Sstevel@tonic-gate 		if (kmc->kmc_state != state)
5347c478bd9Sstevel@tonic-gate 			continue;
5357c478bd9Sstevel@tonic-gate 
5367c478bd9Sstevel@tonic-gate 		n++;
5377c478bd9Sstevel@tonic-gate 
5387c478bd9Sstevel@tonic-gate 		if (msg != NULL) {
5397c478bd9Sstevel@tonic-gate 			if (first) {
5407c478bd9Sstevel@tonic-gate 				mdb_printf(msg, NULL);
5417c478bd9Sstevel@tonic-gate 				first = 0;
5427c478bd9Sstevel@tonic-gate 			}
5437c478bd9Sstevel@tonic-gate 
5447c478bd9Sstevel@tonic-gate 			mdb_printf(" %s", kmc->kmc_modname);
5457c478bd9Sstevel@tonic-gate 		}
5467c478bd9Sstevel@tonic-gate 	}
5477c478bd9Sstevel@tonic-gate 
5487c478bd9Sstevel@tonic-gate 	if (!first && msg != NULL)
5497c478bd9Sstevel@tonic-gate 		mdb_printf("\n");
5507c478bd9Sstevel@tonic-gate 
5517c478bd9Sstevel@tonic-gate 	return (n);
5527c478bd9Sstevel@tonic-gate }
5537c478bd9Sstevel@tonic-gate 
5547c478bd9Sstevel@tonic-gate /*ARGSUSED*/
5557c478bd9Sstevel@tonic-gate static int
kmt_status_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)5567c478bd9Sstevel@tonic-gate kmt_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
5577c478bd9Sstevel@tonic-gate {
5587c478bd9Sstevel@tonic-gate 	struct utsname uts;
5598eb8717cSJohn Levon 	char uuid[UUID_PRINTABLE_STRING_LENGTH];
5607c478bd9Sstevel@tonic-gate 	kreg_t tt;
5617c478bd9Sstevel@tonic-gate 
5627c478bd9Sstevel@tonic-gate 	if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, &uts, sizeof (uts),
5637c478bd9Sstevel@tonic-gate 	    "unix", "utsname") != sizeof (uts)) {
5647c478bd9Sstevel@tonic-gate 		warn("failed to read 'utsname' struct from kernel\n");
5657c478bd9Sstevel@tonic-gate 		bzero(&uts, sizeof (uts));
5667c478bd9Sstevel@tonic-gate 		(void) strcpy(uts.nodename, "unknown machine");
5677c478bd9Sstevel@tonic-gate 	}
5687c478bd9Sstevel@tonic-gate 
5697c478bd9Sstevel@tonic-gate 	mdb_printf("debugging live kernel (%d-bit) on %s\n",
5707c478bd9Sstevel@tonic-gate 	    (int)(sizeof (void *) * NBBY),
5717c478bd9Sstevel@tonic-gate 	    (*uts.nodename == '\0' ? "(not set)" : uts.nodename));
5727c478bd9Sstevel@tonic-gate 	mdb_printf("operating system: %s %s (%s)\n",
5737c478bd9Sstevel@tonic-gate 	    uts.release, uts.version, uts.machine);
5747c478bd9Sstevel@tonic-gate 
5758eb8717cSJohn Levon 	mdb_print_buildversion();
5768eb8717cSJohn Levon 
5778eb8717cSJohn Levon 	if (mdb_readsym(uuid, sizeof (uuid),
5788eb8717cSJohn Levon 	    "dump_osimage_uuid") == sizeof (uuid) &&
5798eb8717cSJohn Levon 	    uuid[sizeof (uuid) - 1] == '\0') {
5808eb8717cSJohn Levon 		mdb_printf("image uuid: %s\n", uuid[0] != '\0' ?
5818eb8717cSJohn Levon 		    uuid : "(not set)");
582f6e214c7SGavin Maltby 	}
583f6e214c7SGavin Maltby 
5847c478bd9Sstevel@tonic-gate 	mdb_printf("DTrace state: %s\n", (kmdb_kdi_dtrace_get_state() ==
5857c478bd9Sstevel@tonic-gate 	    KDI_DTSTATE_DTRACE_ACTIVE ? "active (debugger breakpoints cannot "
5867c478bd9Sstevel@tonic-gate 	    "be armed)" : "inactive"));
5877c478bd9Sstevel@tonic-gate 
5887c478bd9Sstevel@tonic-gate 	(void) kmdb_dpi_get_register("tt", &tt);
5897c478bd9Sstevel@tonic-gate 	mdb_printf("stopped on: %s\n", kmt_trapname(tt));
5907c478bd9Sstevel@tonic-gate 
5917c478bd9Sstevel@tonic-gate 	(void) kmt_dmod_status("pending dmod loads:", KMDB_MC_STATE_LOADING);
5927c478bd9Sstevel@tonic-gate 	(void) kmt_dmod_status("pending dmod unloads:",
5937c478bd9Sstevel@tonic-gate 	    KMDB_MC_STATE_UNLOADING);
5947c478bd9Sstevel@tonic-gate 
5957c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
5967c478bd9Sstevel@tonic-gate }
5977c478bd9Sstevel@tonic-gate 
5987c478bd9Sstevel@tonic-gate /*ARGSUSED*/
5997c478bd9Sstevel@tonic-gate static int
kmt_switch(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)6007c478bd9Sstevel@tonic-gate kmt_switch(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
6017c478bd9Sstevel@tonic-gate {
6027c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC) || argc != 0)
6037c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
6047c478bd9Sstevel@tonic-gate 
6057c478bd9Sstevel@tonic-gate 	if (kmdb_dpi_switch_master((int)addr) < 0) {
6067c478bd9Sstevel@tonic-gate 		warn("failed to switch to CPU %d", (int)addr);
6077c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
6087c478bd9Sstevel@tonic-gate 	}
6097c478bd9Sstevel@tonic-gate 
6107c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
6117c478bd9Sstevel@tonic-gate }
6127c478bd9Sstevel@tonic-gate 
6137c478bd9Sstevel@tonic-gate static const mdb_dcmd_t kmt_dcmds[] = {
6147c478bd9Sstevel@tonic-gate 	{ "$c", "?[cnt]", "print stack backtrace", kmt_stack },
6157c478bd9Sstevel@tonic-gate 	{ "$C", "?[cnt]", "print stack backtrace", kmt_stackv },
6167c478bd9Sstevel@tonic-gate 	{ "$r", NULL, "print general-purpose registers", kmt_regs },
6177c478bd9Sstevel@tonic-gate 	{ "$?", NULL, "print status and registers", kmt_regs },
6187c478bd9Sstevel@tonic-gate 	{ ":x", ":", "change the active CPU", kmt_switch },
6197c478bd9Sstevel@tonic-gate 	{ "call", ":[arg ...]", "call a kernel function", kmt_call },
6207c478bd9Sstevel@tonic-gate 	{ "cpustack", "?[-v] [-c cpuid] [cnt]", "print stack backtrace for a "
6217c478bd9Sstevel@tonic-gate 	    "specific CPU", kmt_cpustack_dcmd },
6227c478bd9Sstevel@tonic-gate 	{ "cpuregs", "?[-c cpuid]", "print general-purpose registers for a "
6237c478bd9Sstevel@tonic-gate 	    "specific CPU", kmt_cpuregs },
6247c478bd9Sstevel@tonic-gate 	{ "crumbs", NULL, NULL, kmt_dump_crumbs },
6257c478bd9Sstevel@tonic-gate #if defined(__i386) || defined(__amd64)
6267c478bd9Sstevel@tonic-gate 	{ "in", ":[-L len]", "read from I/O port", kmt_in_dcmd },
6277c478bd9Sstevel@tonic-gate 	{ "out", ":[-L len] val", "write to I/O port", kmt_out_dcmd },
6287c478bd9Sstevel@tonic-gate 	{ "rdmsr", ":", "read an MSR", kmt_rdmsr },
6297c478bd9Sstevel@tonic-gate 	{ "wrmsr", ": val", "write an MSR", kmt_wrmsr },
6307aec1d6eScindi 	{ "rdpcicfg", ": bus dev func", "read a register in PCI config space",
6317aec1d6eScindi 	kmt_rdpcicfg },
6327aec1d6eScindi 	{ "wrpcicfg", ": bus dev func val", "write a register in PCI config "
6337aec1d6eScindi 	"space", kmt_wrpcicfg },
6347c478bd9Sstevel@tonic-gate #endif
6357c478bd9Sstevel@tonic-gate 	{ "noducttape", NULL, NULL, kmt_noducttape },
6367c478bd9Sstevel@tonic-gate 	{ "regs", NULL, "print general-purpose registers", kmt_regs },
6377c478bd9Sstevel@tonic-gate 	{ "stack", "?[cnt]", "print stack backtrace", kmt_stack },
6387c478bd9Sstevel@tonic-gate 	{ "stackregs", "?", "print stack backtrace and registers", kmt_stackr },
6397c478bd9Sstevel@tonic-gate 	{ "status", NULL, "print summary of current target", kmt_status_dcmd },
6407c478bd9Sstevel@tonic-gate 	{ "switch", ":", "change the active CPU", kmt_switch },
6417c478bd9Sstevel@tonic-gate 	{ NULL }
6427c478bd9Sstevel@tonic-gate };
6437c478bd9Sstevel@tonic-gate 
6447c478bd9Sstevel@tonic-gate static uintmax_t
kmt_reg_disc_get(const mdb_var_t * v)6457c478bd9Sstevel@tonic-gate kmt_reg_disc_get(const mdb_var_t *v)
6467c478bd9Sstevel@tonic-gate {
6477c478bd9Sstevel@tonic-gate 	mdb_tgt_reg_t r = 0;
6487c478bd9Sstevel@tonic-gate 
6497c478bd9Sstevel@tonic-gate 	(void) mdb_tgt_getareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), &r);
6507c478bd9Sstevel@tonic-gate 
6517c478bd9Sstevel@tonic-gate 	return (r);
6527c478bd9Sstevel@tonic-gate }
6537c478bd9Sstevel@tonic-gate 
6547c478bd9Sstevel@tonic-gate static void
kmt_reg_disc_set(mdb_var_t * v,uintmax_t r)6557c478bd9Sstevel@tonic-gate kmt_reg_disc_set(mdb_var_t *v, uintmax_t r)
6567c478bd9Sstevel@tonic-gate {
6577c478bd9Sstevel@tonic-gate 	if (mdb_tgt_putareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), r) == -1)
6587c478bd9Sstevel@tonic-gate 		warn("failed to modify %%%s register", mdb_nv_get_name(v));
6597c478bd9Sstevel@tonic-gate }
6607c478bd9Sstevel@tonic-gate 
6617c478bd9Sstevel@tonic-gate static const mdb_nv_disc_t kmt_reg_disc = {
662*0c1b95beSRichard Lowe 	.disc_get = kmt_reg_disc_get,
663*0c1b95beSRichard Lowe 	.disc_set = kmt_reg_disc_set
6647c478bd9Sstevel@tonic-gate };
6657c478bd9Sstevel@tonic-gate 
6667c478bd9Sstevel@tonic-gate /*ARGSUSED*/
6677c478bd9Sstevel@tonic-gate static int
kmt_getareg(mdb_tgt_t * t,mdb_tgt_tid_t tid,const char * rname,mdb_tgt_reg_t * rp)6687c478bd9Sstevel@tonic-gate kmt_getareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname,
6697c478bd9Sstevel@tonic-gate     mdb_tgt_reg_t *rp)
6707c478bd9Sstevel@tonic-gate {
6717c478bd9Sstevel@tonic-gate 	kreg_t val;
6727c478bd9Sstevel@tonic-gate 
6737c478bd9Sstevel@tonic-gate 	if (kmdb_dpi_get_register(rname, &val) < 0)
6747c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_BADREG));
6757c478bd9Sstevel@tonic-gate 
6767c478bd9Sstevel@tonic-gate 	*rp = val;
6777c478bd9Sstevel@tonic-gate 	return (0);
6787c478bd9Sstevel@tonic-gate }
6797c478bd9Sstevel@tonic-gate 
6807c478bd9Sstevel@tonic-gate /*ARGSUSED*/
6817c478bd9Sstevel@tonic-gate static int
kmt_putareg(mdb_tgt_t * t,mdb_tgt_tid_t tid,const char * rname,mdb_tgt_reg_t r)6827c478bd9Sstevel@tonic-gate kmt_putareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname, mdb_tgt_reg_t r)
6837c478bd9Sstevel@tonic-gate {
6847c478bd9Sstevel@tonic-gate 	if (kmdb_dpi_set_register(rname, r) < 0)
6857c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_BADREG));
6867c478bd9Sstevel@tonic-gate 
6877c478bd9Sstevel@tonic-gate 	return (0);
6887c478bd9Sstevel@tonic-gate }
6897c478bd9Sstevel@tonic-gate 
6907c478bd9Sstevel@tonic-gate static void
kmt_mod_destroy(kmt_module_t * km)6917c478bd9Sstevel@tonic-gate kmt_mod_destroy(kmt_module_t *km)
6927c478bd9Sstevel@tonic-gate {
6937c478bd9Sstevel@tonic-gate 	if (km->km_name != NULL)
6947c478bd9Sstevel@tonic-gate 		strfree(km->km_name);
6957c478bd9Sstevel@tonic-gate 	if (km->km_symtab != NULL)
6967c478bd9Sstevel@tonic-gate 		mdb_gelf_symtab_destroy(km->km_symtab);
6977c478bd9Sstevel@tonic-gate 	if (km->km_ctfp != NULL)
6987c478bd9Sstevel@tonic-gate 		mdb_ctf_close(km->km_ctfp);
6997c478bd9Sstevel@tonic-gate }
7007c478bd9Sstevel@tonic-gate 
7017c478bd9Sstevel@tonic-gate static kmt_module_t *
kmt_mod_create(mdb_tgt_t * t,struct modctl * ctlp,char * name)7027c478bd9Sstevel@tonic-gate kmt_mod_create(mdb_tgt_t *t, struct modctl *ctlp, char *name)
7037c478bd9Sstevel@tonic-gate {
7047c478bd9Sstevel@tonic-gate 	kmt_module_t *km = mdb_zalloc(sizeof (kmt_module_t), UM_SLEEP);
7057c478bd9Sstevel@tonic-gate 	struct module *mod;
7067c478bd9Sstevel@tonic-gate 
7077c478bd9Sstevel@tonic-gate 	km->km_name = mdb_alloc(strlen(name) + 1, UM_SLEEP);
70880148899SSurya Prakki 	(void) strcpy(km->km_name, name);
7097c478bd9Sstevel@tonic-gate 
7107c478bd9Sstevel@tonic-gate 	bcopy(ctlp, &km->km_modctl, sizeof (struct modctl));
7117c478bd9Sstevel@tonic-gate 
7127c478bd9Sstevel@tonic-gate 	if (mdb_tgt_vread(t, &km->km_module, sizeof (struct module),
7137c478bd9Sstevel@tonic-gate 	    (uintptr_t)km->km_modctl.mod_mp) != sizeof (struct module))
7147c478bd9Sstevel@tonic-gate 		goto create_module_cleanup;
7157c478bd9Sstevel@tonic-gate 	mod = &km->km_module;
7167c478bd9Sstevel@tonic-gate 
7177c478bd9Sstevel@tonic-gate 	if (mod->symhdr != NULL && mod->strhdr != NULL && mod->symtbl != NULL &&
7187c478bd9Sstevel@tonic-gate 	    mod->strings != NULL) {
7197c478bd9Sstevel@tonic-gate 		mdb_gelf_ehdr_to_gehdr(&mod->hdr, &km->km_ehdr);
7207c478bd9Sstevel@tonic-gate 
7217c478bd9Sstevel@tonic-gate 		km->km_symtab = mdb_gelf_symtab_create_raw(&km->km_ehdr,
7227c478bd9Sstevel@tonic-gate 		    mod->symhdr, mod->symtbl, mod->strhdr, mod->strings,
7237c478bd9Sstevel@tonic-gate 		    MDB_TGT_SYMTAB);
7247c478bd9Sstevel@tonic-gate 
7257c478bd9Sstevel@tonic-gate 		km->km_symtab_va = mod->symtbl;
7267c478bd9Sstevel@tonic-gate 		km->km_strtab_va = mod->strings;
7277c478bd9Sstevel@tonic-gate 
7287c478bd9Sstevel@tonic-gate 		if (mdb_tgt_vread(t, &km->km_symtab_hdr, sizeof (Shdr),
7297c478bd9Sstevel@tonic-gate 		    (uintptr_t)mod->symhdr) != sizeof (Shdr) ||
7307c478bd9Sstevel@tonic-gate 		    mdb_tgt_vread(t, &km->km_strtab_hdr, sizeof (Shdr),
7317c478bd9Sstevel@tonic-gate 		    (uintptr_t)mod->strhdr) != sizeof (Shdr))
7327c478bd9Sstevel@tonic-gate 			goto create_module_cleanup;
7337c478bd9Sstevel@tonic-gate 	}
7347c478bd9Sstevel@tonic-gate 
7357c478bd9Sstevel@tonic-gate 	/*
7367c478bd9Sstevel@tonic-gate 	 * We don't want everyone rooting around in the module structure, so we
7377c478bd9Sstevel@tonic-gate 	 * make copies of the interesting members.
7387c478bd9Sstevel@tonic-gate 	 */
7397c478bd9Sstevel@tonic-gate 	km->km_text_va = (uintptr_t)mod->text;
7407c478bd9Sstevel@tonic-gate 	km->km_text_size = mod->text_size;
7417c478bd9Sstevel@tonic-gate 	km->km_data_va = (uintptr_t)mod->data;
7427c478bd9Sstevel@tonic-gate 	km->km_data_size = mod->data_size;
7437c478bd9Sstevel@tonic-gate 	km->km_bss_va = (uintptr_t)mod->bss;
7447c478bd9Sstevel@tonic-gate 	km->km_bss_size = mod->bss_size;
7457c478bd9Sstevel@tonic-gate 	km->km_ctf_va = mod->ctfdata;
7467c478bd9Sstevel@tonic-gate 	km->km_ctf_size = mod->ctfsize;
7477c478bd9Sstevel@tonic-gate 
7487c478bd9Sstevel@tonic-gate 	if (mod->flags & KOBJ_PRIM)
7497c478bd9Sstevel@tonic-gate 		km->km_flags |= KM_F_PRIMARY;
7507c478bd9Sstevel@tonic-gate 
7517c478bd9Sstevel@tonic-gate 	return (km);
7527c478bd9Sstevel@tonic-gate 
7537c478bd9Sstevel@tonic-gate create_module_cleanup:
7547c478bd9Sstevel@tonic-gate 	warn("failed to read module %s\n", name);
7557c478bd9Sstevel@tonic-gate 	kmt_mod_destroy(km);
7567c478bd9Sstevel@tonic-gate 	return (NULL);
7577c478bd9Sstevel@tonic-gate }
7587c478bd9Sstevel@tonic-gate 
7597c478bd9Sstevel@tonic-gate static void
kmt_mod_remove(kmt_data_t * kmt,kmt_module_t * km)7607c478bd9Sstevel@tonic-gate kmt_mod_remove(kmt_data_t *kmt, kmt_module_t *km)
7617c478bd9Sstevel@tonic-gate {
7627c478bd9Sstevel@tonic-gate 	mdb_var_t *v = mdb_nv_lookup(&kmt->kmt_modules, km->km_name);
7637c478bd9Sstevel@tonic-gate 
7647c478bd9Sstevel@tonic-gate 	ASSERT(v != NULL);
7657c478bd9Sstevel@tonic-gate 
7667c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "removing module %s\n", km->km_name);
7677c478bd9Sstevel@tonic-gate 
7687c478bd9Sstevel@tonic-gate 	mdb_list_delete(&kmt->kmt_modlist, km);
7697c478bd9Sstevel@tonic-gate 	mdb_nv_remove(&kmt->kmt_modules, v);
7707c478bd9Sstevel@tonic-gate 	kmt_mod_destroy(km);
7717c478bd9Sstevel@tonic-gate }
7727c478bd9Sstevel@tonic-gate 
7737c478bd9Sstevel@tonic-gate static int
kmt_modlist_update_cb(struct modctl * modp,void * arg)7747c478bd9Sstevel@tonic-gate kmt_modlist_update_cb(struct modctl *modp, void *arg)
7757c478bd9Sstevel@tonic-gate {
7767c478bd9Sstevel@tonic-gate 	mdb_tgt_t *t = arg;
7777c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
7787c478bd9Sstevel@tonic-gate 	kmt_module_t *km;
7797c478bd9Sstevel@tonic-gate 	mdb_var_t *v;
7807c478bd9Sstevel@tonic-gate 	char name[MAXNAMELEN];
7817c478bd9Sstevel@tonic-gate 
7827c478bd9Sstevel@tonic-gate 	if (mdb_tgt_readstr(t, MDB_TGT_AS_VIRT, name, MAXNAMELEN,
7837c478bd9Sstevel@tonic-gate 	    (uintptr_t)modp->mod_modname) <= 0) {
7847c478bd9Sstevel@tonic-gate 		warn("failed to read module name at %p",
7857c478bd9Sstevel@tonic-gate 		    (void *)modp->mod_modname);
7867c478bd9Sstevel@tonic-gate 	}
7877c478bd9Sstevel@tonic-gate 
7887c478bd9Sstevel@tonic-gate 	/* We only care about modules that are actually loaded */
7897c478bd9Sstevel@tonic-gate 	if (!kmdb_kdi_mod_isloaded(modp))
7907c478bd9Sstevel@tonic-gate 		return (0);
7917c478bd9Sstevel@tonic-gate 
7927c478bd9Sstevel@tonic-gate 	/*
7937c478bd9Sstevel@tonic-gate 	 * Skip the modules we already know about and that haven't
7947c478bd9Sstevel@tonic-gate 	 * changed since last time we were here.
7957c478bd9Sstevel@tonic-gate 	 */
7967c478bd9Sstevel@tonic-gate 	if ((v = mdb_nv_lookup(&kmt->kmt_modules, name)) != NULL) {
7977c478bd9Sstevel@tonic-gate 		km = MDB_NV_COOKIE(v);
7987c478bd9Sstevel@tonic-gate 
7997c478bd9Sstevel@tonic-gate 		if (kmdb_kdi_mod_haschanged(&km->km_modctl, &km->km_module,
8007c478bd9Sstevel@tonic-gate 		    modp, modp->mod_mp)) {
8017c478bd9Sstevel@tonic-gate 			/*
8027c478bd9Sstevel@tonic-gate 			 * The module has changed since last we saw it.  For
8037c478bd9Sstevel@tonic-gate 			 * safety, remove our old version, and treat it as a
8047c478bd9Sstevel@tonic-gate 			 * new module.
8057c478bd9Sstevel@tonic-gate 			 */
8067c478bd9Sstevel@tonic-gate 			mdb_dprintf(MDB_DBG_KMOD, "stutter module %s\n", name);
8077c478bd9Sstevel@tonic-gate 			kmt_mod_remove(kmt, km);
8087c478bd9Sstevel@tonic-gate 		} else {
8097c478bd9Sstevel@tonic-gate 			km->km_seen = 1;
8107c478bd9Sstevel@tonic-gate 			return (0);
8117c478bd9Sstevel@tonic-gate 		}
8127c478bd9Sstevel@tonic-gate 	}
8137c478bd9Sstevel@tonic-gate 
8147c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "found new module %s\n", name);
8157c478bd9Sstevel@tonic-gate 
8167c478bd9Sstevel@tonic-gate 	if ((km = kmt_mod_create(t, modp, name)) != NULL) {
8177c478bd9Sstevel@tonic-gate 		mdb_list_append(&kmt->kmt_modlist, km);
8187c478bd9Sstevel@tonic-gate 		(void) mdb_nv_insert(&kmt->kmt_modules, name, NULL,
8197c478bd9Sstevel@tonic-gate 		    (uintptr_t)km, 0);
8207c478bd9Sstevel@tonic-gate 		km->km_seen = 1;
8217c478bd9Sstevel@tonic-gate 	}
8227c478bd9Sstevel@tonic-gate 
8237c478bd9Sstevel@tonic-gate 	return (0);
8247c478bd9Sstevel@tonic-gate }
8257c478bd9Sstevel@tonic-gate 
8267c478bd9Sstevel@tonic-gate static void
kmt_modlist_update(mdb_tgt_t * t)8277c478bd9Sstevel@tonic-gate kmt_modlist_update(mdb_tgt_t *t)
8287c478bd9Sstevel@tonic-gate {
8297c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
8307c478bd9Sstevel@tonic-gate 	kmt_module_t *km, *kmn;
8317c478bd9Sstevel@tonic-gate 
8327c478bd9Sstevel@tonic-gate 	if (kmdb_kdi_mod_iter(kmt_modlist_update_cb, t) < 0) {
8337c478bd9Sstevel@tonic-gate 		warn("failed to complete update of kernel module list\n");
8347c478bd9Sstevel@tonic-gate 		return;
8357c478bd9Sstevel@tonic-gate 	}
8367c478bd9Sstevel@tonic-gate 
8377c478bd9Sstevel@tonic-gate 	km = mdb_list_next(&kmt->kmt_modlist);
8387c478bd9Sstevel@tonic-gate 	while (km != NULL) {
8397c478bd9Sstevel@tonic-gate 		kmn = mdb_list_next(km);
8407c478bd9Sstevel@tonic-gate 
8417c478bd9Sstevel@tonic-gate 		if (km->km_seen == 1) {
8427c478bd9Sstevel@tonic-gate 			/* Reset the mark for next time */
8437c478bd9Sstevel@tonic-gate 			km->km_seen = 0;
8447c478bd9Sstevel@tonic-gate 		} else {
8457c478bd9Sstevel@tonic-gate 			/*
8467c478bd9Sstevel@tonic-gate 			 * We didn't see it on the kernel's module list, so
8477c478bd9Sstevel@tonic-gate 			 * remove it from our view of the world.
8487c478bd9Sstevel@tonic-gate 			 */
8497c478bd9Sstevel@tonic-gate 			kmt_mod_remove(kmt, km);
8507c478bd9Sstevel@tonic-gate 		}
8517c478bd9Sstevel@tonic-gate 
8527c478bd9Sstevel@tonic-gate 		km = kmn;
8537c478bd9Sstevel@tonic-gate 	}
8547c478bd9Sstevel@tonic-gate }
8557c478bd9Sstevel@tonic-gate 
8567c478bd9Sstevel@tonic-gate static void
kmt_periodic(mdb_tgt_t * t)8577c478bd9Sstevel@tonic-gate kmt_periodic(mdb_tgt_t *t)
8587c478bd9Sstevel@tonic-gate {
8597c478bd9Sstevel@tonic-gate 	(void) mdb_tgt_status(t, &t->t_status);
8607c478bd9Sstevel@tonic-gate }
8617c478bd9Sstevel@tonic-gate 
8627c478bd9Sstevel@tonic-gate 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)8637c478bd9Sstevel@tonic-gate kmt_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags,
8647c478bd9Sstevel@tonic-gate     char *buf, size_t nbytes, GElf_Sym *symp, mdb_syminfo_t *sip)
8657c478bd9Sstevel@tonic-gate {
8667c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
8677c478bd9Sstevel@tonic-gate 	kmt_module_t *km = mdb_list_next(&kmt->kmt_modlist);
8687c478bd9Sstevel@tonic-gate 	kmt_module_t *sym_km = NULL;
8697c478bd9Sstevel@tonic-gate 	kmt_module_t prmod;
8707c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
8717c478bd9Sstevel@tonic-gate 	uint_t symid;
8727c478bd9Sstevel@tonic-gate 	const char *name;
8737c478bd9Sstevel@tonic-gate 
8747c478bd9Sstevel@tonic-gate 	/*
8757c478bd9Sstevel@tonic-gate 	 * We look through the private symbols (if any), then through the module
8767c478bd9Sstevel@tonic-gate 	 * symbols.  We can simplify the loop if we pretend the private symbols
8777c478bd9Sstevel@tonic-gate 	 * come from a module.
8787c478bd9Sstevel@tonic-gate 	 */
8797c478bd9Sstevel@tonic-gate 	if (mdb.m_prsym != NULL) {
8807c478bd9Sstevel@tonic-gate 		bzero(&prmod, sizeof (kmt_module_t));
8817c478bd9Sstevel@tonic-gate 		prmod.km_name = "<<<prmod>>>";
8827c478bd9Sstevel@tonic-gate 		prmod.km_symtab = mdb.m_prsym;
8837c478bd9Sstevel@tonic-gate 		prmod.km_list.ml_next = (mdb_list_t *)km;
8847c478bd9Sstevel@tonic-gate 		km = &prmod;
8857c478bd9Sstevel@tonic-gate 	}
8867c478bd9Sstevel@tonic-gate 
8877c478bd9Sstevel@tonic-gate 	/* Symbol resolution isn't available during initialization */
8887c478bd9Sstevel@tonic-gate 	if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT)
8897c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_NOSYM));
8907c478bd9Sstevel@tonic-gate 
8917c478bd9Sstevel@tonic-gate 	for (; km != NULL; km = mdb_list_next(km)) {
8927c478bd9Sstevel@tonic-gate 		if (km != &prmod && !kmt->kmt_symavail)
8937c478bd9Sstevel@tonic-gate 			continue;
8947c478bd9Sstevel@tonic-gate 
8957c478bd9Sstevel@tonic-gate 		if (km->km_symtab == NULL)
8967c478bd9Sstevel@tonic-gate 			continue;
8977c478bd9Sstevel@tonic-gate 
8987c478bd9Sstevel@tonic-gate 		if (mdb_gelf_symtab_lookup_by_addr(km->km_symtab, addr, flags,
8997c478bd9Sstevel@tonic-gate 		    buf, nbytes, symp, &sip->sym_id) != 0 ||
9007c478bd9Sstevel@tonic-gate 		    symp->st_value == 0)
9017c478bd9Sstevel@tonic-gate 			continue;
9027c478bd9Sstevel@tonic-gate 
9037c478bd9Sstevel@tonic-gate 		if (flags & MDB_TGT_SYM_EXACT) {
9047c478bd9Sstevel@tonic-gate 			sym_km = km;
9057c478bd9Sstevel@tonic-gate 			goto found;
9067c478bd9Sstevel@tonic-gate 		}
9077c478bd9Sstevel@tonic-gate 
9087c478bd9Sstevel@tonic-gate 		/*
9097c478bd9Sstevel@tonic-gate 		 * If this is the first match we've found, or if this symbol is
9107c478bd9Sstevel@tonic-gate 		 * closer to the specified address than the last one we found,
9117c478bd9Sstevel@tonic-gate 		 * use it.
9127c478bd9Sstevel@tonic-gate 		 */
9137c478bd9Sstevel@tonic-gate 		if (sym_km == NULL || mdb_gelf_sym_closer(symp, &sym, addr)) {
9147c478bd9Sstevel@tonic-gate 			sym_km = km;
9157c478bd9Sstevel@tonic-gate 			sym = *symp;
9167c478bd9Sstevel@tonic-gate 			symid = sip->sym_id;
9177c478bd9Sstevel@tonic-gate 		}
9187c478bd9Sstevel@tonic-gate 	}
9197c478bd9Sstevel@tonic-gate 
9207c478bd9Sstevel@tonic-gate 	/*
9217c478bd9Sstevel@tonic-gate 	 * kmdb dmods are normal kernel modules, loaded by krtld as such.  To
9227c478bd9Sstevel@tonic-gate 	 * avoid polluting modinfo, and to keep from confusing the module
9237c478bd9Sstevel@tonic-gate 	 * subsystem (many dmods have the same names as real kernel modules),
9247c478bd9Sstevel@tonic-gate 	 * kmdb keeps their modctls separate, and doesn't allow their loading
9257c478bd9Sstevel@tonic-gate 	 * to be broadcast via the krtld module load/unload mechanism.  As a
9267c478bd9Sstevel@tonic-gate 	 * result, kmdb_kvm doesn't find out about them, and can't turn their
9277c478bd9Sstevel@tonic-gate 	 * addresses into symbols.  This can be most inconvenient during
9287c478bd9Sstevel@tonic-gate 	 * debugger faults, as the dmod frames will show up without names.
929acbc304dSjohnlev 	 * We weren't able to turn the requested address into a symbol, so we'll
9307c478bd9Sstevel@tonic-gate 	 * take a spin through the dmods, trying to match our address against
9317c478bd9Sstevel@tonic-gate 	 * their symbols.
9327c478bd9Sstevel@tonic-gate 	 */
9337c478bd9Sstevel@tonic-gate 	if (sym_km == NULL) {
9347c478bd9Sstevel@tonic-gate 		return (kmdb_module_lookup_by_addr(addr, flags, buf, nbytes,
9357c478bd9Sstevel@tonic-gate 		    symp, sip));
9367c478bd9Sstevel@tonic-gate 	}
9377c478bd9Sstevel@tonic-gate 
9387c478bd9Sstevel@tonic-gate 	*symp = sym;
9397c478bd9Sstevel@tonic-gate 	sip->sym_id = symid;
9407c478bd9Sstevel@tonic-gate 
9417c478bd9Sstevel@tonic-gate found:
9427c478bd9Sstevel@tonic-gate 	/*
9437c478bd9Sstevel@tonic-gate 	 * Once we've found something, copy the final name into the caller's
9447c478bd9Sstevel@tonic-gate 	 * buffer and prefix it with the load object name if appropriate.
9457c478bd9Sstevel@tonic-gate 	 */
9467c478bd9Sstevel@tonic-gate 	name = mdb_gelf_sym_name(sym_km->km_symtab, symp);
9477c478bd9Sstevel@tonic-gate 
9487c478bd9Sstevel@tonic-gate 	if (sym_km == &prmod) {
9497c478bd9Sstevel@tonic-gate 		if (buf != NULL) {
9507c478bd9Sstevel@tonic-gate 			(void) strncpy(buf, name, nbytes);
9517c478bd9Sstevel@tonic-gate 			buf[nbytes - 1] = '\0';
9527c478bd9Sstevel@tonic-gate 		}
9537c478bd9Sstevel@tonic-gate 		sip->sym_table = MDB_TGT_PRVSYM;
9547c478bd9Sstevel@tonic-gate 	} else {
9557c478bd9Sstevel@tonic-gate 		if (buf != NULL) {
9567c478bd9Sstevel@tonic-gate 			if (sym_km->km_flags & KM_F_PRIMARY) {
9577c478bd9Sstevel@tonic-gate 				(void) strncpy(buf, name, nbytes);
9587c478bd9Sstevel@tonic-gate 				buf[nbytes - 1] = '\0';
9597c478bd9Sstevel@tonic-gate 			} else {
9607c478bd9Sstevel@tonic-gate 				(void) mdb_snprintf(buf, nbytes, "%s`%s",
9617c478bd9Sstevel@tonic-gate 				    sym_km->km_name, name);
9627c478bd9Sstevel@tonic-gate 			}
9637c478bd9Sstevel@tonic-gate 		}
9647c478bd9Sstevel@tonic-gate 		sip->sym_table = MDB_TGT_SYMTAB;
9657c478bd9Sstevel@tonic-gate 	}
9667c478bd9Sstevel@tonic-gate 
9677c478bd9Sstevel@tonic-gate 	return (0);
9687c478bd9Sstevel@tonic-gate }
9697c478bd9Sstevel@tonic-gate 
9707c478bd9Sstevel@tonic-gate static int
kmt_lookup_by_name(mdb_tgt_t * t,const char * obj,const char * name,GElf_Sym * symp,mdb_syminfo_t * sip)9717c478bd9Sstevel@tonic-gate kmt_lookup_by_name(mdb_tgt_t *t, const char *obj, const char *name,
9727c478bd9Sstevel@tonic-gate     GElf_Sym *symp, mdb_syminfo_t *sip)
9737c478bd9Sstevel@tonic-gate {
9747c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
9757c478bd9Sstevel@tonic-gate 	kmt_module_t *km;
9767c478bd9Sstevel@tonic-gate 	mdb_var_t *v;
9777c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
9787c478bd9Sstevel@tonic-gate 	uint_t symid;
9797c478bd9Sstevel@tonic-gate 	int n;
9807c478bd9Sstevel@tonic-gate 
9817c478bd9Sstevel@tonic-gate 	if (!kmt->kmt_symavail)
9827c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_NOSYM));
9837c478bd9Sstevel@tonic-gate 
9847c478bd9Sstevel@tonic-gate 	switch ((uintptr_t)obj) {
9857c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_OBJ_EXEC:
9867c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_OBJ_EVERY:
9877c478bd9Sstevel@tonic-gate 		km = mdb_list_next(&kmt->kmt_modlist);
9887c478bd9Sstevel@tonic-gate 		n = mdb_nv_size(&kmt->kmt_modules);
9897c478bd9Sstevel@tonic-gate 		break;
9907c478bd9Sstevel@tonic-gate 
9917c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_OBJ_RTLD:
992ae115bc7Smrj 		obj = kmt->kmt_rtld_name;
9937c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
9947c478bd9Sstevel@tonic-gate 
9957c478bd9Sstevel@tonic-gate 	default:
9967c478bd9Sstevel@tonic-gate 		/*
9977c478bd9Sstevel@tonic-gate 		 * If this is a request for a dmod symbol, let kmdb_module
9987c478bd9Sstevel@tonic-gate 		 * handle it.
9997c478bd9Sstevel@tonic-gate 		 */
10007c478bd9Sstevel@tonic-gate 		if (obj != NULL && strncmp(obj, "DMOD`", 5) == 0) {
10017c478bd9Sstevel@tonic-gate 			return (kmdb_module_lookup_by_name(obj + 5, name,
10027c478bd9Sstevel@tonic-gate 			    symp, sip));
10037c478bd9Sstevel@tonic-gate 		}
10047c478bd9Sstevel@tonic-gate 
10057c478bd9Sstevel@tonic-gate 		if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL)
10067c478bd9Sstevel@tonic-gate 			return (set_errno(EMDB_NOOBJ));
10077c478bd9Sstevel@tonic-gate 
10087c478bd9Sstevel@tonic-gate 		km = mdb_nv_get_cookie(v);
10097c478bd9Sstevel@tonic-gate 		n = 1;
10107c478bd9Sstevel@tonic-gate 	}
10117c478bd9Sstevel@tonic-gate 
10127c478bd9Sstevel@tonic-gate 	/*
10137c478bd9Sstevel@tonic-gate 	 * kmdb's kvm target is at a bit of a disadvantage compared to mdb's
10147c478bd9Sstevel@tonic-gate 	 * kvm target when it comes to global symbol lookups.  mdb has ksyms,
10157c478bd9Sstevel@tonic-gate 	 * which hides pesky things like symbols that are undefined in unix,
10167c478bd9Sstevel@tonic-gate 	 * but which are defined in genunix.  We don't have such a facility -
10177c478bd9Sstevel@tonic-gate 	 * we simply iterate through the modules, looking for a given symbol
10187c478bd9Sstevel@tonic-gate 	 * in each.  Unless we're careful, we'll return the undef in the
10197c478bd9Sstevel@tonic-gate 	 * aforementioned case.
10207c478bd9Sstevel@tonic-gate 	 */
10217c478bd9Sstevel@tonic-gate 	for (; n > 0; n--, km = mdb_list_next(km)) {
10227c478bd9Sstevel@tonic-gate 		if (mdb_gelf_symtab_lookup_by_name(km->km_symtab, name,
10237c478bd9Sstevel@tonic-gate 		    &sym, &symid) == 0 && sym.st_shndx != SHN_UNDEF)
10247c478bd9Sstevel@tonic-gate 			break;
10257c478bd9Sstevel@tonic-gate 	}
10267c478bd9Sstevel@tonic-gate 
10277c478bd9Sstevel@tonic-gate 	if (n == 0)
10287c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_NOSYM));
10297c478bd9Sstevel@tonic-gate 
10307c478bd9Sstevel@tonic-gate found:
10317c478bd9Sstevel@tonic-gate 	bcopy(&sym, symp, sizeof (GElf_Sym));
10327c478bd9Sstevel@tonic-gate 	sip->sym_id = symid;
10337c478bd9Sstevel@tonic-gate 	sip->sym_table = MDB_TGT_SYMTAB;
10347c478bd9Sstevel@tonic-gate 
10357c478bd9Sstevel@tonic-gate 	return (0);
10367c478bd9Sstevel@tonic-gate }
10377c478bd9Sstevel@tonic-gate 
10387c478bd9Sstevel@tonic-gate static int
kmt_symtab_func(void * data,const GElf_Sym * sym,const char * name,uint_t id)10397c478bd9Sstevel@tonic-gate kmt_symtab_func(void *data, const GElf_Sym *sym, const char *name, uint_t id)
10407c478bd9Sstevel@tonic-gate {
10417c478bd9Sstevel@tonic-gate 	kmt_symarg_t *arg = data;
10427c478bd9Sstevel@tonic-gate 
10437c478bd9Sstevel@tonic-gate 	if (mdb_tgt_sym_match(sym, arg->sym_type)) {
10447c478bd9Sstevel@tonic-gate 		arg->sym_info.sym_id = id;
10457c478bd9Sstevel@tonic-gate 
10467c478bd9Sstevel@tonic-gate 		return (arg->sym_cb(arg->sym_data, sym, name, &arg->sym_info,
10477c478bd9Sstevel@tonic-gate 		    arg->sym_obj));
10487c478bd9Sstevel@tonic-gate 	}
10497c478bd9Sstevel@tonic-gate 
10507c478bd9Sstevel@tonic-gate 	return (0);
10517c478bd9Sstevel@tonic-gate }
10527c478bd9Sstevel@tonic-gate 
10537c478bd9Sstevel@tonic-gate static void
kmt_symtab_iter(mdb_gelf_symtab_t * gst,uint_t type,const char * obj,mdb_tgt_sym_f * cb,void * p)10547c478bd9Sstevel@tonic-gate kmt_symtab_iter(mdb_gelf_symtab_t *gst, uint_t type, const char *obj,
10557c478bd9Sstevel@tonic-gate     mdb_tgt_sym_f *cb, void *p)
10567c478bd9Sstevel@tonic-gate {
10577c478bd9Sstevel@tonic-gate 	kmt_symarg_t arg;
10587c478bd9Sstevel@tonic-gate 
10597c478bd9Sstevel@tonic-gate 	arg.sym_cb = cb;
10607c478bd9Sstevel@tonic-gate 	arg.sym_data = p;
10617c478bd9Sstevel@tonic-gate 	arg.sym_type = type;
10627c478bd9Sstevel@tonic-gate 	arg.sym_info.sym_table = gst->gst_tabid;
10637c478bd9Sstevel@tonic-gate 	arg.sym_obj = obj;
10647c478bd9Sstevel@tonic-gate 
10657c478bd9Sstevel@tonic-gate 	mdb_gelf_symtab_iter(gst, kmt_symtab_func, &arg);
10667c478bd9Sstevel@tonic-gate }
10677c478bd9Sstevel@tonic-gate 
10687c478bd9Sstevel@tonic-gate 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)10697c478bd9Sstevel@tonic-gate kmt_symbol_iter(mdb_tgt_t *t, const char *obj, uint_t which, uint_t type,
10707c478bd9Sstevel@tonic-gate     mdb_tgt_sym_f *cb, void *data)
10717c478bd9Sstevel@tonic-gate {
10727c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
10737c478bd9Sstevel@tonic-gate 	kmt_module_t *km;
10747c478bd9Sstevel@tonic-gate 
10757c478bd9Sstevel@tonic-gate 	mdb_gelf_symtab_t *symtab = NULL;
10767c478bd9Sstevel@tonic-gate 	mdb_var_t *v;
10777c478bd9Sstevel@tonic-gate 
10787c478bd9Sstevel@tonic-gate 	if (which == MDB_TGT_DYNSYM)
10797c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_TGTNOTSUP));
10807c478bd9Sstevel@tonic-gate 
10817c478bd9Sstevel@tonic-gate 	switch ((uintptr_t)obj) {
10827c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_OBJ_EXEC:
10837c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_OBJ_EVERY:
10847c478bd9Sstevel@tonic-gate 		mdb_nv_rewind(&kmt->kmt_modules);
10857c478bd9Sstevel@tonic-gate 		while ((v = mdb_nv_advance(&kmt->kmt_modules)) != NULL) {
10867c478bd9Sstevel@tonic-gate 			km = mdb_nv_get_cookie(v);
10877c478bd9Sstevel@tonic-gate 
10887c478bd9Sstevel@tonic-gate 			if (km->km_symtab != NULL) {
10897c478bd9Sstevel@tonic-gate 				kmt_symtab_iter(km->km_symtab, type,
10907c478bd9Sstevel@tonic-gate 				    km->km_name, cb, data);
10917c478bd9Sstevel@tonic-gate 			}
10927c478bd9Sstevel@tonic-gate 		}
10937c478bd9Sstevel@tonic-gate 		return (0);
10947c478bd9Sstevel@tonic-gate 
10957c478bd9Sstevel@tonic-gate 	case (uintptr_t)MDB_TGT_OBJ_RTLD:
1096ae115bc7Smrj 		obj = kmt->kmt_rtld_name;
10977c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
10987c478bd9Sstevel@tonic-gate 
10997c478bd9Sstevel@tonic-gate 	default:
11007c478bd9Sstevel@tonic-gate 		if (strncmp(obj, "DMOD`", 5) == 0) {
11017c478bd9Sstevel@tonic-gate 			return (kmdb_module_symbol_iter(obj + 5, type,
11027c478bd9Sstevel@tonic-gate 			    cb, data));
11037c478bd9Sstevel@tonic-gate 		}
11047c478bd9Sstevel@tonic-gate 
11057c478bd9Sstevel@tonic-gate 		if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL)
11067c478bd9Sstevel@tonic-gate 			return (set_errno(EMDB_NOOBJ));
11077c478bd9Sstevel@tonic-gate 		km = mdb_nv_get_cookie(v);
11087c478bd9Sstevel@tonic-gate 
11097c478bd9Sstevel@tonic-gate 		symtab = km->km_symtab;
11107c478bd9Sstevel@tonic-gate 	}
11117c478bd9Sstevel@tonic-gate 
11127c478bd9Sstevel@tonic-gate 	if (symtab != NULL)
11137c478bd9Sstevel@tonic-gate 		kmt_symtab_iter(symtab, type, obj, cb, data);
11147c478bd9Sstevel@tonic-gate 
11157c478bd9Sstevel@tonic-gate 	return (0);
11167c478bd9Sstevel@tonic-gate }
11177c478bd9Sstevel@tonic-gate 
11187c478bd9Sstevel@tonic-gate static int
kmt_mapping_walk(uintptr_t addr,const void * data,kmt_maparg_t * marg)11197c478bd9Sstevel@tonic-gate kmt_mapping_walk(uintptr_t addr, const void *data, kmt_maparg_t *marg)
11207c478bd9Sstevel@tonic-gate {
11217c478bd9Sstevel@tonic-gate 	/*
11227c478bd9Sstevel@tonic-gate 	 * This is a bit sketchy but avoids problematic compilation of this
11237c478bd9Sstevel@tonic-gate 	 * target against the current VM implementation.  Now that we have
11247c478bd9Sstevel@tonic-gate 	 * vmem, we can make this less broken and more informative by changing
11257c478bd9Sstevel@tonic-gate 	 * this code to invoke the vmem walker in the near future.
11267c478bd9Sstevel@tonic-gate 	 */
11277c478bd9Sstevel@tonic-gate 	const struct kmt_seg {
11287c478bd9Sstevel@tonic-gate 		caddr_t s_base;
11297c478bd9Sstevel@tonic-gate 		size_t s_size;
11307c478bd9Sstevel@tonic-gate 	} *segp = (const struct kmt_seg *)data;
11317c478bd9Sstevel@tonic-gate 
11327c478bd9Sstevel@tonic-gate 	mdb_map_t map;
11337c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
11347c478bd9Sstevel@tonic-gate 	mdb_syminfo_t info;
11357c478bd9Sstevel@tonic-gate 
11367c478bd9Sstevel@tonic-gate 	map.map_base = (uintptr_t)segp->s_base;
11377c478bd9Sstevel@tonic-gate 	map.map_size = segp->s_size;
11387c478bd9Sstevel@tonic-gate 	map.map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X;
11397c478bd9Sstevel@tonic-gate 
11407c478bd9Sstevel@tonic-gate 	if (kmt_lookup_by_addr(marg->map_target, addr, MDB_TGT_SYM_EXACT,
11417c478bd9Sstevel@tonic-gate 	    map.map_name, MDB_TGT_MAPSZ, &sym, &info) == -1) {
11427c478bd9Sstevel@tonic-gate 
11437c478bd9Sstevel@tonic-gate 		(void) mdb_iob_snprintf(map.map_name, MDB_TGT_MAPSZ,
11447c478bd9Sstevel@tonic-gate 		    "%lr", addr);
11457c478bd9Sstevel@tonic-gate 	}
11467c478bd9Sstevel@tonic-gate 
11477c478bd9Sstevel@tonic-gate 	return (marg->map_cb(marg->map_data, &map, map.map_name));
11487c478bd9Sstevel@tonic-gate }
11497c478bd9Sstevel@tonic-gate 
11507c478bd9Sstevel@tonic-gate static int
kmt_mapping_iter(mdb_tgt_t * t,mdb_tgt_map_f * func,void * private)11517c478bd9Sstevel@tonic-gate kmt_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
11527c478bd9Sstevel@tonic-gate {
11537c478bd9Sstevel@tonic-gate 	kmt_maparg_t m;
11547c478bd9Sstevel@tonic-gate 	uintptr_t kas;
11557c478bd9Sstevel@tonic-gate 
11567c478bd9Sstevel@tonic-gate 	m.map_target = t;
11577c478bd9Sstevel@tonic-gate 	m.map_cb = func;
11587c478bd9Sstevel@tonic-gate 	m.map_data = private;
11597c478bd9Sstevel@tonic-gate 
1160892ad162SToomas Soome 	if ((kas = kmt_read_kas(t)) == 0)
11617c478bd9Sstevel@tonic-gate 		return (-1); /* errno is set for us */
11627c478bd9Sstevel@tonic-gate 
11637c478bd9Sstevel@tonic-gate 	return (mdb_pwalk("seg", (mdb_walk_cb_t)kmt_mapping_walk, &m, kas));
11647c478bd9Sstevel@tonic-gate }
11657c478bd9Sstevel@tonic-gate 
11667c478bd9Sstevel@tonic-gate static const mdb_map_t *
kmt_mod_to_map(kmt_module_t * km,mdb_map_t * map)11677c478bd9Sstevel@tonic-gate kmt_mod_to_map(kmt_module_t *km, mdb_map_t *map)
11687c478bd9Sstevel@tonic-gate {
11697c478bd9Sstevel@tonic-gate 	(void) strncpy(map->map_name, km->km_name, MDB_TGT_MAPSZ);
11707c478bd9Sstevel@tonic-gate 	map->map_name[MDB_TGT_MAPSZ - 1] = '\0';
11717c478bd9Sstevel@tonic-gate 	map->map_base = km->km_text_va;
11727c478bd9Sstevel@tonic-gate 	map->map_size = km->km_text_size;
11737c478bd9Sstevel@tonic-gate 	map->map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X;
11747c478bd9Sstevel@tonic-gate 
11757c478bd9Sstevel@tonic-gate 	return (map);
11767c478bd9Sstevel@tonic-gate }
11777c478bd9Sstevel@tonic-gate 
11787c478bd9Sstevel@tonic-gate static int
kmt_object_iter(mdb_tgt_t * t,mdb_tgt_map_f * func,void * private)11797c478bd9Sstevel@tonic-gate kmt_object_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
11807c478bd9Sstevel@tonic-gate {
11817c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
11827c478bd9Sstevel@tonic-gate 	kmt_module_t *km;
11837c478bd9Sstevel@tonic-gate 	mdb_map_t m;
11847c478bd9Sstevel@tonic-gate 
11857c478bd9Sstevel@tonic-gate 	for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
11867c478bd9Sstevel@tonic-gate 	    km = mdb_list_next(km)) {
11877c478bd9Sstevel@tonic-gate 		if (func(private, kmt_mod_to_map(km, &m), km->km_name) == -1)
11887c478bd9Sstevel@tonic-gate 			break;
11897c478bd9Sstevel@tonic-gate 	}
11907c478bd9Sstevel@tonic-gate 
11917c478bd9Sstevel@tonic-gate 	return (0);
11927c478bd9Sstevel@tonic-gate }
11937c478bd9Sstevel@tonic-gate 
11947c478bd9Sstevel@tonic-gate static const mdb_map_t *
kmt_addr_to_map(mdb_tgt_t * t,uintptr_t addr)11957c478bd9Sstevel@tonic-gate kmt_addr_to_map(mdb_tgt_t *t, uintptr_t addr)
11967c478bd9Sstevel@tonic-gate {
11977c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
11987c478bd9Sstevel@tonic-gate 	kmt_module_t *km;
11997c478bd9Sstevel@tonic-gate 
12007c478bd9Sstevel@tonic-gate 	for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
12017c478bd9Sstevel@tonic-gate 	    km = mdb_list_next(km)) {
12027c478bd9Sstevel@tonic-gate 		if (addr - km->km_text_va < km->km_text_size ||
12037c478bd9Sstevel@tonic-gate 		    addr - km->km_data_va < km->km_data_size ||
12047c478bd9Sstevel@tonic-gate 		    addr - km->km_bss_va < km->km_bss_size)
12057c478bd9Sstevel@tonic-gate 			return (kmt_mod_to_map(km, &kmt->kmt_map));
12067c478bd9Sstevel@tonic-gate 	}
12077c478bd9Sstevel@tonic-gate 
12087c478bd9Sstevel@tonic-gate 	(void) set_errno(EMDB_NOMAP);
12097c478bd9Sstevel@tonic-gate 	return (NULL);
12107c478bd9Sstevel@tonic-gate }
12117c478bd9Sstevel@tonic-gate 
1212ae115bc7Smrj static kmt_module_t *
kmt_module_by_name(kmt_data_t * kmt,const char * name)1213ae115bc7Smrj kmt_module_by_name(kmt_data_t *kmt, const char *name)
1214ae115bc7Smrj {
1215ae115bc7Smrj 	kmt_module_t *km;
1216ae115bc7Smrj 
1217ae115bc7Smrj 	for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
1218ae115bc7Smrj 	    km = mdb_list_next(km)) {
1219ae115bc7Smrj 		if (strcmp(name, km->km_name) == 0)
1220ae115bc7Smrj 			return (km);
1221ae115bc7Smrj 	}
1222ae115bc7Smrj 
1223ae115bc7Smrj 	return (NULL);
1224ae115bc7Smrj }
1225ae115bc7Smrj 
12267c478bd9Sstevel@tonic-gate static const mdb_map_t *
kmt_name_to_map(mdb_tgt_t * t,const char * name)12277c478bd9Sstevel@tonic-gate kmt_name_to_map(mdb_tgt_t *t, const char *name)
12287c478bd9Sstevel@tonic-gate {
12297c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
12307c478bd9Sstevel@tonic-gate 	kmt_module_t *km;
12317c478bd9Sstevel@tonic-gate 	mdb_map_t m;
12327c478bd9Sstevel@tonic-gate 
12337c478bd9Sstevel@tonic-gate 	/*
12347c478bd9Sstevel@tonic-gate 	 * If name is MDB_TGT_OBJ_EXEC, return the first module on the list,
12357c478bd9Sstevel@tonic-gate 	 * which will be unix since we keep kmt_modlist in load order.
12367c478bd9Sstevel@tonic-gate 	 */
12377c478bd9Sstevel@tonic-gate 	if (name == MDB_TGT_OBJ_EXEC) {
12387c478bd9Sstevel@tonic-gate 		return (kmt_mod_to_map(mdb_list_next(&kmt->kmt_modlist),
12397c478bd9Sstevel@tonic-gate 		    &m));
12407c478bd9Sstevel@tonic-gate 	}
12417c478bd9Sstevel@tonic-gate 
12427c478bd9Sstevel@tonic-gate 	if (name == MDB_TGT_OBJ_RTLD)
1243ae115bc7Smrj 		name = kmt->kmt_rtld_name;
12447c478bd9Sstevel@tonic-gate 
1245ae115bc7Smrj 	if ((km = kmt_module_by_name(kmt, name)) != NULL)
1246ae115bc7Smrj 		return (kmt_mod_to_map(km, &m));
12477c478bd9Sstevel@tonic-gate 
12487c478bd9Sstevel@tonic-gate 	(void) set_errno(EMDB_NOOBJ);
12497c478bd9Sstevel@tonic-gate 	return (NULL);
12507c478bd9Sstevel@tonic-gate }
12517c478bd9Sstevel@tonic-gate 
12527c478bd9Sstevel@tonic-gate static ctf_file_t *
kmt_load_ctfdata(mdb_tgt_t * t,kmt_module_t * km)12537c478bd9Sstevel@tonic-gate kmt_load_ctfdata(mdb_tgt_t *t, kmt_module_t *km)
12547c478bd9Sstevel@tonic-gate {
12557c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
12567c478bd9Sstevel@tonic-gate 	int err;
12577c478bd9Sstevel@tonic-gate 
12587c478bd9Sstevel@tonic-gate 	if (km->km_ctfp != NULL)
12597c478bd9Sstevel@tonic-gate 		return (km->km_ctfp);
12607c478bd9Sstevel@tonic-gate 
12617c478bd9Sstevel@tonic-gate 	if (km->km_ctf_va == NULL || km->km_symtab == NULL) {
12627c478bd9Sstevel@tonic-gate 		(void) set_errno(EMDB_NOCTF);
12637c478bd9Sstevel@tonic-gate 		return (NULL);
12647c478bd9Sstevel@tonic-gate 	}
12657c478bd9Sstevel@tonic-gate 
12667c478bd9Sstevel@tonic-gate 	if ((km->km_ctfp = mdb_ctf_bufopen(km->km_ctf_va, km->km_ctf_size,
12677c478bd9Sstevel@tonic-gate 	    km->km_symtab_va, &km->km_symtab_hdr, km->km_strtab_va,
12687c478bd9Sstevel@tonic-gate 	    &km->km_strtab_hdr, &err)) == NULL) {
12697c478bd9Sstevel@tonic-gate 		(void) set_errno(ctf_to_errno(err));
12707c478bd9Sstevel@tonic-gate 		return (NULL);
12717c478bd9Sstevel@tonic-gate 	}
12727c478bd9Sstevel@tonic-gate 
12737c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "loaded %lu bytes of CTF data for %s\n",
12747c478bd9Sstevel@tonic-gate 	    (ulong_t)km->km_ctf_size, km->km_name);
12757c478bd9Sstevel@tonic-gate 
12767c478bd9Sstevel@tonic-gate 	if (ctf_parent_name(km->km_ctfp) != NULL) {
12777c478bd9Sstevel@tonic-gate 		mdb_var_t *v;
12787c478bd9Sstevel@tonic-gate 
12797c478bd9Sstevel@tonic-gate 		if ((v = mdb_nv_lookup(&kmt->kmt_modules,
12807c478bd9Sstevel@tonic-gate 		    ctf_parent_name(km->km_ctfp))) != NULL) {
12817c478bd9Sstevel@tonic-gate 			kmt_module_t *pm = mdb_nv_get_cookie(v);
12827c478bd9Sstevel@tonic-gate 
12837c478bd9Sstevel@tonic-gate 			if (pm->km_ctfp == NULL)
12847c478bd9Sstevel@tonic-gate 				(void) kmt_load_ctfdata(t, pm);
12857c478bd9Sstevel@tonic-gate 
12867c478bd9Sstevel@tonic-gate 			if (pm->km_ctfp != NULL && ctf_import(km->km_ctfp,
12877c478bd9Sstevel@tonic-gate 			    pm->km_ctfp) == CTF_ERR) {
12887c478bd9Sstevel@tonic-gate 				warn("failed to import parent types into "
12897c478bd9Sstevel@tonic-gate 				    "%s: %s\n", km->km_name,
12907c478bd9Sstevel@tonic-gate 				    ctf_errmsg(ctf_errno(km->km_ctfp)));
12917c478bd9Sstevel@tonic-gate 			}
12927c478bd9Sstevel@tonic-gate 		} else {
12937c478bd9Sstevel@tonic-gate 			warn("failed to load CTF data for %s - parent %s not "
12947c478bd9Sstevel@tonic-gate 			    "loaded\n", km->km_name,
12957c478bd9Sstevel@tonic-gate 			    ctf_parent_name(km->km_ctfp));
12967c478bd9Sstevel@tonic-gate 		}
12977c478bd9Sstevel@tonic-gate 	}
12987c478bd9Sstevel@tonic-gate 
12997c478bd9Sstevel@tonic-gate 	return (km->km_ctfp);
13007c478bd9Sstevel@tonic-gate }
13017c478bd9Sstevel@tonic-gate 
13027c478bd9Sstevel@tonic-gate ctf_file_t *
kmt_addr_to_ctf(mdb_tgt_t * t,uintptr_t addr)13037c478bd9Sstevel@tonic-gate kmt_addr_to_ctf(mdb_tgt_t *t, uintptr_t addr)
13047c478bd9Sstevel@tonic-gate {
13057c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
13067c478bd9Sstevel@tonic-gate 	kmt_module_t *km;
13077c478bd9Sstevel@tonic-gate 
13087c478bd9Sstevel@tonic-gate 	for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
13097c478bd9Sstevel@tonic-gate 	    km = mdb_list_next(km)) {
13107c478bd9Sstevel@tonic-gate 		if (addr - km->km_text_va < km->km_text_size ||
13117c478bd9Sstevel@tonic-gate 		    addr - km->km_data_va < km->km_data_size ||
13127c478bd9Sstevel@tonic-gate 		    addr - km->km_bss_va < km->km_bss_size)
13137c478bd9Sstevel@tonic-gate 			return (kmt_load_ctfdata(t, km));
13147c478bd9Sstevel@tonic-gate 	}
13157c478bd9Sstevel@tonic-gate 
13165ae68c69Sjohnlev 	return (kmdb_module_addr_to_ctf(addr));
13177c478bd9Sstevel@tonic-gate }
13187c478bd9Sstevel@tonic-gate 
13197c478bd9Sstevel@tonic-gate ctf_file_t *
kmt_name_to_ctf(mdb_tgt_t * t,const char * name)13207c478bd9Sstevel@tonic-gate kmt_name_to_ctf(mdb_tgt_t *t, const char *name)
13217c478bd9Sstevel@tonic-gate {
13227c478bd9Sstevel@tonic-gate 	kmt_data_t *kt = t->t_data;
13237c478bd9Sstevel@tonic-gate 	kmt_module_t *km;
13247c478bd9Sstevel@tonic-gate 
13255ae68c69Sjohnlev 	if (name == MDB_TGT_OBJ_EXEC) {
1326ae115bc7Smrj 		name = KMT_CTFPARENT;
13275ae68c69Sjohnlev 	} else if (name == MDB_TGT_OBJ_RTLD) {
1328ae115bc7Smrj 		name = kt->kmt_rtld_name;
13295ae68c69Sjohnlev 	} else if (strncmp(name, "DMOD`", 5) == 0) {
13305ae68c69Sjohnlev 		/* Request for CTF data for a DMOD symbol */
13315ae68c69Sjohnlev 		return (kmdb_module_name_to_ctf(name + 5));
13325ae68c69Sjohnlev 	}
13337c478bd9Sstevel@tonic-gate 
1334ae115bc7Smrj 	if ((km = kmt_module_by_name(kt, name)) != NULL)
1335ae115bc7Smrj 		return (kmt_load_ctfdata(t, km));
13367c478bd9Sstevel@tonic-gate 
13377c478bd9Sstevel@tonic-gate 	(void) set_errno(EMDB_NOOBJ);
13387c478bd9Sstevel@tonic-gate 	return (NULL);
13397c478bd9Sstevel@tonic-gate }
13407c478bd9Sstevel@tonic-gate 
13417c478bd9Sstevel@tonic-gate /*ARGSUSED*/
13427c478bd9Sstevel@tonic-gate static int
kmt_status(mdb_tgt_t * t,mdb_tgt_status_t * tsp)13437c478bd9Sstevel@tonic-gate kmt_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
13447c478bd9Sstevel@tonic-gate {
13457c478bd9Sstevel@tonic-gate 	int state;
13467c478bd9Sstevel@tonic-gate 
13477c478bd9Sstevel@tonic-gate 	bzero(tsp, sizeof (mdb_tgt_status_t));
13487c478bd9Sstevel@tonic-gate 
13497c478bd9Sstevel@tonic-gate 	switch ((state = kmdb_dpi_get_state(NULL))) {
13507c478bd9Sstevel@tonic-gate 	case DPI_STATE_INIT:
13517c478bd9Sstevel@tonic-gate 		tsp->st_state = MDB_TGT_RUNNING;
13527c478bd9Sstevel@tonic-gate 		tsp->st_pc = 0;
13537c478bd9Sstevel@tonic-gate 		break;
13547c478bd9Sstevel@tonic-gate 
13557c478bd9Sstevel@tonic-gate 	case DPI_STATE_STOPPED:
13567c478bd9Sstevel@tonic-gate 		tsp->st_state = MDB_TGT_STOPPED;
13577c478bd9Sstevel@tonic-gate 
13587c478bd9Sstevel@tonic-gate 		(void) kmdb_dpi_get_register("pc", &tsp->st_pc);
13597c478bd9Sstevel@tonic-gate 		break;
13607c478bd9Sstevel@tonic-gate 
13617c478bd9Sstevel@tonic-gate 	case DPI_STATE_FAULTED:
13627c478bd9Sstevel@tonic-gate 		tsp->st_state = MDB_TGT_STOPPED;
13637c478bd9Sstevel@tonic-gate 
13647c478bd9Sstevel@tonic-gate 		(void) kmdb_dpi_get_register("pc", &tsp->st_pc);
13657c478bd9Sstevel@tonic-gate 
13667c478bd9Sstevel@tonic-gate 		tsp->st_flags |= MDB_TGT_ISTOP;
13677c478bd9Sstevel@tonic-gate 		break;
13687c478bd9Sstevel@tonic-gate 
13697c478bd9Sstevel@tonic-gate 	case DPI_STATE_LOST:
13707c478bd9Sstevel@tonic-gate 		tsp->st_state = MDB_TGT_LOST;
13717c478bd9Sstevel@tonic-gate 
13727c478bd9Sstevel@tonic-gate 		(void) kmdb_dpi_get_register("pc", &tsp->st_pc);
13737c478bd9Sstevel@tonic-gate 		break;
13747c478bd9Sstevel@tonic-gate 	}
13757c478bd9Sstevel@tonic-gate 
13767c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "kmt_status, dpi: %d tsp: %d, pc = %p %A\n",
13777c478bd9Sstevel@tonic-gate 	    state, tsp->st_state, (void *)tsp->st_pc, tsp->st_pc);
13787c478bd9Sstevel@tonic-gate 
13797c478bd9Sstevel@tonic-gate 	return (0);
13807c478bd9Sstevel@tonic-gate }
13817c478bd9Sstevel@tonic-gate 
13827c478bd9Sstevel@tonic-gate /*
13837c478bd9Sstevel@tonic-gate  * Invoked when kmt_defbp_enter_debugger is called, this routine activates and
13847c478bd9Sstevel@tonic-gate  * deactivates deferred breakpoints in response to module load and unload
13857c478bd9Sstevel@tonic-gate  * events.
13867c478bd9Sstevel@tonic-gate  */
13877c478bd9Sstevel@tonic-gate /*ARGSUSED*/
13887c478bd9Sstevel@tonic-gate static void
kmt_defbp_event(mdb_tgt_t * t,int vid,void * private)13897c478bd9Sstevel@tonic-gate kmt_defbp_event(mdb_tgt_t *t, int vid, void *private)
13907c478bd9Sstevel@tonic-gate {
13917c478bd9Sstevel@tonic-gate 	if (kmt_defbp_modchg_isload) {
13927c478bd9Sstevel@tonic-gate 		if (!mdb_tgt_sespec_activate_all(t) &&
13937c478bd9Sstevel@tonic-gate 		    (mdb.m_flags & MDB_FL_BPTNOSYMSTOP)) {
13947c478bd9Sstevel@tonic-gate 			/*
13957c478bd9Sstevel@tonic-gate 			 * We weren't able to activate the breakpoints.
13967c478bd9Sstevel@tonic-gate 			 * If so requested, we'll return without calling
13977c478bd9Sstevel@tonic-gate 			 * continue, thus throwing the user into the debugger.
13987c478bd9Sstevel@tonic-gate 			 */
13997c478bd9Sstevel@tonic-gate 			return;
14007c478bd9Sstevel@tonic-gate 		}
14017c478bd9Sstevel@tonic-gate 
14027c478bd9Sstevel@tonic-gate 	} else {
14037c478bd9Sstevel@tonic-gate 		mdb_sespec_t *sep, *nsep;
14047c478bd9Sstevel@tonic-gate 		const mdb_map_t *map, *bpmap;
14057c478bd9Sstevel@tonic-gate 		mdb_map_t modmap;
14067c478bd9Sstevel@tonic-gate 
14077c478bd9Sstevel@tonic-gate 		if ((map = kmt_addr_to_map(t,
14087c478bd9Sstevel@tonic-gate 		    (uintptr_t)kmt_defbp_modchg_modctl->mod_text)) == NULL) {
14097c478bd9Sstevel@tonic-gate 			warn("module unload notification for unknown module %s",
14107c478bd9Sstevel@tonic-gate 			    kmt_defbp_modchg_modctl->mod_modname);
14117c478bd9Sstevel@tonic-gate 			return; /* drop into the debugger */
14127c478bd9Sstevel@tonic-gate 		}
14137c478bd9Sstevel@tonic-gate 
14147c478bd9Sstevel@tonic-gate 		bcopy(map, &modmap, sizeof (mdb_map_t));
14157c478bd9Sstevel@tonic-gate 
14167c478bd9Sstevel@tonic-gate 		for (sep = mdb_list_next(&t->t_active); sep; sep = nsep) {
14177c478bd9Sstevel@tonic-gate 			nsep = mdb_list_next(sep);
14187c478bd9Sstevel@tonic-gate 
14197c478bd9Sstevel@tonic-gate 			if (sep->se_ops == &kmt_brkpt_ops) {
14207c478bd9Sstevel@tonic-gate 				kmt_brkpt_t *kb = sep->se_data;
14217c478bd9Sstevel@tonic-gate 
14227c478bd9Sstevel@tonic-gate 				if ((bpmap = kmt_addr_to_map(t,
14237c478bd9Sstevel@tonic-gate 				    kb->kb_addr)) == NULL ||
14247c478bd9Sstevel@tonic-gate 				    (bpmap->map_base == modmap.map_base &&
14257c478bd9Sstevel@tonic-gate 				    bpmap->map_size == modmap.map_size)) {
14267c478bd9Sstevel@tonic-gate 					mdb_tgt_sespec_idle_one(t, sep,
14277c478bd9Sstevel@tonic-gate 					    EMDB_NOMAP);
14287c478bd9Sstevel@tonic-gate 				}
14297c478bd9Sstevel@tonic-gate 			}
14307c478bd9Sstevel@tonic-gate 		}
14317c478bd9Sstevel@tonic-gate 	}
14327c478bd9Sstevel@tonic-gate 
14337c478bd9Sstevel@tonic-gate 	(void) mdb_tgt_continue(t, NULL);
14347c478bd9Sstevel@tonic-gate }
14357c478bd9Sstevel@tonic-gate 
14367c478bd9Sstevel@tonic-gate static void
kmt_defbp_enter_debugger(void)14377c478bd9Sstevel@tonic-gate kmt_defbp_enter_debugger(void)
14387c478bd9Sstevel@tonic-gate {
14397c478bd9Sstevel@tonic-gate 	/*
14407c478bd9Sstevel@tonic-gate 	 * The debugger places a breakpoint here.  We can't have a simple
14417c478bd9Sstevel@tonic-gate 	 * nop function here, because GCC knows much more than we do, and
1442acbc304dSjohnlev 	 * will optimize away the call to it.
14437c478bd9Sstevel@tonic-gate 	 */
14447c478bd9Sstevel@tonic-gate 	(void) get_fp();
14457c478bd9Sstevel@tonic-gate }
14467c478bd9Sstevel@tonic-gate 
14477c478bd9Sstevel@tonic-gate /*
14487c478bd9Sstevel@tonic-gate  * This routine is called while the kernel is running.  It attempts to determine
14497c478bd9Sstevel@tonic-gate  * whether any deferred breakpoints exist for the module being changed (loaded
14507c478bd9Sstevel@tonic-gate  * or unloaded).  If any such breakpoints exist, the debugger will be entered to
14517c478bd9Sstevel@tonic-gate  * process them.
14527c478bd9Sstevel@tonic-gate  */
14537c478bd9Sstevel@tonic-gate static void
kmt_defbp_modchg(struct modctl * mctl,int isload)14547c478bd9Sstevel@tonic-gate kmt_defbp_modchg(struct modctl *mctl, int isload)
14557c478bd9Sstevel@tonic-gate {
14567c478bd9Sstevel@tonic-gate 	kmt_defbp_t *dbp;
14577c478bd9Sstevel@tonic-gate 
14587c478bd9Sstevel@tonic-gate 	kmt_defbp_lock = 1;
14597c478bd9Sstevel@tonic-gate 
14607c478bd9Sstevel@tonic-gate 	for (dbp = mdb_list_next(&kmt_defbp_list); dbp;
14617c478bd9Sstevel@tonic-gate 	    dbp = mdb_list_next(dbp)) {
14627c478bd9Sstevel@tonic-gate 		if (!dbp->dbp_ref)
14637c478bd9Sstevel@tonic-gate 			continue;
14647c478bd9Sstevel@tonic-gate 
14657c478bd9Sstevel@tonic-gate 		if (strcmp(mctl->mod_modname, dbp->dbp_objname) == 0) {
14667c478bd9Sstevel@tonic-gate 			/*
14677c478bd9Sstevel@tonic-gate 			 * Activate the breakpoint
14687c478bd9Sstevel@tonic-gate 			 */
14697c478bd9Sstevel@tonic-gate 			kmt_defbp_modchg_isload = isload;
14707c478bd9Sstevel@tonic-gate 			kmt_defbp_modchg_modctl = mctl;
14717c478bd9Sstevel@tonic-gate 
14727c478bd9Sstevel@tonic-gate 			kmt_defbp_enter_debugger();
14737c478bd9Sstevel@tonic-gate 			break;
14747c478bd9Sstevel@tonic-gate 		}
14757c478bd9Sstevel@tonic-gate 	}
14767c478bd9Sstevel@tonic-gate 
14777c478bd9Sstevel@tonic-gate 	kmt_defbp_lock = 0;
14787c478bd9Sstevel@tonic-gate }
14797c478bd9Sstevel@tonic-gate 
14807c478bd9Sstevel@tonic-gate /*ARGSUSED*/
14817c478bd9Sstevel@tonic-gate static int
kmt_continue(mdb_tgt_t * t,mdb_tgt_status_t * tsp)14827c478bd9Sstevel@tonic-gate kmt_continue(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
14837c478bd9Sstevel@tonic-gate {
14847c478bd9Sstevel@tonic-gate 	int n;
14857c478bd9Sstevel@tonic-gate 
14867c478bd9Sstevel@tonic-gate 	kmdb_dpi_resume();
14877c478bd9Sstevel@tonic-gate 
14887c478bd9Sstevel@tonic-gate 	/*
14897c478bd9Sstevel@tonic-gate 	 * The order of the following two calls is important.  If there are
14907c478bd9Sstevel@tonic-gate 	 * load acks on the work queue, we'll initialize the dmods they
14917c478bd9Sstevel@tonic-gate 	 * represent.  This will involve a call to _mdb_init, which may very
14927c478bd9Sstevel@tonic-gate 	 * well result in a symbol lookup.  If we haven't resynced our view
14937c478bd9Sstevel@tonic-gate 	 * of symbols with the current state of the world, this lookup could
14947c478bd9Sstevel@tonic-gate 	 * end very badly.  We therefore make sure to sync before processing
14957c478bd9Sstevel@tonic-gate 	 * the work queue.
14967c478bd9Sstevel@tonic-gate 	 */
14977c478bd9Sstevel@tonic-gate 	kmt_sync(t);
14987c478bd9Sstevel@tonic-gate 	kmdb_dpi_process_work_queue();
14997c478bd9Sstevel@tonic-gate 
15007c478bd9Sstevel@tonic-gate 	if (kmdb_kdi_get_unload_request())
15017c478bd9Sstevel@tonic-gate 		t->t_flags |= MDB_TGT_F_UNLOAD;
15027c478bd9Sstevel@tonic-gate 
15037c478bd9Sstevel@tonic-gate 	(void) mdb_tgt_status(t, &t->t_status);
15047c478bd9Sstevel@tonic-gate 
15057c478bd9Sstevel@tonic-gate 	if ((n = kmt_dmod_status(NULL, KMDB_MC_STATE_LOADING) +
15067c478bd9Sstevel@tonic-gate 	    kmt_dmod_status(NULL, KMDB_MC_STATE_UNLOADING)) != 0) {
15077c478bd9Sstevel@tonic-gate 		mdb_warn("%d dmod load%c/unload%c pending\n", n,
15087c478bd9Sstevel@tonic-gate 		    "s"[n == 1], "s"[n == 1]);
15097c478bd9Sstevel@tonic-gate 	}
15107c478bd9Sstevel@tonic-gate 
15117c478bd9Sstevel@tonic-gate 	return (0);
15127c478bd9Sstevel@tonic-gate }
15137c478bd9Sstevel@tonic-gate 
15147c478bd9Sstevel@tonic-gate /*ARGSUSED*/
15157c478bd9Sstevel@tonic-gate static int
kmt_step(mdb_tgt_t * t,mdb_tgt_status_t * tsp)15167c478bd9Sstevel@tonic-gate kmt_step(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
15177c478bd9Sstevel@tonic-gate {
15187c478bd9Sstevel@tonic-gate 	int rc;
15197c478bd9Sstevel@tonic-gate 
15207c478bd9Sstevel@tonic-gate 	if ((rc = kmdb_dpi_step()) == 0)
15217c478bd9Sstevel@tonic-gate 		(void) mdb_tgt_status(t, &t->t_status);
15227c478bd9Sstevel@tonic-gate 
15237c478bd9Sstevel@tonic-gate 	return (rc);
15247c478bd9Sstevel@tonic-gate }
15257c478bd9Sstevel@tonic-gate 
15267c478bd9Sstevel@tonic-gate static int
kmt_defbp_activate(mdb_tgt_t * t)15277c478bd9Sstevel@tonic-gate kmt_defbp_activate(mdb_tgt_t *t)
15287c478bd9Sstevel@tonic-gate {
15297c478bd9Sstevel@tonic-gate 	kmdb_dpi_modchg_register(kmt_defbp_modchg);
15307c478bd9Sstevel@tonic-gate 
15317c478bd9Sstevel@tonic-gate 	/*
15327c478bd9Sstevel@tonic-gate 	 * The routines that add and arm breakpoints will check for the proper
15337c478bd9Sstevel@tonic-gate 	 * DTrace state, but they'll just put this breakpoint on the idle list
15347c478bd9Sstevel@tonic-gate 	 * if DTrace is active.  It'll correctly move to the active list when
15357c478bd9Sstevel@tonic-gate 	 * DTrace deactivates, but that's insufficient for our purposes -- we
15367c478bd9Sstevel@tonic-gate 	 * need to do extra processing at that point.  We won't get to do said
15377c478bd9Sstevel@tonic-gate 	 * processing with with a normal idle->active transition, so we just
15387c478bd9Sstevel@tonic-gate 	 * won't add it add it until we're sure that it'll stick.
15397c478bd9Sstevel@tonic-gate 	 */
15407c478bd9Sstevel@tonic-gate 
15417c478bd9Sstevel@tonic-gate 	if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE)
15427c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_DTACTIVE));
15437c478bd9Sstevel@tonic-gate 
15447c478bd9Sstevel@tonic-gate 	kmt_defbp_bpspec = mdb_tgt_add_vbrkpt(t,
15457c478bd9Sstevel@tonic-gate 	    (uintptr_t)kmt_defbp_enter_debugger,
15467c478bd9Sstevel@tonic-gate 	    MDB_TGT_SPEC_HIDDEN, kmt_defbp_event, NULL);
15477c478bd9Sstevel@tonic-gate 
15487c478bd9Sstevel@tonic-gate 	return (0);
15497c478bd9Sstevel@tonic-gate }
15507c478bd9Sstevel@tonic-gate 
15517c478bd9Sstevel@tonic-gate static void
kmt_defbp_deactivate(mdb_tgt_t * t)15527c478bd9Sstevel@tonic-gate kmt_defbp_deactivate(mdb_tgt_t *t)
15537c478bd9Sstevel@tonic-gate {
15547c478bd9Sstevel@tonic-gate 	kmdb_dpi_modchg_cancel();
15557c478bd9Sstevel@tonic-gate 
15567c478bd9Sstevel@tonic-gate 	if (kmt_defbp_bpspec != 0) {
15577c478bd9Sstevel@tonic-gate 		if (t != NULL)
15587c478bd9Sstevel@tonic-gate 			(void) mdb_tgt_vespec_delete(t, kmt_defbp_bpspec);
15597c478bd9Sstevel@tonic-gate 
15607c478bd9Sstevel@tonic-gate 		kmt_defbp_bpspec = 0;
15617c478bd9Sstevel@tonic-gate 	}
15627c478bd9Sstevel@tonic-gate }
15637c478bd9Sstevel@tonic-gate 
15647c478bd9Sstevel@tonic-gate static kmt_defbp_t *
kmt_defbp_create(mdb_tgt_t * t,const char * objname,const char * symname)15657c478bd9Sstevel@tonic-gate kmt_defbp_create(mdb_tgt_t *t, const char *objname, const char *symname)
15667c478bd9Sstevel@tonic-gate {
15677c478bd9Sstevel@tonic-gate 	kmt_defbp_t *dbp = mdb_alloc(sizeof (kmt_defbp_t), UM_SLEEP);
15687c478bd9Sstevel@tonic-gate 
15697c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "defbp_create %s`%s\n", objname, symname);
15707c478bd9Sstevel@tonic-gate 
15717c478bd9Sstevel@tonic-gate 	dbp->dbp_objname = strdup(objname);
15727c478bd9Sstevel@tonic-gate 	dbp->dbp_symname = strdup(symname);
15737c478bd9Sstevel@tonic-gate 	dbp->dbp_ref = 1;
15747c478bd9Sstevel@tonic-gate 
15757c478bd9Sstevel@tonic-gate 	kmt_defbp_num++;
15767c478bd9Sstevel@tonic-gate 
15777c478bd9Sstevel@tonic-gate 	if (kmt_defbp_num == 1 || kmt_defbp_bpspec == 0) {
15787c478bd9Sstevel@tonic-gate 		if (kmt_defbp_activate(t) < 0)
15797c478bd9Sstevel@tonic-gate 			warn("failed to activate deferred breakpoints");
15807c478bd9Sstevel@tonic-gate 	}
15817c478bd9Sstevel@tonic-gate 
15827c478bd9Sstevel@tonic-gate 	mdb_list_append(&kmt_defbp_list, dbp);
15837c478bd9Sstevel@tonic-gate 
15847c478bd9Sstevel@tonic-gate 	return (dbp);
15857c478bd9Sstevel@tonic-gate }
15867c478bd9Sstevel@tonic-gate 
15877c478bd9Sstevel@tonic-gate static void
kmt_defbp_destroy(kmt_defbp_t * dbp)15887c478bd9Sstevel@tonic-gate kmt_defbp_destroy(kmt_defbp_t *dbp)
15897c478bd9Sstevel@tonic-gate {
15907c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "defbp_destroy %s`%s\n", dbp->dbp_objname,
15917c478bd9Sstevel@tonic-gate 	    dbp->dbp_symname);
15927c478bd9Sstevel@tonic-gate 
15937c478bd9Sstevel@tonic-gate 	mdb_list_delete(&kmt_defbp_list, dbp);
15947c478bd9Sstevel@tonic-gate 
15957c478bd9Sstevel@tonic-gate 	strfree(dbp->dbp_objname);
15967c478bd9Sstevel@tonic-gate 	strfree(dbp->dbp_symname);
15977c478bd9Sstevel@tonic-gate 	mdb_free(dbp, sizeof (kmt_defbp_t));
15987c478bd9Sstevel@tonic-gate }
15997c478bd9Sstevel@tonic-gate 
16007c478bd9Sstevel@tonic-gate static void
kmt_defbp_prune_common(int all)16017c478bd9Sstevel@tonic-gate kmt_defbp_prune_common(int all)
16027c478bd9Sstevel@tonic-gate {
16037c478bd9Sstevel@tonic-gate 	kmt_defbp_t *dbp, *ndbp;
16047c478bd9Sstevel@tonic-gate 
16057c478bd9Sstevel@tonic-gate 	/* We can't remove items from the list while the driver is using it. */
16067c478bd9Sstevel@tonic-gate 	if (kmt_defbp_lock)
16077c478bd9Sstevel@tonic-gate 		return;
16087c478bd9Sstevel@tonic-gate 
16097c478bd9Sstevel@tonic-gate 	for (dbp = mdb_list_next(&kmt_defbp_list); dbp != NULL; dbp = ndbp) {
16107c478bd9Sstevel@tonic-gate 		ndbp = mdb_list_next(dbp);
16117c478bd9Sstevel@tonic-gate 
16127c478bd9Sstevel@tonic-gate 		if (!all && dbp->dbp_ref)
16137c478bd9Sstevel@tonic-gate 			continue;
16147c478bd9Sstevel@tonic-gate 
16157c478bd9Sstevel@tonic-gate 		kmt_defbp_destroy(dbp);
16167c478bd9Sstevel@tonic-gate 	}
16177c478bd9Sstevel@tonic-gate }
16187c478bd9Sstevel@tonic-gate 
16197c478bd9Sstevel@tonic-gate static void
kmt_defbp_prune(void)16207c478bd9Sstevel@tonic-gate kmt_defbp_prune(void)
16217c478bd9Sstevel@tonic-gate {
16227c478bd9Sstevel@tonic-gate 	kmt_defbp_prune_common(0);
16237c478bd9Sstevel@tonic-gate }
16247c478bd9Sstevel@tonic-gate 
16257c478bd9Sstevel@tonic-gate static void
kmt_defbp_destroy_all(void)16267c478bd9Sstevel@tonic-gate kmt_defbp_destroy_all(void)
16277c478bd9Sstevel@tonic-gate {
16287c478bd9Sstevel@tonic-gate 	kmt_defbp_prune_common(1);
16297c478bd9Sstevel@tonic-gate }
16307c478bd9Sstevel@tonic-gate 
16317c478bd9Sstevel@tonic-gate static void
kmt_defbp_delete(mdb_tgt_t * t,kmt_defbp_t * dbp)16327c478bd9Sstevel@tonic-gate kmt_defbp_delete(mdb_tgt_t *t, kmt_defbp_t *dbp)
16337c478bd9Sstevel@tonic-gate {
16347c478bd9Sstevel@tonic-gate 	dbp->dbp_ref = 0;
16357c478bd9Sstevel@tonic-gate 
16367c478bd9Sstevel@tonic-gate 	ASSERT(kmt_defbp_num > 0);
16377c478bd9Sstevel@tonic-gate 	kmt_defbp_num--;
16387c478bd9Sstevel@tonic-gate 
16397c478bd9Sstevel@tonic-gate 	if (kmt_defbp_num == 0)
16407c478bd9Sstevel@tonic-gate 		kmt_defbp_deactivate(t);
16417c478bd9Sstevel@tonic-gate 
16427c478bd9Sstevel@tonic-gate 	kmt_defbp_prune();
16437c478bd9Sstevel@tonic-gate }
16447c478bd9Sstevel@tonic-gate 
16457c478bd9Sstevel@tonic-gate static int
kmt_brkpt_ctor(mdb_tgt_t * t,mdb_sespec_t * sep,void * args)16467c478bd9Sstevel@tonic-gate kmt_brkpt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
16477c478bd9Sstevel@tonic-gate {
16487c478bd9Sstevel@tonic-gate 	mdb_tgt_status_t tsp;
16497c478bd9Sstevel@tonic-gate 	kmt_bparg_t *ka = args;
16507c478bd9Sstevel@tonic-gate 	kmt_brkpt_t *kb;
16517c478bd9Sstevel@tonic-gate 	GElf_Sym s;
16527c478bd9Sstevel@tonic-gate 	mdb_instr_t instr;
16537c478bd9Sstevel@tonic-gate 
16547c478bd9Sstevel@tonic-gate 	(void) mdb_tgt_status(t, &tsp);
16557c478bd9Sstevel@tonic-gate 	if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED)
16567c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_NOPROC));
16577c478bd9Sstevel@tonic-gate 
16587c478bd9Sstevel@tonic-gate 	if (ka->ka_symbol != NULL) {
16597c478bd9Sstevel@tonic-gate 		if (mdb_tgt_lookup_by_scope(t, ka->ka_symbol, &s, NULL) == -1) {
16607c478bd9Sstevel@tonic-gate 			if (errno != EMDB_NOOBJ && !(errno == EMDB_NOSYM &&
16617c478bd9Sstevel@tonic-gate 			    !(mdb.m_flags & MDB_FL_BPTNOSYMSTOP))) {
16627c478bd9Sstevel@tonic-gate 				warn("breakpoint %s activation failed",
16637c478bd9Sstevel@tonic-gate 				    ka->ka_symbol);
16647c478bd9Sstevel@tonic-gate 			}
16657c478bd9Sstevel@tonic-gate 			return (-1); /* errno is set for us */
16667c478bd9Sstevel@tonic-gate 		}
16677c478bd9Sstevel@tonic-gate 
16687c478bd9Sstevel@tonic-gate 		ka->ka_addr = (uintptr_t)s.st_value;
16697c478bd9Sstevel@tonic-gate 	}
16707c478bd9Sstevel@tonic-gate 
16717c478bd9Sstevel@tonic-gate #ifdef __sparc
16727c478bd9Sstevel@tonic-gate 	if (ka->ka_addr & 3)
16737c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_BPALIGN));
16747c478bd9Sstevel@tonic-gate #endif
16757c478bd9Sstevel@tonic-gate 
16767c478bd9Sstevel@tonic-gate 	if (mdb_vread(&instr, sizeof (instr), ka->ka_addr) != sizeof (instr))
16777c478bd9Sstevel@tonic-gate 		return (-1); /* errno is set for us */
16787c478bd9Sstevel@tonic-gate 
16797c478bd9Sstevel@tonic-gate 	if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE)
16807c478bd9Sstevel@tonic-gate 		warn("breakpoint will not arm until DTrace is inactive\n");
16817c478bd9Sstevel@tonic-gate 
16827c478bd9Sstevel@tonic-gate 	kb = mdb_zalloc(sizeof (kmt_brkpt_t), UM_SLEEP);
16837c478bd9Sstevel@tonic-gate 	kb->kb_addr = ka->ka_addr;
16847c478bd9Sstevel@tonic-gate 	sep->se_data = kb;
16857c478bd9Sstevel@tonic-gate 
16867c478bd9Sstevel@tonic-gate 	return (0);
16877c478bd9Sstevel@tonic-gate }
16887c478bd9Sstevel@tonic-gate 
16897c478bd9Sstevel@tonic-gate /*ARGSUSED*/
16907c478bd9Sstevel@tonic-gate static void
kmt_brkpt_dtor(mdb_tgt_t * t,mdb_sespec_t * sep)16917c478bd9Sstevel@tonic-gate kmt_brkpt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep)
16927c478bd9Sstevel@tonic-gate {
16937c478bd9Sstevel@tonic-gate 	mdb_free(sep->se_data, sizeof (kmt_brkpt_t));
16947c478bd9Sstevel@tonic-gate }
16957c478bd9Sstevel@tonic-gate 
16967c478bd9Sstevel@tonic-gate /*ARGSUSED*/
16977c478bd9Sstevel@tonic-gate 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)16987c478bd9Sstevel@tonic-gate kmt_brkpt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep,
16997c478bd9Sstevel@tonic-gate     mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes)
17007c478bd9Sstevel@tonic-gate {
1701892ad162SToomas Soome 	uintptr_t addr = 0;
17027c478bd9Sstevel@tonic-gate 
17037c478bd9Sstevel@tonic-gate 	if (vep != NULL) {
17047c478bd9Sstevel@tonic-gate 		kmt_bparg_t *ka = vep->ve_args;
17057c478bd9Sstevel@tonic-gate 
17067c478bd9Sstevel@tonic-gate 		if (ka->ka_symbol != NULL) {
17077c478bd9Sstevel@tonic-gate 			(void) mdb_iob_snprintf(buf, nbytes, "stop at %s",
17087c478bd9Sstevel@tonic-gate 			    ka->ka_symbol);
17097c478bd9Sstevel@tonic-gate 		} else {
17107c478bd9Sstevel@tonic-gate 			(void) mdb_iob_snprintf(buf, nbytes, "stop at %a",
17117c478bd9Sstevel@tonic-gate 			    ka->ka_addr);
17127c478bd9Sstevel@tonic-gate 			addr = ka->ka_addr;
17137c478bd9Sstevel@tonic-gate 		}
17147c478bd9Sstevel@tonic-gate 
17157c478bd9Sstevel@tonic-gate 	} else {
17167c478bd9Sstevel@tonic-gate 		addr = ((kmt_brkpt_t *)sep->se_data)->kb_addr;
17177c478bd9Sstevel@tonic-gate 		(void) mdb_iob_snprintf(buf, nbytes, "stop at %a", addr);
17187c478bd9Sstevel@tonic-gate 	}
17197c478bd9Sstevel@tonic-gate 
17207c478bd9Sstevel@tonic-gate 	sp->spec_base = addr;
17217c478bd9Sstevel@tonic-gate 	sp->spec_size = sizeof (mdb_instr_t);
17227c478bd9Sstevel@tonic-gate 
17237c478bd9Sstevel@tonic-gate 	return (buf);
17247c478bd9Sstevel@tonic-gate }
17257c478bd9Sstevel@tonic-gate 
17267c478bd9Sstevel@tonic-gate static int
kmt_brkpt_secmp(mdb_tgt_t * t,mdb_sespec_t * sep,void * args)17277c478bd9Sstevel@tonic-gate kmt_brkpt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
17287c478bd9Sstevel@tonic-gate {
17297c478bd9Sstevel@tonic-gate 	kmt_brkpt_t *kb = sep->se_data;
17307c478bd9Sstevel@tonic-gate 	kmt_bparg_t *ka = args;
17317c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
17327c478bd9Sstevel@tonic-gate 
17337c478bd9Sstevel@tonic-gate 	if (ka->ka_symbol != NULL) {
17347c478bd9Sstevel@tonic-gate 		return (mdb_tgt_lookup_by_scope(t, ka->ka_symbol,
17357c478bd9Sstevel@tonic-gate 		    &sym, NULL) == 0 && sym.st_value == kb->kb_addr);
17367c478bd9Sstevel@tonic-gate 	}
17377c478bd9Sstevel@tonic-gate 
17387c478bd9Sstevel@tonic-gate 	return (ka->ka_addr == kb->kb_addr);
17397c478bd9Sstevel@tonic-gate }
17407c478bd9Sstevel@tonic-gate 
17417c478bd9Sstevel@tonic-gate /*ARGSUSED*/
17427c478bd9Sstevel@tonic-gate static int
kmt_brkpt_vecmp(mdb_tgt_t * t,mdb_vespec_t * vep,void * args)17437c478bd9Sstevel@tonic-gate kmt_brkpt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args)
17447c478bd9Sstevel@tonic-gate {
17457c478bd9Sstevel@tonic-gate 	kmt_bparg_t *ka1 = vep->ve_args;
17467c478bd9Sstevel@tonic-gate 	kmt_bparg_t *ka2 = args;
17477c478bd9Sstevel@tonic-gate 
17487c478bd9Sstevel@tonic-gate 	if (ka1->ka_symbol != NULL && ka2->ka_symbol != NULL)
17497c478bd9Sstevel@tonic-gate 		return (strcmp(ka1->ka_symbol, ka2->ka_symbol) == 0);
17507c478bd9Sstevel@tonic-gate 
17517c478bd9Sstevel@tonic-gate 	if (ka1->ka_symbol == NULL && ka2->ka_symbol == NULL)
17527c478bd9Sstevel@tonic-gate 		return (ka1->ka_addr == ka2->ka_addr);
17537c478bd9Sstevel@tonic-gate 
17547c478bd9Sstevel@tonic-gate 	return (0); /* fail if one is symbolic, other is an explicit address */
17557c478bd9Sstevel@tonic-gate }
17567c478bd9Sstevel@tonic-gate 
17577c478bd9Sstevel@tonic-gate static int
kmt_brkpt_arm(mdb_tgt_t * t,mdb_sespec_t * sep)17587c478bd9Sstevel@tonic-gate kmt_brkpt_arm(mdb_tgt_t *t, mdb_sespec_t *sep)
17597c478bd9Sstevel@tonic-gate {
17607c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
17617c478bd9Sstevel@tonic-gate 	kmt_brkpt_t *kb = sep->se_data;
17627c478bd9Sstevel@tonic-gate 	int rv;
17637c478bd9Sstevel@tonic-gate 
17647c478bd9Sstevel@tonic-gate 	if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE)
17657c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_DTACTIVE));
17667c478bd9Sstevel@tonic-gate 
17677c478bd9Sstevel@tonic-gate 	if ((rv = kmdb_dpi_brkpt_arm(kb->kb_addr, &kb->kb_oinstr)) != 0)
17687c478bd9Sstevel@tonic-gate 		return (rv);
17697c478bd9Sstevel@tonic-gate 
17707c478bd9Sstevel@tonic-gate 	if (kmt->kmt_narmedbpts++ == 0)
17717c478bd9Sstevel@tonic-gate 		(void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_ACTIVATE);
17727c478bd9Sstevel@tonic-gate 
17737c478bd9Sstevel@tonic-gate 	return (0);
17747c478bd9Sstevel@tonic-gate }
17757c478bd9Sstevel@tonic-gate 
17767c478bd9Sstevel@tonic-gate static int
kmt_brkpt_disarm(mdb_tgt_t * t,mdb_sespec_t * sep)17777c478bd9Sstevel@tonic-gate kmt_brkpt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep)
17787c478bd9Sstevel@tonic-gate {
17797c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
17807c478bd9Sstevel@tonic-gate 	kmt_brkpt_t *kb = sep->se_data;
17817c478bd9Sstevel@tonic-gate 	int rv;
17827c478bd9Sstevel@tonic-gate 
17837c478bd9Sstevel@tonic-gate 	ASSERT(kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_KMDB_BPT_ACTIVE);
17847c478bd9Sstevel@tonic-gate 
17857c478bd9Sstevel@tonic-gate 	if ((rv = kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr)) != 0)
17867c478bd9Sstevel@tonic-gate 		return (rv);
17877c478bd9Sstevel@tonic-gate 
17887c478bd9Sstevel@tonic-gate 	if (--kmt->kmt_narmedbpts == 0)
17897c478bd9Sstevel@tonic-gate 		(void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_DEACTIVATE);
17907c478bd9Sstevel@tonic-gate 
17917c478bd9Sstevel@tonic-gate 	return (0);
17927c478bd9Sstevel@tonic-gate }
17937c478bd9Sstevel@tonic-gate 
17947c478bd9Sstevel@tonic-gate /*
17957c478bd9Sstevel@tonic-gate  * Determine whether the specified sespec is an armed watchpoint that overlaps
17967c478bd9Sstevel@tonic-gate  * with the given breakpoint and has the given flags set.  We use this to find
17977c478bd9Sstevel@tonic-gate  * conflicts with breakpoints, below.
17987c478bd9Sstevel@tonic-gate  */
17997c478bd9Sstevel@tonic-gate static int
kmt_wp_overlap(mdb_sespec_t * sep,kmt_brkpt_t * kb,int flags)18007c478bd9Sstevel@tonic-gate kmt_wp_overlap(mdb_sespec_t *sep, kmt_brkpt_t *kb, int flags)
18017c478bd9Sstevel@tonic-gate {
18027c478bd9Sstevel@tonic-gate 	const kmdb_wapt_t *wp = sep->se_data;
18037c478bd9Sstevel@tonic-gate 
18047c478bd9Sstevel@tonic-gate 	return (sep->se_state == MDB_TGT_SPEC_ARMED &&
18057c478bd9Sstevel@tonic-gate 	    sep->se_ops == &kmt_wapt_ops && (wp->wp_wflags & flags) &&
18067c478bd9Sstevel@tonic-gate 	    kb->kb_addr - wp->wp_addr < wp->wp_size);
18077c478bd9Sstevel@tonic-gate }
18087c478bd9Sstevel@tonic-gate 
18097c478bd9Sstevel@tonic-gate /*
18107c478bd9Sstevel@tonic-gate  * We step over breakpoints using our single-stepper.  If a conflicting
18117c478bd9Sstevel@tonic-gate  * watchpoint is present, we must temporarily remove it before stepping over the
18127c478bd9Sstevel@tonic-gate  * breakpoint so we don't immediately re-trigger the watchpoint.  We know the
18137c478bd9Sstevel@tonic-gate  * watchpoint has already triggered on our trap instruction as part of fetching
18147c478bd9Sstevel@tonic-gate  * it.  Before we return, we must re-install any disabled watchpoints.
18157c478bd9Sstevel@tonic-gate  */
18167c478bd9Sstevel@tonic-gate static int
kmt_brkpt_cont(mdb_tgt_t * t,mdb_sespec_t * sep,mdb_tgt_status_t * tsp)18177c478bd9Sstevel@tonic-gate kmt_brkpt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
18187c478bd9Sstevel@tonic-gate {
18197c478bd9Sstevel@tonic-gate 	kmt_brkpt_t *kb = sep->se_data;
18207c478bd9Sstevel@tonic-gate 	int status = -1;
18217c478bd9Sstevel@tonic-gate 	int error;
18227c478bd9Sstevel@tonic-gate 
18237c478bd9Sstevel@tonic-gate 	for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) {
18247c478bd9Sstevel@tonic-gate 		if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X))
18257c478bd9Sstevel@tonic-gate 			(void) kmdb_dpi_wapt_disarm(sep->se_data);
18267c478bd9Sstevel@tonic-gate 	}
18277c478bd9Sstevel@tonic-gate 
18287c478bd9Sstevel@tonic-gate 	if (kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr) == 0 &&
18297c478bd9Sstevel@tonic-gate 	    kmt_step(t, tsp) == 0)
18307c478bd9Sstevel@tonic-gate 		status = kmt_status(t, tsp);
18317c478bd9Sstevel@tonic-gate 
18327c478bd9Sstevel@tonic-gate 	error = errno; /* save errno from disarm, step, or status */
18337c478bd9Sstevel@tonic-gate 
18347c478bd9Sstevel@tonic-gate 	for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) {
18357c478bd9Sstevel@tonic-gate 		if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X))
18367c478bd9Sstevel@tonic-gate 			kmdb_dpi_wapt_arm(sep->se_data);
18377c478bd9Sstevel@tonic-gate 	}
18387c478bd9Sstevel@tonic-gate 
18397c478bd9Sstevel@tonic-gate 	(void) set_errno(error);
18407c478bd9Sstevel@tonic-gate 	return (status);
18417c478bd9Sstevel@tonic-gate }
18427c478bd9Sstevel@tonic-gate 
18437c478bd9Sstevel@tonic-gate /*ARGSUSED*/
18447c478bd9Sstevel@tonic-gate static int
kmt_brkpt_match(mdb_tgt_t * t,mdb_sespec_t * sep,mdb_tgt_status_t * tsp)18457c478bd9Sstevel@tonic-gate kmt_brkpt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
18467c478bd9Sstevel@tonic-gate {
18477c478bd9Sstevel@tonic-gate 	kmt_brkpt_t *kb = sep->se_data;
18487c478bd9Sstevel@tonic-gate 	int state, why;
18497c478bd9Sstevel@tonic-gate 	kreg_t pc;
18507c478bd9Sstevel@tonic-gate 
18517c478bd9Sstevel@tonic-gate 	state = kmdb_dpi_get_state(&why);
18527c478bd9Sstevel@tonic-gate 	(void) kmdb_dpi_get_register("pc", &pc);
18537c478bd9Sstevel@tonic-gate 
18547c478bd9Sstevel@tonic-gate 	return (state == DPI_STATE_FAULTED && why == DPI_STATE_WHY_BKPT &&
18557c478bd9Sstevel@tonic-gate 	    pc == kb->kb_addr);
18567c478bd9Sstevel@tonic-gate }
18577c478bd9Sstevel@tonic-gate 
18587c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_brkpt_ops = {
1859*0c1b95beSRichard Lowe 	.se_ctor = kmt_brkpt_ctor,
1860*0c1b95beSRichard Lowe 	.se_dtor = kmt_brkpt_dtor,
1861*0c1b95beSRichard Lowe 	.se_info = kmt_brkpt_info,
1862*0c1b95beSRichard Lowe 	.se_secmp = kmt_brkpt_secmp,
1863*0c1b95beSRichard Lowe 	.se_vecmp = kmt_brkpt_vecmp,
1864*0c1b95beSRichard Lowe 	.se_arm = kmt_brkpt_arm,
1865*0c1b95beSRichard Lowe 	.se_disarm = kmt_brkpt_disarm,
1866*0c1b95beSRichard Lowe 	.se_cont = kmt_brkpt_cont,
1867*0c1b95beSRichard Lowe 	.se_match = kmt_brkpt_match,
18687c478bd9Sstevel@tonic-gate };
18697c478bd9Sstevel@tonic-gate 
18707c478bd9Sstevel@tonic-gate static int
kmt_wapt_ctor(mdb_tgt_t * t,mdb_sespec_t * sep,void * args)18717c478bd9Sstevel@tonic-gate kmt_wapt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
18727c478bd9Sstevel@tonic-gate {
18737c478bd9Sstevel@tonic-gate 	mdb_tgt_status_t tsp;
18747c478bd9Sstevel@tonic-gate 	kmdb_wapt_t *vwp = args;
18757c478bd9Sstevel@tonic-gate 	kmdb_wapt_t *swp;
18767c478bd9Sstevel@tonic-gate 
18777c478bd9Sstevel@tonic-gate 	(void) mdb_tgt_status(t, &tsp);
18787c478bd9Sstevel@tonic-gate 	if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED)
18797c478bd9Sstevel@tonic-gate 		return (set_errno(EMDB_NOPROC));
18807c478bd9Sstevel@tonic-gate 
18817c478bd9Sstevel@tonic-gate 	swp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP);
18827c478bd9Sstevel@tonic-gate 	bcopy(vwp, swp, sizeof (kmdb_wapt_t));
18837c478bd9Sstevel@tonic-gate 
18847c478bd9Sstevel@tonic-gate 	if (kmdb_dpi_wapt_reserve(swp) < 0) {
18857c478bd9Sstevel@tonic-gate 		mdb_free(swp, sizeof (kmdb_wapt_t));
18867c478bd9Sstevel@tonic-gate 		return (-1); /* errno is set for us */
18877c478bd9Sstevel@tonic-gate 	}
18887c478bd9Sstevel@tonic-gate 
18897c478bd9Sstevel@tonic-gate 	sep->se_data = swp;
18907c478bd9Sstevel@tonic-gate 
18917c478bd9Sstevel@tonic-gate 	return (0);
18927c478bd9Sstevel@tonic-gate }
18937c478bd9Sstevel@tonic-gate 
18947c478bd9Sstevel@tonic-gate /*ARGSUSED*/
18957c478bd9Sstevel@tonic-gate static void
kmt_wapt_dtor(mdb_tgt_t * t,mdb_sespec_t * sep)18967c478bd9Sstevel@tonic-gate kmt_wapt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep)
18977c478bd9Sstevel@tonic-gate {
18987c478bd9Sstevel@tonic-gate 	kmdb_wapt_t *wp = sep->se_data;
18997c478bd9Sstevel@tonic-gate 
19007c478bd9Sstevel@tonic-gate 	kmdb_dpi_wapt_release(wp);
19017c478bd9Sstevel@tonic-gate 	mdb_free(wp, sizeof (kmdb_wapt_t));
19027c478bd9Sstevel@tonic-gate }
19037c478bd9Sstevel@tonic-gate 
19047c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19057c478bd9Sstevel@tonic-gate 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)19067c478bd9Sstevel@tonic-gate kmt_wapt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep,
19077c478bd9Sstevel@tonic-gate     mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes)
19087c478bd9Sstevel@tonic-gate {
19097c478bd9Sstevel@tonic-gate 	kmdb_wapt_t *wp = vep != NULL ? vep->ve_args : sep->se_data;
19107c478bd9Sstevel@tonic-gate 	const char *fmt;
19117c478bd9Sstevel@tonic-gate 	char desc[24];
19127c478bd9Sstevel@tonic-gate 
19137c478bd9Sstevel@tonic-gate 	ASSERT(wp->wp_wflags != 0);
19147c478bd9Sstevel@tonic-gate 	desc[0] = '\0';
19157c478bd9Sstevel@tonic-gate 
19167c478bd9Sstevel@tonic-gate 	switch (wp->wp_wflags) {
19177c478bd9Sstevel@tonic-gate 	case MDB_TGT_WA_R:
19187c478bd9Sstevel@tonic-gate 		(void) strcat(desc, "/read");
19197c478bd9Sstevel@tonic-gate 		break;
19207c478bd9Sstevel@tonic-gate 	case MDB_TGT_WA_W:
19217c478bd9Sstevel@tonic-gate 		(void) strcat(desc, "/write");
19227c478bd9Sstevel@tonic-gate 		break;
19237c478bd9Sstevel@tonic-gate 	case MDB_TGT_WA_X:
19247c478bd9Sstevel@tonic-gate 		(void) strcat(desc, "/exec");
19257c478bd9Sstevel@tonic-gate 		break;
19267c478bd9Sstevel@tonic-gate 	default:
19277c478bd9Sstevel@tonic-gate 		if (wp->wp_wflags & MDB_TGT_WA_R)
19287c478bd9Sstevel@tonic-gate 			(void) strcat(desc, "/r");
19297c478bd9Sstevel@tonic-gate 		if (wp->wp_wflags & MDB_TGT_WA_W)
19307c478bd9Sstevel@tonic-gate 			(void) strcat(desc, "/w");
19317c478bd9Sstevel@tonic-gate 		if (wp->wp_wflags & MDB_TGT_WA_X)
19327c478bd9Sstevel@tonic-gate 			(void) strcat(desc, "/x");
19337c478bd9Sstevel@tonic-gate 	}
19347c478bd9Sstevel@tonic-gate 
19357c478bd9Sstevel@tonic-gate 	switch (wp->wp_type) {
19367c478bd9Sstevel@tonic-gate 	case DPI_WAPT_TYPE_PHYS:
19377c478bd9Sstevel@tonic-gate 		fmt = "stop on %s of phys [%p, %p)";
19387c478bd9Sstevel@tonic-gate 		break;
19397c478bd9Sstevel@tonic-gate 
19407c478bd9Sstevel@tonic-gate 	case DPI_WAPT_TYPE_VIRT:
19417c478bd9Sstevel@tonic-gate 		fmt = "stop on %s of [%la, %la)";
19427c478bd9Sstevel@tonic-gate 		break;
19437c478bd9Sstevel@tonic-gate 
19447c478bd9Sstevel@tonic-gate 	case DPI_WAPT_TYPE_IO:
19457c478bd9Sstevel@tonic-gate 		if (wp->wp_size == 1)
19467c478bd9Sstevel@tonic-gate 			fmt = "stop on %s of I/O port %p";
19477c478bd9Sstevel@tonic-gate 		else
19487c478bd9Sstevel@tonic-gate 			fmt = "stop on %s of I/O port [%p, %p)";
19497c478bd9Sstevel@tonic-gate 		break;
195024537d3eSToomas Soome 
195124537d3eSToomas Soome 	default:
195224537d3eSToomas Soome 		fmt = "stop on %s of unknown [%p, %p]";
195324537d3eSToomas Soome 		break;
19547c478bd9Sstevel@tonic-gate 	}
19557c478bd9Sstevel@tonic-gate 
19567c478bd9Sstevel@tonic-gate 	(void) mdb_iob_snprintf(buf, nbytes, fmt, desc + 1, wp->wp_addr,
19577c478bd9Sstevel@tonic-gate 	    wp->wp_addr + wp->wp_size);
19587c478bd9Sstevel@tonic-gate 
19597c478bd9Sstevel@tonic-gate 	sp->spec_base = wp->wp_addr;
19607c478bd9Sstevel@tonic-gate 	sp->spec_size = wp->wp_size;
19617c478bd9Sstevel@tonic-gate 
19627c478bd9Sstevel@tonic-gate 	return (buf);
19637c478bd9Sstevel@tonic-gate }
19647c478bd9Sstevel@tonic-gate 
19657c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19667c478bd9Sstevel@tonic-gate static int
kmt_wapt_secmp(mdb_tgt_t * t,mdb_sespec_t * sep,void * args)19677c478bd9Sstevel@tonic-gate kmt_wapt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
19687c478bd9Sstevel@tonic-gate {
19697c478bd9Sstevel@tonic-gate 	kmdb_wapt_t *wp1 = sep->se_data;
19707c478bd9Sstevel@tonic-gate 	kmdb_wapt_t *wp2 = args;
19717c478bd9Sstevel@tonic-gate 
19727c478bd9Sstevel@tonic-gate 	return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size &&
19737c478bd9Sstevel@tonic-gate 	    wp1->wp_wflags == wp2->wp_wflags);
19747c478bd9Sstevel@tonic-gate }
19757c478bd9Sstevel@tonic-gate 
19767c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19777c478bd9Sstevel@tonic-gate static int
kmt_wapt_vecmp(mdb_tgt_t * t,mdb_vespec_t * vep,void * args)19787c478bd9Sstevel@tonic-gate kmt_wapt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args)
19797c478bd9Sstevel@tonic-gate {
19807c478bd9Sstevel@tonic-gate 	kmdb_wapt_t *wp1 = vep->ve_args;
19817c478bd9Sstevel@tonic-gate 	kmdb_wapt_t *wp2 = args;
19827c478bd9Sstevel@tonic-gate 
19837c478bd9Sstevel@tonic-gate 	return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size &&
19847c478bd9Sstevel@tonic-gate 	    wp1->wp_wflags == wp2->wp_wflags);
19857c478bd9Sstevel@tonic-gate }
19867c478bd9Sstevel@tonic-gate 
19877c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19887c478bd9Sstevel@tonic-gate static int
kmt_wapt_arm(mdb_tgt_t * t,mdb_sespec_t * sep)19897c478bd9Sstevel@tonic-gate kmt_wapt_arm(mdb_tgt_t *t, mdb_sespec_t *sep)
19907c478bd9Sstevel@tonic-gate {
19917c478bd9Sstevel@tonic-gate 	kmdb_dpi_wapt_arm(sep->se_data);
19927c478bd9Sstevel@tonic-gate 
19937c478bd9Sstevel@tonic-gate 	return (0);
19947c478bd9Sstevel@tonic-gate }
19957c478bd9Sstevel@tonic-gate 
19967c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19977c478bd9Sstevel@tonic-gate static int
kmt_wapt_disarm(mdb_tgt_t * t,mdb_sespec_t * sep)19987c478bd9Sstevel@tonic-gate kmt_wapt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep)
19997c478bd9Sstevel@tonic-gate {
20007c478bd9Sstevel@tonic-gate 	kmdb_dpi_wapt_disarm(sep->se_data);
20017c478bd9Sstevel@tonic-gate 
20027c478bd9Sstevel@tonic-gate 	return (0);
20037c478bd9Sstevel@tonic-gate }
20047c478bd9Sstevel@tonic-gate 
20057c478bd9Sstevel@tonic-gate /*
20067c478bd9Sstevel@tonic-gate  * Determine whether the specified sespec is an armed breakpoint at the given
20077c478bd9Sstevel@tonic-gate  * %pc.  We use this to find conflicts with watchpoints below.
20087c478bd9Sstevel@tonic-gate  */
20097c478bd9Sstevel@tonic-gate static int
kmt_bp_overlap(mdb_sespec_t * sep,uintptr_t pc)20107c478bd9Sstevel@tonic-gate kmt_bp_overlap(mdb_sespec_t *sep, uintptr_t pc)
20117c478bd9Sstevel@tonic-gate {
20127c478bd9Sstevel@tonic-gate 	kmt_brkpt_t *kb = sep->se_data;
20137c478bd9Sstevel@tonic-gate 
20147c478bd9Sstevel@tonic-gate 	return (sep->se_state == MDB_TGT_SPEC_ARMED &&
20157c478bd9Sstevel@tonic-gate 	    sep->se_ops == &kmt_brkpt_ops && kb->kb_addr == pc);
20167c478bd9Sstevel@tonic-gate }
20177c478bd9Sstevel@tonic-gate 
20187c478bd9Sstevel@tonic-gate /*
20197c478bd9Sstevel@tonic-gate  * We step over watchpoints using our single-stepper.  If a conflicting
20207c478bd9Sstevel@tonic-gate  * breakpoint is present, we must temporarily disarm it before stepping over
20217c478bd9Sstevel@tonic-gate  * the watchpoint so we do not immediately re-trigger the breakpoint.  This is
20227c478bd9Sstevel@tonic-gate  * similar to the case handled in kmt_brkpt_cont(), above.
20237c478bd9Sstevel@tonic-gate  */
20247c478bd9Sstevel@tonic-gate static int
kmt_wapt_cont(mdb_tgt_t * t,mdb_sespec_t * sep,mdb_tgt_status_t * tsp)20257c478bd9Sstevel@tonic-gate kmt_wapt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
20267c478bd9Sstevel@tonic-gate {
20277c478bd9Sstevel@tonic-gate 	mdb_sespec_t *bep = NULL;
20287c478bd9Sstevel@tonic-gate 	int status = -1;
20297c478bd9Sstevel@tonic-gate 	int error, why;
20307c478bd9Sstevel@tonic-gate 
20317c478bd9Sstevel@tonic-gate 	/*
20327c478bd9Sstevel@tonic-gate 	 * If we stopped for anything other than a watchpoint, check to see
20337c478bd9Sstevel@tonic-gate 	 * if there's a breakpoint here.
20347c478bd9Sstevel@tonic-gate 	 */
20357c478bd9Sstevel@tonic-gate 	if (!(kmdb_dpi_get_state(&why) == DPI_STATE_FAULTED &&
20367c478bd9Sstevel@tonic-gate 	    (why == DPI_STATE_WHY_V_WAPT || why == DPI_STATE_WHY_P_WAPT))) {
20377c478bd9Sstevel@tonic-gate 		kreg_t pc;
20387c478bd9Sstevel@tonic-gate 
20397c478bd9Sstevel@tonic-gate 		(void) kmdb_dpi_get_register("pc", &pc);
20407c478bd9Sstevel@tonic-gate 
20417c478bd9Sstevel@tonic-gate 		for (bep = mdb_list_next(&t->t_active); bep != NULL;
20427c478bd9Sstevel@tonic-gate 		    bep = mdb_list_next(bep)) {
20437c478bd9Sstevel@tonic-gate 			if (kmt_bp_overlap(bep, pc)) {
20447c478bd9Sstevel@tonic-gate 				(void) bep->se_ops->se_disarm(t, bep);
20457c478bd9Sstevel@tonic-gate 				bep->se_state = MDB_TGT_SPEC_ACTIVE;
20467c478bd9Sstevel@tonic-gate 				break;
20477c478bd9Sstevel@tonic-gate 			}
20487c478bd9Sstevel@tonic-gate 		}
20497c478bd9Sstevel@tonic-gate 	}
20507c478bd9Sstevel@tonic-gate 
20517c478bd9Sstevel@tonic-gate 	kmdb_dpi_wapt_disarm(sep->se_data);
20527c478bd9Sstevel@tonic-gate 	if (kmt_step(t, tsp) == 0)
20537c478bd9Sstevel@tonic-gate 		status = kmt_status(t, tsp);
20547c478bd9Sstevel@tonic-gate 
20557c478bd9Sstevel@tonic-gate 	error = errno; /* save errno from step or status */
20567c478bd9Sstevel@tonic-gate 
20577c478bd9Sstevel@tonic-gate 	if (bep != NULL)
20587c478bd9Sstevel@tonic-gate 		mdb_tgt_sespec_arm_one(t, bep);
20597c478bd9Sstevel@tonic-gate 
20607c478bd9Sstevel@tonic-gate 	(void) set_errno(error);
20617c478bd9Sstevel@tonic-gate 	return (status);
20627c478bd9Sstevel@tonic-gate }
20637c478bd9Sstevel@tonic-gate 
20647c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20657c478bd9Sstevel@tonic-gate static int
kmt_wapt_match(mdb_tgt_t * t,mdb_sespec_t * sep,mdb_tgt_status_t * tsp)20667c478bd9Sstevel@tonic-gate kmt_wapt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
20677c478bd9Sstevel@tonic-gate {
20687c478bd9Sstevel@tonic-gate 	return (kmdb_dpi_wapt_match(sep->se_data));
20697c478bd9Sstevel@tonic-gate }
20707c478bd9Sstevel@tonic-gate 
20717c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_wapt_ops = {
2072*0c1b95beSRichard Lowe 	.se_ctor = kmt_wapt_ctor,
2073*0c1b95beSRichard Lowe 	.se_dtor = kmt_wapt_dtor,
2074*0c1b95beSRichard Lowe 	.se_info = kmt_wapt_info,
2075*0c1b95beSRichard Lowe 	.se_secmp = kmt_wapt_secmp,
2076*0c1b95beSRichard Lowe 	.se_vecmp = kmt_wapt_vecmp,
2077*0c1b95beSRichard Lowe 	.se_arm = kmt_wapt_arm,
2078*0c1b95beSRichard Lowe 	.se_disarm = kmt_wapt_disarm,
2079*0c1b95beSRichard Lowe 	.se_cont = kmt_wapt_cont,
2080*0c1b95beSRichard Lowe 	.se_match = kmt_wapt_match,
20817c478bd9Sstevel@tonic-gate };
20827c478bd9Sstevel@tonic-gate 
20837c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20847c478bd9Sstevel@tonic-gate static int
kmt_trap_ctor(mdb_tgt_t * t,mdb_sespec_t * sep,void * args)20857c478bd9Sstevel@tonic-gate kmt_trap_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
20867c478bd9Sstevel@tonic-gate {
20877c478bd9Sstevel@tonic-gate 	sep->se_data = args; /* trap number */
20887c478bd9Sstevel@tonic-gate 
20897c478bd9Sstevel@tonic-gate 	return (0);
20907c478bd9Sstevel@tonic-gate }
20917c478bd9Sstevel@tonic-gate 
20927c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20937c478bd9Sstevel@tonic-gate 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)20947c478bd9Sstevel@tonic-gate kmt_trap_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep,
20957c478bd9Sstevel@tonic-gate     mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes)
20967c478bd9Sstevel@tonic-gate {
20977c478bd9Sstevel@tonic-gate 	const char *name;
20987c478bd9Sstevel@tonic-gate 	int trapnum;
20997c478bd9Sstevel@tonic-gate 
21007c478bd9Sstevel@tonic-gate 	if (vep != NULL)
21017c478bd9Sstevel@tonic-gate 		trapnum = (intptr_t)vep->ve_args;
21027c478bd9Sstevel@tonic-gate 	else
21037c478bd9Sstevel@tonic-gate 		trapnum = (intptr_t)sep->se_data;
21047c478bd9Sstevel@tonic-gate 
21057c478bd9Sstevel@tonic-gate 	if (trapnum == KMT_TRAP_ALL)
21067c478bd9Sstevel@tonic-gate 		name = "any trap";
21077c478bd9Sstevel@tonic-gate 	else if (trapnum == KMT_TRAP_NOTENUM)
21087c478bd9Sstevel@tonic-gate 		name = "miscellaneous trap";
21097c478bd9Sstevel@tonic-gate 	else
21107c478bd9Sstevel@tonic-gate 		name = kmt_trapname(trapnum);
21117c478bd9Sstevel@tonic-gate 
21127c478bd9Sstevel@tonic-gate 	(void) mdb_iob_snprintf(buf, nbytes, "single-step stop on %s", name);
21137c478bd9Sstevel@tonic-gate 
21147c478bd9Sstevel@tonic-gate 	return (buf);
21157c478bd9Sstevel@tonic-gate }
21167c478bd9Sstevel@tonic-gate 
21177c478bd9Sstevel@tonic-gate /*ARGSUSED2*/
21187c478bd9Sstevel@tonic-gate static int
kmt_trap_match(mdb_tgt_t * t,mdb_sespec_t * sep,mdb_tgt_status_t * tsp)21197c478bd9Sstevel@tonic-gate kmt_trap_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
21207c478bd9Sstevel@tonic-gate {
21217c478bd9Sstevel@tonic-gate 	int spectt = (intptr_t)sep->se_data;
21227c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
21237c478bd9Sstevel@tonic-gate 	kreg_t tt;
21247c478bd9Sstevel@tonic-gate 
21257c478bd9Sstevel@tonic-gate 	(void) kmdb_dpi_get_register("tt", &tt);
21267c478bd9Sstevel@tonic-gate 
21277c478bd9Sstevel@tonic-gate 	switch (spectt) {
21287c478bd9Sstevel@tonic-gate 	case KMT_TRAP_ALL:
21297c478bd9Sstevel@tonic-gate 		return (1);
21307c478bd9Sstevel@tonic-gate 	case KMT_TRAP_NOTENUM:
21317c478bd9Sstevel@tonic-gate 		return (tt > kmt->kmt_trapmax ||
21327c478bd9Sstevel@tonic-gate 		    !BT_TEST(kmt->kmt_trapmap, tt));
21337c478bd9Sstevel@tonic-gate 	default:
21347c478bd9Sstevel@tonic-gate 		return (tt == spectt);
21357c478bd9Sstevel@tonic-gate 	}
21367c478bd9Sstevel@tonic-gate }
21377c478bd9Sstevel@tonic-gate 
21387c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_trap_ops = {
2139*0c1b95beSRichard Lowe 	.se_ctor = kmt_trap_ctor,
2140*0c1b95beSRichard Lowe 	.se_dtor = no_se_dtor,
2141*0c1b95beSRichard Lowe 	.se_info = kmt_trap_info,
2142*0c1b95beSRichard Lowe 	.se_secmp = no_se_secmp,
2143*0c1b95beSRichard Lowe 	.se_vecmp = no_se_vecmp,
2144*0c1b95beSRichard Lowe 	.se_arm = no_se_arm,
2145*0c1b95beSRichard Lowe 	.se_disarm = no_se_disarm,
2146*0c1b95beSRichard Lowe 	.se_cont = no_se_cont,
2147*0c1b95beSRichard Lowe 	.se_match = kmt_trap_match,
21487c478bd9Sstevel@tonic-gate };
21497c478bd9Sstevel@tonic-gate 
21507c478bd9Sstevel@tonic-gate static void
kmt_bparg_dtor(mdb_vespec_t * vep)21517c478bd9Sstevel@tonic-gate kmt_bparg_dtor(mdb_vespec_t *vep)
21527c478bd9Sstevel@tonic-gate {
21537c478bd9Sstevel@tonic-gate 	kmt_bparg_t *ka = vep->ve_args;
21547c478bd9Sstevel@tonic-gate 
21557c478bd9Sstevel@tonic-gate 	if (ka->ka_symbol != NULL)
21567c478bd9Sstevel@tonic-gate 		strfree(ka->ka_symbol);
21577c478bd9Sstevel@tonic-gate 
21587c478bd9Sstevel@tonic-gate 	if (ka->ka_defbp != NULL)
21597c478bd9Sstevel@tonic-gate 		kmt_defbp_delete(mdb.m_target, ka->ka_defbp);
21607c478bd9Sstevel@tonic-gate 
21617c478bd9Sstevel@tonic-gate 	mdb_free(ka, sizeof (kmt_bparg_t));
21627c478bd9Sstevel@tonic-gate }
21637c478bd9Sstevel@tonic-gate 
21647c478bd9Sstevel@tonic-gate static int
kmt_add_vbrkpt(mdb_tgt_t * t,uintptr_t addr,int spec_flags,mdb_tgt_se_f * func,void * data)21657c478bd9Sstevel@tonic-gate kmt_add_vbrkpt(mdb_tgt_t *t, uintptr_t addr,
21667c478bd9Sstevel@tonic-gate     int spec_flags, mdb_tgt_se_f *func, void *data)
21677c478bd9Sstevel@tonic-gate {
21687c478bd9Sstevel@tonic-gate 	kmt_bparg_t *ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP);
21697c478bd9Sstevel@tonic-gate 
21707c478bd9Sstevel@tonic-gate 	ka->ka_addr = addr;
21717c478bd9Sstevel@tonic-gate 	ka->ka_symbol = NULL;
21727c478bd9Sstevel@tonic-gate 	ka->ka_defbp = NULL;
21737c478bd9Sstevel@tonic-gate 
21747c478bd9Sstevel@tonic-gate 	return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags,
21757c478bd9Sstevel@tonic-gate 	    func, data, ka, kmt_bparg_dtor));
21767c478bd9Sstevel@tonic-gate }
21777c478bd9Sstevel@tonic-gate 
21787c478bd9Sstevel@tonic-gate static int
kmt_add_sbrkpt(mdb_tgt_t * t,const char * fullname,int spec_flags,mdb_tgt_se_f * func,void * data)21797c478bd9Sstevel@tonic-gate kmt_add_sbrkpt(mdb_tgt_t *t, const char *fullname,
21807c478bd9Sstevel@tonic-gate     int spec_flags, mdb_tgt_se_f *func, void *data)
21817c478bd9Sstevel@tonic-gate {
21827c478bd9Sstevel@tonic-gate 	kmt_bparg_t *ka;
21837c478bd9Sstevel@tonic-gate 	kmt_defbp_t *dbp;
21847c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
21857c478bd9Sstevel@tonic-gate 	char *tick, *objname, *symname;
21867c478bd9Sstevel@tonic-gate 	int serrno;
21877c478bd9Sstevel@tonic-gate 
21887c478bd9Sstevel@tonic-gate 	if ((tick = strchr(fullname, '`')) == fullname) {
21897c478bd9Sstevel@tonic-gate 		(void) set_errno(EMDB_NOOBJ);
21907c478bd9Sstevel@tonic-gate 		return (0);
21917c478bd9Sstevel@tonic-gate 	}
21927c478bd9Sstevel@tonic-gate 
21937c478bd9Sstevel@tonic-gate 	/*
21947c478bd9Sstevel@tonic-gate 	 * Deferred breakpoints are always scoped.  If we didn't find a tick,
21957c478bd9Sstevel@tonic-gate 	 * there's no scope.  We'll create a vbrkpt, but only if we can turn the
21967c478bd9Sstevel@tonic-gate 	 * provided string into an address.
21977c478bd9Sstevel@tonic-gate 	 */
21987c478bd9Sstevel@tonic-gate 	if (tick == NULL) {
21997c478bd9Sstevel@tonic-gate 		uintptr_t addr;
22007c478bd9Sstevel@tonic-gate 
22017c478bd9Sstevel@tonic-gate 		if (strisbasenum(fullname)) {
22027c478bd9Sstevel@tonic-gate 			addr = mdb_strtoull(fullname); /* a bare address */
22037c478bd9Sstevel@tonic-gate 		} else if (mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EVERY,
22047c478bd9Sstevel@tonic-gate 		    fullname, &sym, NULL) < 0) {
22057c478bd9Sstevel@tonic-gate 			(void) set_errno(EMDB_NOSYM);
22067c478bd9Sstevel@tonic-gate 			return (0);
22077c478bd9Sstevel@tonic-gate 		} else {
22087c478bd9Sstevel@tonic-gate 			addr = (uintptr_t)sym.st_value; /* unscoped sym name */
22097c478bd9Sstevel@tonic-gate 		}
22107c478bd9Sstevel@tonic-gate 
22117c478bd9Sstevel@tonic-gate 		return (kmt_add_vbrkpt(t, addr, spec_flags, func, data));
22127c478bd9Sstevel@tonic-gate 	}
22137c478bd9Sstevel@tonic-gate 
22147c478bd9Sstevel@tonic-gate 	if (*(tick + 1) == '\0') {
22157c478bd9Sstevel@tonic-gate 		(void) set_errno(EMDB_NOSYM);
22167c478bd9Sstevel@tonic-gate 		return (0);
22177c478bd9Sstevel@tonic-gate 	}
22187c478bd9Sstevel@tonic-gate 
22197c478bd9Sstevel@tonic-gate 	objname = strndup(fullname, tick - fullname);
22207c478bd9Sstevel@tonic-gate 	symname = tick + 1;
22217c478bd9Sstevel@tonic-gate 
22227c478bd9Sstevel@tonic-gate 	if (mdb_tgt_lookup_by_name(t, objname, symname, NULL, NULL) < 0 &&
22237c478bd9Sstevel@tonic-gate 	    errno != EMDB_NOOBJ) {
22247c478bd9Sstevel@tonic-gate 		serrno = errno;
22257c478bd9Sstevel@tonic-gate 		strfree(objname);
22267c478bd9Sstevel@tonic-gate 
22277c478bd9Sstevel@tonic-gate 		(void) set_errno(serrno);
22287c478bd9Sstevel@tonic-gate 		return (0); /* errno is set for us */
22297c478bd9Sstevel@tonic-gate 	}
22307c478bd9Sstevel@tonic-gate 
22317c478bd9Sstevel@tonic-gate 	dbp = kmt_defbp_create(t, objname, symname);
22327c478bd9Sstevel@tonic-gate 	strfree(objname);
22337c478bd9Sstevel@tonic-gate 
22347c478bd9Sstevel@tonic-gate 	ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP);
22357c478bd9Sstevel@tonic-gate 	ka->ka_symbol = strdup(fullname);
2236892ad162SToomas Soome 	ka->ka_addr = 0;
22377c478bd9Sstevel@tonic-gate 	ka->ka_defbp = dbp;
22387c478bd9Sstevel@tonic-gate 
22397c478bd9Sstevel@tonic-gate 	return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags,
22407b9b3bf3Sedp 	    func, data, ka, kmt_bparg_dtor));
22417c478bd9Sstevel@tonic-gate }
22427c478bd9Sstevel@tonic-gate 
22437c478bd9Sstevel@tonic-gate static int
kmt_wparg_overlap(const kmdb_wapt_t * wp1,const kmdb_wapt_t * wp2)22447c478bd9Sstevel@tonic-gate kmt_wparg_overlap(const kmdb_wapt_t *wp1, const kmdb_wapt_t *wp2)
22457c478bd9Sstevel@tonic-gate {
22467c478bd9Sstevel@tonic-gate 	/* Assume the watchpoint spaces don't overlap */
22477c478bd9Sstevel@tonic-gate 	if (wp1->wp_type != wp2->wp_type)
22487c478bd9Sstevel@tonic-gate 		return (0);
22497c478bd9Sstevel@tonic-gate 
22507c478bd9Sstevel@tonic-gate 	if (wp2->wp_addr + wp2->wp_size <= wp1->wp_addr)
22517c478bd9Sstevel@tonic-gate 		return (0); /* no range overlap */
22527c478bd9Sstevel@tonic-gate 
22537c478bd9Sstevel@tonic-gate 	if (wp1->wp_addr + wp1->wp_size <= wp2->wp_addr)
22547c478bd9Sstevel@tonic-gate 		return (0); /* no range overlap */
22557c478bd9Sstevel@tonic-gate 
22567c478bd9Sstevel@tonic-gate 	return (wp1->wp_addr != wp2->wp_addr || wp1->wp_size != wp2->wp_size ||
22577c478bd9Sstevel@tonic-gate 	    wp1->wp_wflags != wp2->wp_wflags);
22587c478bd9Sstevel@tonic-gate }
22597c478bd9Sstevel@tonic-gate 
22607c478bd9Sstevel@tonic-gate static void
kmt_wparg_dtor(mdb_vespec_t * vep)22617c478bd9Sstevel@tonic-gate kmt_wparg_dtor(mdb_vespec_t *vep)
22627c478bd9Sstevel@tonic-gate {
22637c478bd9Sstevel@tonic-gate 	mdb_free(vep->ve_args, sizeof (kmdb_wapt_t));
22647c478bd9Sstevel@tonic-gate }
22657c478bd9Sstevel@tonic-gate 
22667c478bd9Sstevel@tonic-gate 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)22677c478bd9Sstevel@tonic-gate kmt_add_wapt_common(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags,
22687c478bd9Sstevel@tonic-gate     int spec_flags, mdb_tgt_se_f *func, void *data, int type)
22697c478bd9Sstevel@tonic-gate {
22707c478bd9Sstevel@tonic-gate 	kmdb_wapt_t *wp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP);
22717c478bd9Sstevel@tonic-gate 	mdb_sespec_t *sep;
22727c478bd9Sstevel@tonic-gate 
22737c478bd9Sstevel@tonic-gate 	wp->wp_addr = addr;
22747c478bd9Sstevel@tonic-gate 	wp->wp_size = len;
22757c478bd9Sstevel@tonic-gate 	wp->wp_type = type;
22767c478bd9Sstevel@tonic-gate 	wp->wp_wflags = wflags;
22777c478bd9Sstevel@tonic-gate 
22787c478bd9Sstevel@tonic-gate 	if (kmdb_dpi_wapt_validate(wp) < 0)
22797c478bd9Sstevel@tonic-gate 		return (0); /* errno is set for us */
22807c478bd9Sstevel@tonic-gate 
22817c478bd9Sstevel@tonic-gate 	for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) {
22827c478bd9Sstevel@tonic-gate 		if (sep->se_ops == &kmt_wapt_ops &&
22837c478bd9Sstevel@tonic-gate 		    mdb_list_next(&sep->se_velist) != NULL &&
22847c478bd9Sstevel@tonic-gate 		    kmt_wparg_overlap(wp, sep->se_data))
22857c478bd9Sstevel@tonic-gate 			goto wapt_dup;
22867c478bd9Sstevel@tonic-gate 	}
22877c478bd9Sstevel@tonic-gate 
22887c478bd9Sstevel@tonic-gate 	for (sep = mdb_list_next(&t->t_idle); sep; sep = mdb_list_next(sep)) {
22897c478bd9Sstevel@tonic-gate 		if (sep->se_ops == &kmt_wapt_ops && kmt_wparg_overlap(wp,
22907c478bd9Sstevel@tonic-gate 		    ((mdb_vespec_t *)mdb_list_next(&sep->se_velist))->ve_args))
22917c478bd9Sstevel@tonic-gate 			goto wapt_dup;
22927c478bd9Sstevel@tonic-gate 	}
22937c478bd9Sstevel@tonic-gate 
22947c478bd9Sstevel@tonic-gate 	return (mdb_tgt_vespec_insert(t, &kmt_wapt_ops, spec_flags,
22957c478bd9Sstevel@tonic-gate 	    func, data, wp, kmt_wparg_dtor));
22967c478bd9Sstevel@tonic-gate 
22977c478bd9Sstevel@tonic-gate wapt_dup:
22987c478bd9Sstevel@tonic-gate 	mdb_free(wp, sizeof (kmdb_wapt_t));
22997c478bd9Sstevel@tonic-gate 	(void) set_errno(EMDB_WPDUP);
23007c478bd9Sstevel@tonic-gate 	return (0);
23017c478bd9Sstevel@tonic-gate }
23027c478bd9Sstevel@tonic-gate 
23037c478bd9Sstevel@tonic-gate 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)23047c478bd9Sstevel@tonic-gate kmt_add_pwapt(mdb_tgt_t *t, physaddr_t addr, size_t len, uint_t wflags,
23057c478bd9Sstevel@tonic-gate     int spec_flags, mdb_tgt_se_f *func, void *data)
23067c478bd9Sstevel@tonic-gate {
23077c478bd9Sstevel@tonic-gate 	return (kmt_add_wapt_common(t, (uintptr_t)addr, len, wflags, spec_flags,
23087c478bd9Sstevel@tonic-gate 	    func, data, DPI_WAPT_TYPE_PHYS));
23097c478bd9Sstevel@tonic-gate }
23107c478bd9Sstevel@tonic-gate 
23117c478bd9Sstevel@tonic-gate 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)23127c478bd9Sstevel@tonic-gate kmt_add_vwapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags,
23137c478bd9Sstevel@tonic-gate     int spec_flags, mdb_tgt_se_f *func, void *data)
23147c478bd9Sstevel@tonic-gate {
23157c478bd9Sstevel@tonic-gate 	return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func,
23167c478bd9Sstevel@tonic-gate 	    data, DPI_WAPT_TYPE_VIRT));
23177c478bd9Sstevel@tonic-gate }
23187c478bd9Sstevel@tonic-gate 
23197c478bd9Sstevel@tonic-gate 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)23207c478bd9Sstevel@tonic-gate kmt_add_iowapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags,
23217c478bd9Sstevel@tonic-gate     int spec_flags, mdb_tgt_se_f *func, void *data)
23227c478bd9Sstevel@tonic-gate {
23237c478bd9Sstevel@tonic-gate 	return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func,
23247c478bd9Sstevel@tonic-gate 	    data, DPI_WAPT_TYPE_IO));
23257c478bd9Sstevel@tonic-gate }
23267c478bd9Sstevel@tonic-gate 
23277c478bd9Sstevel@tonic-gate static int
kmt_add_trap(mdb_tgt_t * t,int trapnum,int spec_flags,mdb_tgt_se_f * func,void * data)23287c478bd9Sstevel@tonic-gate kmt_add_trap(mdb_tgt_t *t, int trapnum, int spec_flags, mdb_tgt_se_f *func,
23297c478bd9Sstevel@tonic-gate     void *data)
23307c478bd9Sstevel@tonic-gate {
23317c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
23327c478bd9Sstevel@tonic-gate 
23337c478bd9Sstevel@tonic-gate 	if (trapnum != KMT_TRAP_ALL && trapnum != KMT_TRAP_NOTENUM) {
23347c478bd9Sstevel@tonic-gate 		if (trapnum < 0 || trapnum > kmt->kmt_trapmax) {
23357c478bd9Sstevel@tonic-gate 			(void) set_errno(EMDB_BADFLTNUM);
23367c478bd9Sstevel@tonic-gate 			return (0);
23377c478bd9Sstevel@tonic-gate 		}
23387c478bd9Sstevel@tonic-gate 
23397c478bd9Sstevel@tonic-gate 		BT_SET(kmt->kmt_trapmap, trapnum);
23407c478bd9Sstevel@tonic-gate 	}
23417c478bd9Sstevel@tonic-gate 
23427c478bd9Sstevel@tonic-gate 	return (mdb_tgt_vespec_insert(t, &kmt_trap_ops, spec_flags, func, data,
23437c478bd9Sstevel@tonic-gate 	    (void *)(uintptr_t)trapnum, no_ve_dtor));
23447c478bd9Sstevel@tonic-gate }
23457c478bd9Sstevel@tonic-gate 
23467c478bd9Sstevel@tonic-gate /*ARGSUSED*/
23477c478bd9Sstevel@tonic-gate static uintmax_t
kmt_cpuid_disc_get(const mdb_var_t * v)23487c478bd9Sstevel@tonic-gate kmt_cpuid_disc_get(const mdb_var_t *v)
23497c478bd9Sstevel@tonic-gate {
23507c478bd9Sstevel@tonic-gate 	return (kmdb_dpi_get_master_cpuid());
23517c478bd9Sstevel@tonic-gate }
23527c478bd9Sstevel@tonic-gate 
23537c478bd9Sstevel@tonic-gate static const mdb_nv_disc_t kmt_cpuid_disc = {
2354*0c1b95beSRichard Lowe 	.disc_get = kmt_cpuid_disc_get
23557c478bd9Sstevel@tonic-gate };
23567c478bd9Sstevel@tonic-gate 
23577c478bd9Sstevel@tonic-gate /*
23587c478bd9Sstevel@tonic-gate  * This routine executes while the kernel is running.
23597c478bd9Sstevel@tonic-gate  */
23607c478bd9Sstevel@tonic-gate void
kmt_activate(mdb_tgt_t * t)23617c478bd9Sstevel@tonic-gate kmt_activate(mdb_tgt_t *t)
23627c478bd9Sstevel@tonic-gate {
23637c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
23647c478bd9Sstevel@tonic-gate 
23657c478bd9Sstevel@tonic-gate 	mdb_prop_postmortem = FALSE;
23667c478bd9Sstevel@tonic-gate 	mdb_prop_kernel = TRUE;
23677c478bd9Sstevel@tonic-gate 
23687c478bd9Sstevel@tonic-gate 	(void) mdb_tgt_register_dcmds(t, &kmt_dcmds[0], MDB_MOD_FORCE);
23697c478bd9Sstevel@tonic-gate 	mdb_tgt_register_regvars(t, kmt->kmt_rds, &kmt_reg_disc, 0);
2370ae115bc7Smrj 
2371ae115bc7Smrj 	/*
2372ae115bc7Smrj 	 * Force load of the MDB krtld module, in case it's been rolled into
2373ae115bc7Smrj 	 * unix.
2374ae115bc7Smrj 	 */
2375ae115bc7Smrj 	(void) mdb_module_load(KMT_RTLD_NAME, MDB_MOD_SILENT | MDB_MOD_DEFER);
23767c478bd9Sstevel@tonic-gate }
23777c478bd9Sstevel@tonic-gate 
23787c478bd9Sstevel@tonic-gate static void
kmt_destroy(mdb_tgt_t * t)23797c478bd9Sstevel@tonic-gate kmt_destroy(mdb_tgt_t *t)
23807c478bd9Sstevel@tonic-gate {
23817c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
23827c478bd9Sstevel@tonic-gate 	kmt_module_t *km, *pkm;
23837c478bd9Sstevel@tonic-gate 
23847c478bd9Sstevel@tonic-gate 	mdb_nv_destroy(&kmt->kmt_modules);
23857c478bd9Sstevel@tonic-gate 	for (km = mdb_list_prev(&kmt->kmt_modlist); km != NULL; km = pkm) {
23867c478bd9Sstevel@tonic-gate 		pkm = mdb_list_prev(km);
23877c478bd9Sstevel@tonic-gate 		mdb_free(km, sizeof (kmt_module_t));
23887c478bd9Sstevel@tonic-gate 	}
23897c478bd9Sstevel@tonic-gate 
23907c478bd9Sstevel@tonic-gate 	if (!kmt_defbp_lock)
23917c478bd9Sstevel@tonic-gate 		kmt_defbp_destroy_all();
23927c478bd9Sstevel@tonic-gate 
23937c478bd9Sstevel@tonic-gate 	if (kmt->kmt_trapmap != NULL)
23947c478bd9Sstevel@tonic-gate 		mdb_free(kmt->kmt_trapmap, BT_SIZEOFMAP(kmt->kmt_trapmax));
23957c478bd9Sstevel@tonic-gate 
2396d75f3745SJohn Levon 	mdb_free(kmt, sizeof (kmt_data_t));
23977c478bd9Sstevel@tonic-gate }
23987c478bd9Sstevel@tonic-gate 
23997c478bd9Sstevel@tonic-gate static const mdb_tgt_ops_t kmt_ops = {
2400*0c1b95beSRichard Lowe 	.t_setflags = kmt_setflags,
2401*0c1b95beSRichard Lowe 	.t_setcontext = (int (*)())(uintptr_t)mdb_tgt_notsup,
2402*0c1b95beSRichard Lowe 	.t_activate = kmt_activate,
2403*0c1b95beSRichard Lowe 	.t_deactivate = (void (*)())(uintptr_t)mdb_tgt_nop,
2404*0c1b95beSRichard Lowe 	.t_periodic = kmt_periodic,
2405*0c1b95beSRichard Lowe 	.t_destroy = kmt_destroy,
2406*0c1b95beSRichard Lowe 	.t_name = kmt_name,
2407*0c1b95beSRichard Lowe 	.t_isa = (const char *(*)())mdb_conf_isa,
2408*0c1b95beSRichard Lowe 	.t_platform = kmt_platform,
2409*0c1b95beSRichard Lowe 	.t_uname = kmt_uname,
2410*0c1b95beSRichard Lowe 	.t_dmodel = kmt_dmodel,
2411*0c1b95beSRichard Lowe 	.t_aread = (ssize_t (*)())mdb_tgt_notsup,
2412*0c1b95beSRichard Lowe 	.t_awrite = (ssize_t (*)())mdb_tgt_notsup,
2413*0c1b95beSRichard Lowe 	.t_vread = kmt_read,
2414*0c1b95beSRichard Lowe 	.t_vwrite = kmt_write,
2415*0c1b95beSRichard Lowe 	.t_pread = kmt_pread,
2416*0c1b95beSRichard Lowe 	.t_pwrite = kmt_pwrite,
2417*0c1b95beSRichard Lowe 	.t_fread = kmt_read,
2418*0c1b95beSRichard Lowe 	.t_fwrite = kmt_write,
2419*0c1b95beSRichard Lowe 	.t_ioread = kmt_ioread,
2420*0c1b95beSRichard Lowe 	.t_iowrite = kmt_iowrite,
2421*0c1b95beSRichard Lowe 	.t_vtop = kmt_vtop,
2422*0c1b95beSRichard Lowe 	.t_lookup_by_name = kmt_lookup_by_name,
2423*0c1b95beSRichard Lowe 	.t_lookup_by_addr = kmt_lookup_by_addr,
2424*0c1b95beSRichard Lowe 	.t_symbol_iter = kmt_symbol_iter,
2425*0c1b95beSRichard Lowe 	.t_mapping_iter = kmt_mapping_iter,
2426*0c1b95beSRichard Lowe 	.t_object_iter = kmt_object_iter,
2427*0c1b95beSRichard Lowe 	.t_addr_to_map = kmt_addr_to_map,
2428*0c1b95beSRichard Lowe 	.t_name_to_map = kmt_name_to_map,
2429*0c1b95beSRichard Lowe 	.t_addr_to_ctf = kmt_addr_to_ctf,
2430*0c1b95beSRichard Lowe 	.t_name_to_ctf = kmt_name_to_ctf,
2431*0c1b95beSRichard Lowe 	.t_status = kmt_status,
2432*0c1b95beSRichard Lowe 	.t_run = (int (*)())(uintptr_t)mdb_tgt_notsup,
2433*0c1b95beSRichard Lowe 	.t_step = kmt_step,
2434*0c1b95beSRichard Lowe 	.t_step_out = kmt_step_out,
2435*0c1b95beSRichard Lowe 	.t_next = kmt_next,
2436*0c1b95beSRichard Lowe 	.t_cont = kmt_continue,
2437*0c1b95beSRichard Lowe 	.t_signal = (int (*)())(uintptr_t)mdb_tgt_notsup,
2438*0c1b95beSRichard Lowe 	.t_add_vbrkpt = kmt_add_vbrkpt,
2439*0c1b95beSRichard Lowe 	.t_add_sbrkpt = kmt_add_sbrkpt,
2440*0c1b95beSRichard Lowe 	.t_add_pwapt = kmt_add_pwapt,
2441*0c1b95beSRichard Lowe 	.t_add_vwapt = kmt_add_vwapt,
2442*0c1b95beSRichard Lowe 	.t_add_iowapt = kmt_add_iowapt,
2443*0c1b95beSRichard Lowe 	.t_add_sysenter = (int (*)())(uintptr_t)mdb_tgt_null,
2444*0c1b95beSRichard Lowe 	.t_add_sysexit = (int (*)())(uintptr_t)mdb_tgt_null,
2445*0c1b95beSRichard Lowe 	.t_add_signal = (int (*)())(uintptr_t)mdb_tgt_null,
2446*0c1b95beSRichard Lowe 	.t_add_fault = kmt_add_trap,
2447*0c1b95beSRichard Lowe 	.t_getareg = kmt_getareg,
2448*0c1b95beSRichard Lowe 	.t_putareg = kmt_putareg,
2449*0c1b95beSRichard Lowe 	.t_stack_iter = (int (*)())(uintptr_t)mdb_tgt_nop,	/* XXX */
2450*0c1b95beSRichard Lowe 	.t_auxv = (int (*)())(uintptr_t)mdb_tgt_notsup,
2451*0c1b95beSRichard Lowe 	.t_thread_name = (int (*)())(uintptr_t)mdb_tgt_notsup,
24527c478bd9Sstevel@tonic-gate };
24537c478bd9Sstevel@tonic-gate 
24547c478bd9Sstevel@tonic-gate /*
24557c478bd9Sstevel@tonic-gate  * Called immediately upon resumption of the system after a step or continue.
24567c478bd9Sstevel@tonic-gate  * Allows us to synchronize kmt's view of the world with reality.
24577c478bd9Sstevel@tonic-gate  */
24587c478bd9Sstevel@tonic-gate /*ARGSUSED*/
24597c478bd9Sstevel@tonic-gate static void
kmt_sync(mdb_tgt_t * t)24607c478bd9Sstevel@tonic-gate kmt_sync(mdb_tgt_t *t)
24617c478bd9Sstevel@tonic-gate {
24627c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt = t->t_data;
24637c478bd9Sstevel@tonic-gate 	int symavail;
24647c478bd9Sstevel@tonic-gate 
24657c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "synchronizing with kernel\n");
24667c478bd9Sstevel@tonic-gate 
24677c478bd9Sstevel@tonic-gate 	symavail = kmt->kmt_symavail;
24687c478bd9Sstevel@tonic-gate 	kmt->kmt_symavail = FALSE;
24697c478bd9Sstevel@tonic-gate 
24707c478bd9Sstevel@tonic-gate 	/*
24717c478bd9Sstevel@tonic-gate 	 * Resync our view of the world if the modules have changed, or if we
24727c478bd9Sstevel@tonic-gate 	 * didn't have any symbols coming into this function.  The latter will
24737c478bd9Sstevel@tonic-gate 	 * only happen on startup.
24747c478bd9Sstevel@tonic-gate 	 */
24757c478bd9Sstevel@tonic-gate 	if (kmdb_kdi_mods_changed() || !symavail)
24767c478bd9Sstevel@tonic-gate 		kmt_modlist_update(t);
24777c478bd9Sstevel@tonic-gate 
24787c478bd9Sstevel@tonic-gate 	/*
24797c478bd9Sstevel@tonic-gate 	 * It would be nice if we could run this less frequently, perhaps
24807c478bd9Sstevel@tonic-gate 	 * after a dvec-initiated trigger.
24817c478bd9Sstevel@tonic-gate 	 */
24827c478bd9Sstevel@tonic-gate 	kmdb_module_sync();
24837c478bd9Sstevel@tonic-gate 
24847c478bd9Sstevel@tonic-gate 	kmt->kmt_symavail = TRUE;
24857c478bd9Sstevel@tonic-gate 
24867c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "synchronization complete\n");
24877c478bd9Sstevel@tonic-gate 
24887c478bd9Sstevel@tonic-gate 	kmt_defbp_prune();
24897c478bd9Sstevel@tonic-gate 
24907c478bd9Sstevel@tonic-gate 	if (kmt_defbp_num > 0 && kmt_defbp_bpspec == 0 &&
24917c478bd9Sstevel@tonic-gate 	    kmdb_kdi_dtrace_get_state() != KDI_DTSTATE_DTRACE_ACTIVE) {
24927c478bd9Sstevel@tonic-gate 		/*
24937c478bd9Sstevel@tonic-gate 		 * Deferred breakpoints were created while DTrace was active,
24947c478bd9Sstevel@tonic-gate 		 * and consequently the deferred breakpoint enabling mechanism
24957c478bd9Sstevel@tonic-gate 		 * wasn't activated.  Activate it now, and then try to activate
24967c478bd9Sstevel@tonic-gate 		 * the deferred breakpoints.  We do this so that we can catch
24977c478bd9Sstevel@tonic-gate 		 * the ones which may apply to modules that have been loaded
24987c478bd9Sstevel@tonic-gate 		 * while they were waiting for DTrace to deactivate.
24997c478bd9Sstevel@tonic-gate 		 */
25007c478bd9Sstevel@tonic-gate 		(void) kmt_defbp_activate(t);
25017c478bd9Sstevel@tonic-gate 		(void) mdb_tgt_sespec_activate_all(t);
25027c478bd9Sstevel@tonic-gate 	}
25037c478bd9Sstevel@tonic-gate 
25047c478bd9Sstevel@tonic-gate 	(void) mdb_tgt_status(t, &t->t_status);
25057c478bd9Sstevel@tonic-gate }
25067c478bd9Sstevel@tonic-gate 
25077c478bd9Sstevel@tonic-gate /*
25087c478bd9Sstevel@tonic-gate  * This routine executes while the kernel is running.
25097c478bd9Sstevel@tonic-gate  */
25107c478bd9Sstevel@tonic-gate /*ARGSUSED*/
25117c478bd9Sstevel@tonic-gate int
kmdb_kvm_create(mdb_tgt_t * t,int argc,const char * argv[])25127c478bd9Sstevel@tonic-gate kmdb_kvm_create(mdb_tgt_t *t, int argc, const char *argv[])
25137c478bd9Sstevel@tonic-gate {
25147c478bd9Sstevel@tonic-gate 	kmt_data_t *kmt;
25157c478bd9Sstevel@tonic-gate 
25167c478bd9Sstevel@tonic-gate 	if (argc != 0)
25177c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
25187c478bd9Sstevel@tonic-gate 
25197c478bd9Sstevel@tonic-gate 	kmt = mdb_zalloc(sizeof (kmt_data_t), UM_SLEEP);
25207c478bd9Sstevel@tonic-gate 	t->t_data = kmt;
25217c478bd9Sstevel@tonic-gate 	t->t_ops = &kmt_ops;
25227c478bd9Sstevel@tonic-gate 	t->t_flags |= MDB_TGT_F_RDWR;	/* kmdb is always r/w */
25237c478bd9Sstevel@tonic-gate 
25247c478bd9Sstevel@tonic-gate 	(void) mdb_nv_insert(&mdb.m_nv, "cpuid", &kmt_cpuid_disc, 0,
25257c478bd9Sstevel@tonic-gate 	    MDB_NV_PERSIST | MDB_NV_RDONLY);
25267c478bd9Sstevel@tonic-gate 
25277c478bd9Sstevel@tonic-gate 	(void) mdb_nv_create(&kmt->kmt_modules, UM_SLEEP);
25287c478bd9Sstevel@tonic-gate 
25297c478bd9Sstevel@tonic-gate 	kmt_init_isadep(t);
25307c478bd9Sstevel@tonic-gate 
25317c478bd9Sstevel@tonic-gate 	kmt->kmt_symavail = FALSE;
25327c478bd9Sstevel@tonic-gate 
25337c478bd9Sstevel@tonic-gate 	bzero(&kmt_defbp_list, sizeof (mdb_list_t));
25347c478bd9Sstevel@tonic-gate 
25357c478bd9Sstevel@tonic-gate 	return (0);
25367c478bd9Sstevel@tonic-gate 
25377c478bd9Sstevel@tonic-gate create_err:
25387c478bd9Sstevel@tonic-gate 	kmt_destroy(t);
25397c478bd9Sstevel@tonic-gate 
25407c478bd9Sstevel@tonic-gate 	return (-1);
25417c478bd9Sstevel@tonic-gate }
25427c478bd9Sstevel@tonic-gate 
25437c478bd9Sstevel@tonic-gate /*
25447c478bd9Sstevel@tonic-gate  * This routine is called once, when kmdb first has control of the world.
25457c478bd9Sstevel@tonic-gate  */
25467c478bd9Sstevel@tonic-gate void
kmdb_kvm_startup(void)25477c478bd9Sstevel@tonic-gate kmdb_kvm_startup(void)
25487c478bd9Sstevel@tonic-gate {
2549ae115bc7Smrj 	kmt_data_t *kmt = mdb.m_target->t_data;
2550ae115bc7Smrj 
25517c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm startup\n");
25527c478bd9Sstevel@tonic-gate 
25537c478bd9Sstevel@tonic-gate 	kmt_sync(mdb.m_target);
25547c478bd9Sstevel@tonic-gate 	(void) mdb_module_load_builtin(KMT_MODULE);
25557c478bd9Sstevel@tonic-gate 	kmt_startup_isadep(mdb.m_target);
25567c478bd9Sstevel@tonic-gate 
25577c478bd9Sstevel@tonic-gate 	/*
25587c478bd9Sstevel@tonic-gate 	 * This is here because we need to write the deferred breakpoint
25597c478bd9Sstevel@tonic-gate 	 * breakpoint when the debugger starts.  Our normal r/o write routines
25607c478bd9Sstevel@tonic-gate 	 * don't work when the kernel is running, so we have to do it during
25617c478bd9Sstevel@tonic-gate 	 * startup.
25627c478bd9Sstevel@tonic-gate 	 */
25637c478bd9Sstevel@tonic-gate 	(void) mdb_tgt_sespec_activate_all(mdb.m_target);
2564ae115bc7Smrj 
2565ae115bc7Smrj 	kmt->kmt_rtld_name = KMT_RTLD_NAME;
2566ae115bc7Smrj 
2567ae115bc7Smrj 	if (kmt_module_by_name(kmt, KMT_RTLD_NAME) == NULL)
2568ae115bc7Smrj 		kmt->kmt_rtld_name = "unix";
25697c478bd9Sstevel@tonic-gate }
25707c478bd9Sstevel@tonic-gate 
25717c478bd9Sstevel@tonic-gate /*
25727c478bd9Sstevel@tonic-gate  * This routine is called after kmdb has loaded its initial set of modules.
25737c478bd9Sstevel@tonic-gate  */
25747c478bd9Sstevel@tonic-gate void
kmdb_kvm_poststartup(void)25757c478bd9Sstevel@tonic-gate kmdb_kvm_poststartup(void)
25767c478bd9Sstevel@tonic-gate {
25777c478bd9Sstevel@tonic-gate 	mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm post-startup\n");
25787c478bd9Sstevel@tonic-gate 
25797c478bd9Sstevel@tonic-gate 	(void) mdb_dis_select(kmt_def_dismode());
25807c478bd9Sstevel@tonic-gate }
2581