xref: /illumos-gate/usr/src/cmd/mdb/common/mdb/mdb_kvm.c (revision 843e1988)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 /*
29  * Libkvm Kernel Target
30  *
31  * The libkvm kernel target provides access to both crash dumps and live
32  * kernels through /dev/ksyms and /dev/kmem, using the facilities provided by
33  * the libkvm.so library.  The target-specific data structures are shared
34  * between this file (common code) and the ISA-dependent parts of the target,
35  * and so they are defined in the mdb_kvm.h header.  The target processes an
36  * "executable" (/dev/ksyms or the unix.X file) which contains a primary
37  * .symtab and .dynsym, and then also iterates over the krtld module chain in
38  * the kernel in order to obtain a list of loaded modules and per-module symbol
39  * tables.  To improve startup performance, the per-module symbol tables are
40  * instantiated on-the-fly whenever an address lookup falls within the text
41  * section of a given module.  The target also relies on services from the
42  * mdb_ks (kernel support) module, which contains pieces of the implementation
43  * that must be compiled against the kernel implementation.
44  */
45 
46 #include <sys/modctl.h>
47 #include <sys/kobj.h>
48 #include <sys/kobj_impl.h>
49 #include <sys/utsname.h>
50 #include <sys/panic.h>
51 #include <sys/dumphdr.h>
52 #include <sys/dumpadm.h>
53 
54 #include <dlfcn.h>
55 #include <libctf.h>
56 #include <string.h>
57 #include <fcntl.h>
58 #include <errno.h>
59 
60 #include <mdb/mdb_target_impl.h>
61 #include <mdb/mdb_err.h>
62 #include <mdb/mdb_debug.h>
63 #include <mdb/mdb_string.h>
64 #include <mdb/mdb_modapi.h>
65 #include <mdb/mdb_io_impl.h>
66 #include <mdb/mdb_ctf.h>
67 #include <mdb/mdb_kvm.h>
68 #include <mdb/mdb_module.h>
69 #include <mdb/mdb_kb.h>
70 #include <mdb/mdb.h>
71 
72 #define	KT_RELOC_BUF(buf, obase, nbase) \
73 	((uintptr_t)(buf) - (uintptr_t)(obase) + (uintptr_t)(nbase))
74 
75 #define	KT_BAD_BUF(buf, base, size) \
76 	((uintptr_t)(buf) < (uintptr_t)(base) || \
77 	((uintptr_t)(buf) >= (uintptr_t)(base) + (uintptr_t)(size)))
78 
79 typedef struct kt_symarg {
80 	mdb_tgt_sym_f *sym_cb;		/* Caller's callback function */
81 	void *sym_data;			/* Callback function argument */
82 	uint_t sym_type;		/* Symbol type/binding filter */
83 	mdb_syminfo_t sym_info;		/* Symbol id and table id */
84 	const char *sym_obj;		/* Containing object */
85 } kt_symarg_t;
86 
87 typedef struct kt_maparg {
88 	mdb_tgt_t *map_target;		/* Target used for mapping iter */
89 	mdb_tgt_map_f *map_cb;		/* Caller's callback function */
90 	void *map_data;			/* Callback function argument */
91 } kt_maparg_t;
92 
93 static const char KT_MODULE[] = "mdb_ks";
94 static const char KT_CTFPARENT[] = "genunix";
95 
96 static void
97 kt_load_module(kt_data_t *kt, mdb_tgt_t *t, kt_module_t *km)
98 {
99 	km->km_data = mdb_alloc(km->km_datasz, UM_SLEEP);
100 
101 	(void) mdb_tgt_vread(t, km->km_data, km->km_datasz, km->km_symspace_va);
102 
103 	km->km_symbuf = (void *)
104 	    KT_RELOC_BUF(km->km_symtab_va, km->km_symspace_va, km->km_data);
105 
106 	km->km_strtab = (char *)
107 	    KT_RELOC_BUF(km->km_strtab_va, km->km_symspace_va, km->km_data);
108 
109 	km->km_symtab = mdb_gelf_symtab_create_raw(&kt->k_file->gf_ehdr,
110 	    &km->km_symtab_hdr, km->km_symbuf,
111 	    &km->km_strtab_hdr, km->km_strtab, MDB_TGT_SYMTAB);
112 }
113 
114 static void
115 kt_load_modules(kt_data_t *kt, mdb_tgt_t *t)
116 {
117 	char name[MAXNAMELEN];
118 	uintptr_t addr, head;
119 
120 	struct module kmod;
121 	struct modctl ctl;
122 	Shdr symhdr, strhdr;
123 	GElf_Sym sym;
124 
125 	kt_module_t *km;
126 
127 	if (mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EXEC,
128 	    "modules", &sym, NULL) == -1) {
129 		warn("failed to get 'modules' symbol");
130 		return;
131 	}
132 
133 	if (mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, &ctl, sizeof (ctl),
134 	    MDB_TGT_OBJ_EXEC, "modules") != sizeof (ctl)) {
135 		warn("failed to read 'modules' struct");
136 		return;
137 	}
138 
139 	addr = head = (uintptr_t)sym.st_value;
140 
141 	do {
142 		if (addr == NULL)
143 			break; /* Avoid spurious NULL pointers in list */
144 
145 		if (mdb_tgt_vread(t, &ctl, sizeof (ctl), addr) == -1) {
146 			warn("failed to read modctl at %p", (void *)addr);
147 			return;
148 		}
149 
150 		if (ctl.mod_mp == NULL)
151 			continue; /* No associated krtld structure */
152 
153 		if (mdb_tgt_readstr(t, MDB_TGT_AS_VIRT, name, MAXNAMELEN,
154 		    (uintptr_t)ctl.mod_modname) <= 0) {
155 			warn("failed to read module name at %p",
156 			    (void *)ctl.mod_modname);
157 			continue;
158 		}
159 
160 		mdb_dprintf(MDB_DBG_KMOD, "reading mod %s (%p)\n",
161 		    name, (void *)addr);
162 
163 		if (mdb_nv_lookup(&kt->k_modules, name) != NULL) {
164 			warn("skipping duplicate module '%s', id=%d\n",
165 			    name, ctl.mod_id);
166 			continue;
167 		}
168 
169 		if (mdb_tgt_vread(t, &kmod, sizeof (kmod),
170 		    (uintptr_t)ctl.mod_mp) == -1) {
171 			warn("failed to read module at %p\n",
172 			    (void *)ctl.mod_mp);
173 			continue;
174 		}
175 
176 		if (kmod.symspace == NULL || kmod.symhdr == NULL ||
177 		    kmod.strhdr == NULL) {
178 			/*
179 			 * If no buffer for the symbols has been allocated,
180 			 * or the shdrs for .symtab and .strtab are missing,
181 			 * then we're out of luck.
182 			 */
183 			continue;
184 		}
185 
186 		if (mdb_tgt_vread(t, &symhdr, sizeof (Shdr),
187 		    (uintptr_t)kmod.symhdr) == -1) {
188 			warn("failed to read .symtab header for '%s', id=%d",
189 			    name, ctl.mod_id);
190 			continue;
191 		}
192 
193 		if (mdb_tgt_vread(t, &strhdr, sizeof (Shdr),
194 		    (uintptr_t)kmod.strhdr) == -1) {
195 			warn("failed to read .strtab header for '%s', id=%d",
196 			    name, ctl.mod_id);
197 			continue;
198 		}
199 
200 		/*
201 		 * Now get clever: f(*^ing krtld didn't used to bother updating
202 		 * its own kmod.symsize value.  We know that prior to this bug
203 		 * being fixed, symspace was a contiguous buffer containing
204 		 * .symtab, .strtab, and the symbol hash table in that order.
205 		 * So if symsize is zero, recompute it as the size of .symtab
206 		 * plus the size of .strtab.  We don't need to load the hash
207 		 * table anyway since we re-hash all the symbols internally.
208 		 */
209 		if (kmod.symsize == 0)
210 			kmod.symsize = symhdr.sh_size + strhdr.sh_size;
211 
212 		/*
213 		 * Similar logic can be used to make educated guesses
214 		 * at the values of kmod.symtbl and kmod.strings.
215 		 */
216 		if (kmod.symtbl == NULL)
217 			kmod.symtbl = kmod.symspace;
218 		if (kmod.strings == NULL)
219 			kmod.strings = kmod.symspace + symhdr.sh_size;
220 
221 		/*
222 		 * Make sure things seem reasonable before we proceed
223 		 * to actually read and decipher the symspace.
224 		 */
225 		if (KT_BAD_BUF(kmod.symtbl, kmod.symspace, kmod.symsize) ||
226 		    KT_BAD_BUF(kmod.strings, kmod.symspace, kmod.symsize)) {
227 			warn("skipping module '%s', id=%d (corrupt symspace)\n",
228 			    name, ctl.mod_id);
229 			continue;
230 		}
231 
232 		km = mdb_zalloc(sizeof (kt_module_t), UM_SLEEP);
233 		km->km_name = strdup(name);
234 
235 		(void) mdb_nv_insert(&kt->k_modules, km->km_name, NULL,
236 		    (uintptr_t)km, MDB_NV_EXTNAME);
237 
238 		km->km_datasz = kmod.symsize;
239 		km->km_symspace_va = (uintptr_t)kmod.symspace;
240 		km->km_symtab_va = (uintptr_t)kmod.symtbl;
241 		km->km_strtab_va = (uintptr_t)kmod.strings;
242 		km->km_symtab_hdr = symhdr;
243 		km->km_strtab_hdr = strhdr;
244 		km->km_text_va = (uintptr_t)kmod.text;
245 		km->km_text_size = kmod.text_size;
246 		km->km_data_va = (uintptr_t)kmod.data;
247 		km->km_data_size = kmod.data_size;
248 		km->km_bss_va = (uintptr_t)kmod.bss;
249 		km->km_bss_size = kmod.bss_size;
250 
251 		if (kt->k_ctfvalid) {
252 			km->km_ctf_va = (uintptr_t)kmod.ctfdata;
253 			km->km_ctf_size = kmod.ctfsize;
254 		}
255 
256 		/*
257 		 * Add the module to the end of the list of modules in load-
258 		 * dependency order.  This is needed to load the corresponding
259 		 * debugger modules in the same order for layering purposes.
260 		 */
261 		mdb_list_append(&kt->k_modlist, km);
262 
263 		if (t->t_flags & MDB_TGT_F_PRELOAD) {
264 			mdb_iob_printf(mdb.m_out, " %s", name);
265 			mdb_iob_flush(mdb.m_out);
266 			kt_load_module(kt, t, km);
267 		}
268 
269 	} while ((addr = (uintptr_t)ctl.mod_next) != head);
270 }
271 
272 int
273 kt_setflags(mdb_tgt_t *t, int flags)
274 {
275 	int iochg = ((flags ^ t->t_flags) & MDB_TGT_F_ALLOWIO) &&
276 	    !mdb_prop_postmortem;
277 	int rwchg = (flags ^ t->t_flags) & MDB_TGT_F_RDWR;
278 	kt_data_t *kt = t->t_data;
279 	const char *kvmfile;
280 	void *cookie;
281 	int mode;
282 
283 	if (!iochg && !rwchg)
284 		return (0);
285 
286 	if (kt->k_xpv_domu) {
287 		warn("read-only target");
288 		return (-1);
289 	}
290 
291 	if (iochg) {
292 		kvmfile = (flags & MDB_TGT_F_ALLOWIO) ? "/dev/allkmem" :
293 		    "/dev/kmem";
294 	} else {
295 		kvmfile = kt->k_kvmfile;
296 	}
297 
298 	mode = (flags & MDB_TGT_F_RDWR) ? O_RDWR : O_RDONLY;
299 
300 	if ((cookie = kt->k_kb_ops->kb_open(kt->k_symfile, kvmfile, NULL, mode,
301 	    mdb.m_pname)) == NULL) {
302 		/* We failed to re-open, so don't change t_flags */
303 		warn("failed to re-open target");
304 		return (-1);
305 	}
306 
307 	/*
308 	 * We successfully reopened the target, so update k_kvmfile.  Also set
309 	 * the RDWR and ALLOWIO bits in t_flags to match those in flags.
310 	 */
311 	(void) kt->k_kb_ops->kb_close(kt->k_cookie);
312 	kt->k_cookie = cookie;
313 
314 	if (kvmfile != kt->k_kvmfile) {
315 		strfree(kt->k_kvmfile);
316 		kt->k_kvmfile = strdup(kvmfile);
317 	}
318 
319 	t->t_flags = (t->t_flags & ~(MDB_TGT_F_RDWR | MDB_TGT_F_ALLOWIO)) |
320 	    (flags & (MDB_TGT_F_RDWR | MDB_TGT_F_ALLOWIO));
321 
322 	return (0);
323 }
324 
325 /*
326  * Determine which PIDs (if any) have their pages saved in the dump.  We
327  * do this by looking for content flags in dump_flags in the header.  These
328  * flags, which won't be set in older dumps, tell us whether a single process
329  * has had its pages included in the dump.  If a single process has been
330  * included, we need to get the PID for that process from the dump_pids
331  * array in the dump.
332  */
333 static int
334 kt_find_dump_contents(kt_data_t *kt)
335 {
336 	dumphdr_t *dh = kt->k_dumphdr;
337 	pid_t pid = -1;
338 
339 	if (dh->dump_flags & DF_ALL)
340 		return (KT_DUMPCONTENT_ALL);
341 
342 	if (dh->dump_flags & DF_CURPROC) {
343 		if ((pid = kt->k_dump_find_curproc()) == -1)
344 			return (KT_DUMPCONTENT_INVALID);
345 		else
346 			return (pid);
347 	} else {
348 		return (KT_DUMPCONTENT_KERNEL);
349 	}
350 }
351 
352 static int
353 kt_dump_contains_proc(mdb_tgt_t *t, void *context)
354 {
355 	kt_data_t *kt = t->t_data;
356 	pid_t (*f_pid)(uintptr_t);
357 	pid_t reqpid;
358 
359 	switch (kt->k_dumpcontent) {
360 	case KT_DUMPCONTENT_KERNEL:
361 		return (0);
362 	case KT_DUMPCONTENT_ALL:
363 		return (1);
364 	case KT_DUMPCONTENT_INVALID:
365 		goto procnotfound;
366 	default:
367 		f_pid = (pid_t (*)()) dlsym(RTLD_NEXT, "mdb_kproc_pid");
368 		if (f_pid == NULL)
369 			goto procnotfound;
370 
371 		reqpid = f_pid((uintptr_t)context);
372 		if (reqpid == -1)
373 			goto procnotfound;
374 
375 		return (kt->k_dumpcontent == reqpid);
376 	}
377 
378 procnotfound:
379 	warn("unable to determine whether dump contains proc %p\n", context);
380 	return (1);
381 }
382 
383 int
384 kt_setcontext(mdb_tgt_t *t, void *context)
385 {
386 	if (context != NULL) {
387 		const char *argv[2];
388 		int argc = 0;
389 		mdb_tgt_t *ct;
390 		kt_data_t *kt = t->t_data;
391 
392 		argv[argc++] = (const char *)context;
393 		argv[argc] = NULL;
394 
395 		if (kt->k_dumphdr != NULL &&
396 		    !kt_dump_contains_proc(t, context)) {
397 			warn("dump does not contain pages for proc %p\n",
398 			    context);
399 			return (-1);
400 		}
401 
402 		if ((ct = mdb_tgt_create(mdb_kproc_tgt_create,
403 		    t->t_flags, argc, argv)) == NULL)
404 			return (-1);
405 
406 		mdb_printf("debugger context set to proc %p\n", context);
407 		mdb_tgt_activate(ct);
408 	} else
409 		mdb_printf("debugger context set to kernel\n");
410 
411 	return (0);
412 }
413 
414 static int
415 kt_stack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
416 {
417 	kt_data_t *kt = mdb.m_target->t_data;
418 	return (kt->k_dcmd_stack(addr, flags, argc, argv));
419 }
420 
421 static int
422 kt_stackv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
423 {
424 	kt_data_t *kt = mdb.m_target->t_data;
425 	return (kt->k_dcmd_stackv(addr, flags, argc, argv));
426 }
427 
428 static int
429 kt_stackr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
430 {
431 	kt_data_t *kt = mdb.m_target->t_data;
432 	return (kt->k_dcmd_stackr(addr, flags, argc, argv));
433 }
434 
435 static int
436 kt_regs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
437 {
438 	kt_data_t *kt = mdb.m_target->t_data;
439 
440 	if (argc != 0 || (flags & DCMD_ADDRSPEC))
441 		return (DCMD_USAGE);
442 
443 	addr = (uintptr_t)kt->k_regs;
444 
445 	return (kt->k_dcmd_regs(addr, flags, argc, argv));
446 }
447 
448 #ifdef __x86
449 static int
450 kt_cpustack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
451 {
452 	kt_data_t *kt = mdb.m_target->t_data;
453 	return (kt->k_dcmd_cpustack(addr, flags, argc, argv));
454 }
455 
456 static int
457 kt_cpuregs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
458 {
459 	kt_data_t *kt = mdb.m_target->t_data;
460 	return (kt->k_dcmd_cpuregs(addr, flags, argc, argv));
461 }
462 #endif /* __x86 */
463 
464 /*ARGSUSED*/
465 static int
466 kt_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
467 {
468 	kt_data_t *kt = mdb.m_target->t_data;
469 	struct utsname uts;
470 
471 	bzero(&uts, sizeof (uts));
472 	(void) strcpy(uts.nodename, "unknown machine");
473 	(void) kt_uname(mdb.m_target, &uts);
474 
475 	if (mdb_prop_postmortem) {
476 		mdb_printf("debugging %scrash dump %s (%d-bit) from %s\n",
477 		    kt->k_xpv_domu ? "domain " : "", kt->k_kvmfile,
478 		    (int)(sizeof (void *) * NBBY), uts.nodename);
479 	} else {
480 		mdb_printf("debugging live kernel (%d-bit) on %s\n",
481 		    (int)(sizeof (void *) * NBBY), uts.nodename);
482 	}
483 
484 	mdb_printf("operating system: %s %s (%s)\n",
485 	    uts.release, uts.version, uts.machine);
486 
487 	if (kt->k_dumphdr) {
488 		dumphdr_t *dh = kt->k_dumphdr;
489 
490 		mdb_printf("panic message: %s\n", dh->dump_panicstring);
491 
492 		kt->k_dump_print_content(dh, kt->k_dumpcontent);
493 	}
494 
495 	return (DCMD_OK);
496 }
497 
498 static const mdb_dcmd_t kt_dcmds[] = {
499 	{ "$c", "?[cnt]", "print stack backtrace", kt_stack },
500 	{ "$C", "?[cnt]", "print stack backtrace", kt_stackv },
501 	{ "$r", NULL, "print general-purpose registers", kt_regs },
502 	{ "$?", NULL, "print status and registers", kt_regs },
503 	{ "regs", NULL, "print general-purpose registers", kt_regs },
504 	{ "stack", "?[cnt]", "print stack backtrace", kt_stack },
505 	{ "stackregs", "?", "print stack backtrace and registers", kt_stackr },
506 #ifdef __x86
507 	{ "cpustack", "?[-v] [-c cpuid] [cnt]", "print stack backtrace for a "
508 	    "specific CPU", kt_cpustack },
509 	{ "cpuregs", "?[-c cpuid]", "print general-purpose registers for a "
510 	    "specific CPU", kt_cpuregs },
511 #endif
512 	{ "status", NULL, "print summary of current target", kt_status_dcmd },
513 	{ NULL }
514 };
515 
516 static uintmax_t
517 reg_disc_get(const mdb_var_t *v)
518 {
519 	mdb_tgt_t *t = MDB_NV_COOKIE(v);
520 	kt_data_t *kt = t->t_data;
521 	mdb_tgt_reg_t r = 0;
522 
523 	(void) mdb_tgt_getareg(t, kt->k_tid, mdb_nv_get_name(v), &r);
524 	return (r);
525 }
526 
527 static kt_module_t *
528 kt_module_by_name(kt_data_t *kt, const char *name)
529 {
530 	kt_module_t *km;
531 
532 	for (km = mdb_list_next(&kt->k_modlist); km; km = mdb_list_next(km)) {
533 		if (strcmp(name, km->km_name) == 0)
534 			return (km);
535 	}
536 
537 	return (NULL);
538 }
539 
540 void
541 kt_activate(mdb_tgt_t *t)
542 {
543 	static const mdb_nv_disc_t reg_disc = { NULL, reg_disc_get };
544 	kt_data_t *kt = t->t_data;
545 	void *sym;
546 
547 	int oflag;
548 
549 	mdb_prop_postmortem = kt->k_xpv_domu || (kt->k_dumphdr != NULL);
550 	mdb_prop_kernel = TRUE;
551 	mdb_prop_datamodel = MDB_TGT_MODEL_NATIVE;
552 
553 	if (kt->k_activated == FALSE) {
554 		struct utsname u1, u2;
555 		/*
556 		 * If we're examining a crash dump, root is /, and uname(2)
557 		 * does not match the utsname in the dump, issue a warning.
558 		 * Note that we are assuming that the modules and macros in
559 		 * /usr/lib are compiled against the kernel from uname -rv.
560 		 */
561 		if (mdb_prop_postmortem && strcmp(mdb.m_root, "/") == 0 &&
562 		    uname(&u1) >= 0 && kt_uname(t, &u2) >= 0 &&
563 		    (strcmp(u1.release, u2.release) ||
564 		    strcmp(u1.version, u2.version))) {
565 			mdb_warn("warning: dump is from %s %s %s; dcmds and "
566 			    "macros may not match kernel implementation\n",
567 			    u2.sysname, u2.release, u2.version);
568 		}
569 
570 		if (mdb_module_load(KT_MODULE, MDB_MOD_GLOBAL) < 0) {
571 			warn("failed to load kernel support module -- "
572 			    "some modules may not load\n");
573 		}
574 
575 		if (mdb_prop_postmortem && kt->k_dumphdr != NULL) {
576 			sym = dlsym(RTLD_NEXT, "mdb_dump_print_content");
577 			if (sym != NULL)
578 				kt->k_dump_print_content = (void (*)())sym;
579 
580 			sym = dlsym(RTLD_NEXT, "mdb_dump_find_curproc");
581 			if (sym != NULL)
582 				kt->k_dump_find_curproc = (int (*)())sym;
583 
584 			kt->k_dumpcontent = kt_find_dump_contents(kt);
585 		}
586 
587 		if (t->t_flags & MDB_TGT_F_PRELOAD) {
588 			oflag = mdb_iob_getflags(mdb.m_out) & MDB_IOB_PGENABLE;
589 
590 			mdb_iob_clrflags(mdb.m_out, oflag);
591 			mdb_iob_puts(mdb.m_out, "Preloading module symbols: [");
592 			mdb_iob_flush(mdb.m_out);
593 		}
594 
595 		if (!(t->t_flags & MDB_TGT_F_NOLOAD)) {
596 			kt_load_modules(kt, t);
597 
598 			/*
599 			 * Determine where the CTF data for krtld is. If krtld
600 			 * is rolled into unix, force load the MDB krtld
601 			 * module.
602 			 */
603 			kt->k_rtld_name = "krtld";
604 
605 			if (kt_module_by_name(kt, "krtld") == NULL) {
606 				(void) mdb_module_load("krtld", MDB_MOD_SILENT);
607 				kt->k_rtld_name = "unix";
608 			}
609 		}
610 
611 
612 		if (t->t_flags & MDB_TGT_F_PRELOAD) {
613 			mdb_iob_puts(mdb.m_out, " ]\n");
614 			mdb_iob_setflags(mdb.m_out, oflag);
615 		}
616 
617 		kt->k_activated = TRUE;
618 	}
619 
620 	(void) mdb_tgt_register_dcmds(t, &kt_dcmds[0], MDB_MOD_FORCE);
621 
622 	/* Export some of our registers as named variables */
623 	mdb_tgt_register_regvars(t, kt->k_rds, &reg_disc, MDB_NV_RDONLY);
624 
625 	mdb_tgt_elf_export(kt->k_file);
626 }
627 
628 void
629 kt_deactivate(mdb_tgt_t *t)
630 {
631 	kt_data_t *kt = t->t_data;
632 
633 	const mdb_tgt_regdesc_t *rdp;
634 	const mdb_dcmd_t *dcp;
635 
636 	for (rdp = kt->k_rds; rdp->rd_name != NULL; rdp++) {
637 		mdb_var_t *v;
638 
639 		if (!(rdp->rd_flags & MDB_TGT_R_EXPORT))
640 			continue; /* Didn't export register as a variable */
641 
642 		if ((v = mdb_nv_lookup(&mdb.m_nv, rdp->rd_name)) != NULL) {
643 			v->v_flags &= ~MDB_NV_PERSIST;
644 			mdb_nv_remove(&mdb.m_nv, v);
645 		}
646 	}
647 
648 	for (dcp = &kt_dcmds[0]; dcp->dc_name != NULL; dcp++) {
649 		if (mdb_module_remove_dcmd(t->t_module, dcp->dc_name) == -1)
650 			warn("failed to remove dcmd %s", dcp->dc_name);
651 	}
652 
653 	mdb_prop_postmortem = FALSE;
654 	mdb_prop_kernel = FALSE;
655 	mdb_prop_datamodel = MDB_TGT_MODEL_UNKNOWN;
656 }
657 
658 /*ARGSUSED*/
659 const char *
660 kt_name(mdb_tgt_t *t)
661 {
662 	return ("kvm");
663 }
664 
665 const char *
666 kt_platform(mdb_tgt_t *t)
667 {
668 	kt_data_t *kt = t->t_data;
669 	return (kt->k_platform);
670 }
671 
672 int
673 kt_uname(mdb_tgt_t *t, struct utsname *utsp)
674 {
675 	return (mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, utsp,
676 	    sizeof (struct utsname), MDB_TGT_OBJ_EXEC, "utsname"));
677 }
678 
679 /*ARGSUSED*/
680 int
681 kt_dmodel(mdb_tgt_t *t)
682 {
683 	return (MDB_TGT_MODEL_NATIVE);
684 }
685 
686 ssize_t
687 kt_aread(mdb_tgt_t *t, mdb_tgt_as_t as, void *buf,
688     size_t nbytes, mdb_tgt_addr_t addr)
689 {
690 	kt_data_t *kt = t->t_data;
691 	ssize_t rval;
692 
693 	if ((rval = kt->k_kb_ops->kb_aread(kt->k_cookie, addr, buf,
694 	    nbytes, as)) == -1)
695 		return (set_errno(EMDB_NOMAP));
696 
697 	return (rval);
698 }
699 
700 ssize_t
701 kt_awrite(mdb_tgt_t *t, mdb_tgt_as_t as, const void *buf,
702     size_t nbytes, mdb_tgt_addr_t addr)
703 {
704 	kt_data_t *kt = t->t_data;
705 	ssize_t rval;
706 
707 	if ((rval = kt->k_kb_ops->kb_awrite(kt->k_cookie, addr, buf,
708 	    nbytes, as)) == -1)
709 		return (set_errno(EMDB_NOMAP));
710 
711 	return (rval);
712 }
713 
714 ssize_t
715 kt_vread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
716 {
717 	kt_data_t *kt = t->t_data;
718 	ssize_t rval;
719 
720 	if ((rval = kt->k_kb_ops->kb_kread(kt->k_cookie, addr, buf,
721 	    nbytes)) == -1)
722 		return (set_errno(EMDB_NOMAP));
723 
724 	return (rval);
725 }
726 
727 ssize_t
728 kt_vwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
729 {
730 	kt_data_t *kt = t->t_data;
731 	ssize_t rval;
732 
733 	if ((rval = kt->k_kb_ops->kb_kwrite(kt->k_cookie, addr, buf,
734 	    nbytes)) == -1)
735 		return (set_errno(EMDB_NOMAP));
736 
737 	return (rval);
738 }
739 
740 ssize_t
741 kt_fread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
742 {
743 	return (kt_vread(t, buf, nbytes, addr));
744 }
745 
746 ssize_t
747 kt_fwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
748 {
749 	return (kt_vwrite(t, buf, nbytes, addr));
750 }
751 
752 ssize_t
753 kt_pread(mdb_tgt_t *t, void *buf, size_t nbytes, physaddr_t addr)
754 {
755 	kt_data_t *kt = t->t_data;
756 	ssize_t rval;
757 
758 	if ((rval = kt->k_kb_ops->kb_pread(kt->k_cookie, addr, buf,
759 	    nbytes)) == -1)
760 		return (set_errno(EMDB_NOMAP));
761 
762 	return (rval);
763 }
764 
765 ssize_t
766 kt_pwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, physaddr_t addr)
767 {
768 	kt_data_t *kt = t->t_data;
769 	ssize_t rval;
770 
771 	if ((rval = kt->k_kb_ops->kb_pwrite(kt->k_cookie, addr, buf,
772 	    nbytes)) == -1)
773 		return (set_errno(EMDB_NOMAP));
774 
775 	return (rval);
776 }
777 
778 int
779 kt_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap)
780 {
781 	kt_data_t *kt = t->t_data;
782 
783 	struct as *asp;
784 	physaddr_t pa;
785 	mdb_module_t *mod;
786 	mdb_var_t *v;
787 	int (*fptr)(uintptr_t, struct as *, physaddr_t *);
788 
789 	switch ((uintptr_t)as) {
790 	case (uintptr_t)MDB_TGT_AS_PHYS:
791 	case (uintptr_t)MDB_TGT_AS_FILE:
792 	case (uintptr_t)MDB_TGT_AS_IO:
793 		return (set_errno(EINVAL));
794 	case (uintptr_t)MDB_TGT_AS_VIRT:
795 		asp = kt->k_as;
796 		break;
797 	default:
798 		asp = (struct as *)as;
799 	}
800 
801 	if ((pa = kt->k_kb_ops->kb_vtop(kt->k_cookie, asp, va)) != -1ULL) {
802 		*pap = pa;
803 		return (0);
804 	}
805 
806 	if ((v = mdb_nv_lookup(&mdb.m_modules, "unix")) != NULL &&
807 	    (mod = mdb_nv_get_cookie(v)) != NULL) {
808 
809 		fptr = (int (*)(uintptr_t, struct as *, physaddr_t *))
810 		    dlsym(mod->mod_hdl, "platform_vtop");
811 
812 		if ((fptr != NULL) && ((*fptr)(va, asp, pap) == 0))
813 			return (0);
814 	}
815 
816 	return (set_errno(EMDB_NOMAP));
817 }
818 
819 int
820 kt_lookup_by_name(mdb_tgt_t *t, const char *obj, const char *name,
821     GElf_Sym *symp, mdb_syminfo_t *sip)
822 {
823 	kt_data_t *kt = t->t_data;
824 	kt_module_t *km, kmod;
825 	mdb_var_t *v;
826 	int n;
827 
828 	/*
829 	 * To simplify the implementation, we create a fake module on the stack
830 	 * which is "prepended" to k_modlist and whose symtab is kt->k_symtab.
831 	 */
832 	kmod.km_symtab = kt->k_symtab;
833 	kmod.km_list.ml_next = mdb_list_next(&kt->k_modlist);
834 
835 	switch ((uintptr_t)obj) {
836 	case (uintptr_t)MDB_TGT_OBJ_EXEC:
837 		km = &kmod;
838 		n = 1;
839 		break;
840 
841 	case (uintptr_t)MDB_TGT_OBJ_EVERY:
842 		km = &kmod;
843 		n = mdb_nv_size(&kt->k_modules) + 1;
844 		break;
845 
846 	case (uintptr_t)MDB_TGT_OBJ_RTLD:
847 		obj = kt->k_rtld_name;
848 		/*FALLTHRU*/
849 
850 	default:
851 		if ((v = mdb_nv_lookup(&kt->k_modules, obj)) == NULL)
852 			return (set_errno(EMDB_NOOBJ));
853 
854 		km = mdb_nv_get_cookie(v);
855 		n = 1;
856 
857 		if (km->km_symtab == NULL)
858 			kt_load_module(kt, t, km);
859 	}
860 
861 	for (; n > 0; n--, km = mdb_list_next(km)) {
862 		if (mdb_gelf_symtab_lookup_by_name(km->km_symtab, name,
863 		    symp, &sip->sym_id) == 0) {
864 			sip->sym_table = MDB_TGT_SYMTAB;
865 			return (0);
866 		}
867 	}
868 
869 	return (set_errno(EMDB_NOSYM));
870 }
871 
872 int
873 kt_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags,
874     char *buf, size_t nbytes, GElf_Sym *symp, mdb_syminfo_t *sip)
875 {
876 	kt_data_t *kt = t->t_data;
877 	kt_module_t kmods[3], *kmods_begin = &kmods[0], *kmods_end;
878 	const char *name;
879 
880 	kt_module_t *km = &kmods[0];	/* Point km at first fake module */
881 	kt_module_t *sym_km = NULL;	/* Module associated with best sym */
882 	GElf_Sym sym;			/* Best symbol found so far if !exact */
883 	uint_t symid;			/* ID of best symbol found so far */
884 
885 	/*
886 	 * To simplify the implementation, we create fake modules on the stack
887 	 * that are "prepended" to k_modlist and whose symtab is set to
888 	 * each of three special symbol tables, in order of precedence.
889 	 */
890 	km->km_symtab = mdb.m_prsym;
891 
892 	if (kt->k_symtab != NULL) {
893 		km->km_list.ml_next = (mdb_list_t *)(km + 1);
894 		km = mdb_list_next(km);
895 		km->km_symtab = kt->k_symtab;
896 	}
897 
898 	if (kt->k_dynsym != NULL) {
899 		km->km_list.ml_next = (mdb_list_t *)(km + 1);
900 		km = mdb_list_next(km);
901 		km->km_symtab = kt->k_dynsym;
902 	}
903 
904 	km->km_list.ml_next = mdb_list_next(&kt->k_modlist);
905 	kmods_end = km;
906 
907 	/*
908 	 * Now iterate over the list of fake and real modules.  If the module
909 	 * has no symbol table and the address is in the text section,
910 	 * instantiate the module's symbol table.  In exact mode, we can
911 	 * jump to 'found' immediately if we match.  Otherwise we continue
912 	 * looking and improve our choice if we find a closer symbol.
913 	 */
914 	for (km = &kmods[0]; km != NULL; km = mdb_list_next(km)) {
915 		if (km->km_symtab == NULL && addr >= km->km_text_va &&
916 		    addr < km->km_text_va + km->km_text_size)
917 			kt_load_module(kt, t, km);
918 
919 		if (mdb_gelf_symtab_lookup_by_addr(km->km_symtab, addr,
920 		    flags, buf, nbytes, symp, &sip->sym_id) != 0 ||
921 		    symp->st_value == 0)
922 			continue;
923 
924 		if (flags & MDB_TGT_SYM_EXACT) {
925 			sym_km = km;
926 			goto found;
927 		}
928 
929 		if (sym_km == NULL || mdb_gelf_sym_closer(symp, &sym, addr)) {
930 			sym_km = km;
931 			sym = *symp;
932 			symid = sip->sym_id;
933 		}
934 	}
935 
936 	if (sym_km == NULL)
937 		return (set_errno(EMDB_NOSYMADDR));
938 
939 	*symp = sym; /* Copy our best symbol into the caller's symbol */
940 	sip->sym_id = symid;
941 found:
942 	/*
943 	 * Once we've found something, copy the final name into the caller's
944 	 * buffer and prefix it with the load object name if appropriate.
945 	 */
946 	if (sym_km != NULL) {
947 		name = mdb_gelf_sym_name(sym_km->km_symtab, symp);
948 
949 		if (sym_km < kmods_begin || sym_km > kmods_end) {
950 			(void) mdb_snprintf(buf, nbytes, "%s`%s",
951 			    sym_km->km_name, name);
952 		} else if (nbytes > 0) {
953 			(void) strncpy(buf, name, nbytes);
954 			buf[nbytes - 1] = '\0';
955 		}
956 
957 		if (sym_km->km_symtab == mdb.m_prsym)
958 			sip->sym_table = MDB_TGT_PRVSYM;
959 		else
960 			sip->sym_table = MDB_TGT_SYMTAB;
961 	} else {
962 		sip->sym_table = MDB_TGT_SYMTAB;
963 	}
964 
965 	return (0);
966 }
967 
968 static int
969 kt_symtab_func(void *data, const GElf_Sym *sym, const char *name, uint_t id)
970 {
971 	kt_symarg_t *argp = data;
972 
973 	if (mdb_tgt_sym_match(sym, argp->sym_type)) {
974 		argp->sym_info.sym_id = id;
975 
976 		return (argp->sym_cb(argp->sym_data, sym, name,
977 		    &argp->sym_info, argp->sym_obj));
978 	}
979 
980 	return (0);
981 }
982 
983 static void
984 kt_symtab_iter(mdb_gelf_symtab_t *gst, uint_t type, const char *obj,
985     mdb_tgt_sym_f *cb, void *p)
986 {
987 	kt_symarg_t arg;
988 
989 	arg.sym_cb = cb;
990 	arg.sym_data = p;
991 	arg.sym_type = type;
992 	arg.sym_info.sym_table = gst->gst_tabid;
993 	arg.sym_obj = obj;
994 
995 	mdb_gelf_symtab_iter(gst, kt_symtab_func, &arg);
996 }
997 
998 int
999 kt_symbol_iter(mdb_tgt_t *t, const char *obj, uint_t which, uint_t type,
1000     mdb_tgt_sym_f *cb, void *data)
1001 {
1002 	kt_data_t *kt = t->t_data;
1003 	kt_module_t *km;
1004 
1005 	mdb_gelf_symtab_t *symtab = NULL;
1006 	mdb_var_t *v;
1007 
1008 	switch ((uintptr_t)obj) {
1009 	case (uintptr_t)MDB_TGT_OBJ_EXEC:
1010 		if (which == MDB_TGT_SYMTAB)
1011 			symtab = kt->k_symtab;
1012 		else
1013 			symtab = kt->k_dynsym;
1014 		break;
1015 
1016 	case (uintptr_t)MDB_TGT_OBJ_EVERY:
1017 		if (which == MDB_TGT_DYNSYM) {
1018 			symtab = kt->k_dynsym;
1019 			obj = MDB_TGT_OBJ_EXEC;
1020 			break;
1021 		}
1022 
1023 		mdb_nv_rewind(&kt->k_modules);
1024 		while ((v = mdb_nv_advance(&kt->k_modules)) != NULL) {
1025 			km = mdb_nv_get_cookie(v);
1026 
1027 			if (km->km_symtab == NULL)
1028 				kt_load_module(kt, t, km);
1029 
1030 			if (km->km_symtab != NULL)
1031 				kt_symtab_iter(km->km_symtab, type,
1032 				    km->km_name, cb, data);
1033 		}
1034 		break;
1035 
1036 	case (uintptr_t)MDB_TGT_OBJ_RTLD:
1037 		obj = kt->k_rtld_name;
1038 		/*FALLTHRU*/
1039 
1040 	default:
1041 		v = mdb_nv_lookup(&kt->k_modules, obj);
1042 
1043 		if (v == NULL)
1044 			return (set_errno(EMDB_NOOBJ));
1045 
1046 		km = mdb_nv_get_cookie(v);
1047 
1048 		if (km->km_symtab == NULL)
1049 			kt_load_module(kt, t, km);
1050 
1051 		symtab = km->km_symtab;
1052 	}
1053 
1054 	if (symtab)
1055 		kt_symtab_iter(symtab, type, obj, cb, data);
1056 
1057 	return (0);
1058 }
1059 
1060 static int
1061 kt_mapping_walk(uintptr_t addr, const void *data, kt_maparg_t *marg)
1062 {
1063 	/*
1064 	 * This is a bit sketchy but avoids problematic compilation of this
1065 	 * target against the current VM implementation.  Now that we have
1066 	 * vmem, we can make this less broken and more informative by changing
1067 	 * this code to invoke the vmem walker in the near future.
1068 	 */
1069 	const struct kt_seg {
1070 		caddr_t s_base;
1071 		size_t s_size;
1072 	} *segp = (const struct kt_seg *)data;
1073 
1074 	mdb_map_t map;
1075 	GElf_Sym sym;
1076 	mdb_syminfo_t info;
1077 
1078 	map.map_base = (uintptr_t)segp->s_base;
1079 	map.map_size = segp->s_size;
1080 	map.map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X;
1081 
1082 	if (kt_lookup_by_addr(marg->map_target, addr, MDB_TGT_SYM_EXACT,
1083 	    map.map_name, MDB_TGT_MAPSZ, &sym, &info) == -1) {
1084 
1085 		(void) mdb_iob_snprintf(map.map_name, MDB_TGT_MAPSZ,
1086 		    "%lr", addr);
1087 	}
1088 
1089 	return (marg->map_cb(marg->map_data, &map, map.map_name));
1090 }
1091 
1092 int
1093 kt_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
1094 {
1095 	kt_data_t *kt = t->t_data;
1096 	kt_maparg_t m;
1097 
1098 	m.map_target = t;
1099 	m.map_cb = func;
1100 	m.map_data = private;
1101 
1102 	return (mdb_pwalk("seg", (mdb_walk_cb_t)kt_mapping_walk, &m,
1103 	    (uintptr_t)kt->k_as));
1104 }
1105 
1106 static const mdb_map_t *
1107 kt_module_to_map(kt_module_t *km, mdb_map_t *map)
1108 {
1109 	(void) strncpy(map->map_name, km->km_name, MDB_TGT_MAPSZ);
1110 	map->map_name[MDB_TGT_MAPSZ - 1] = '\0';
1111 	map->map_base = km->km_text_va;
1112 	map->map_size = km->km_text_size;
1113 	map->map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X;
1114 
1115 	return (map);
1116 }
1117 
1118 int
1119 kt_object_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
1120 {
1121 	kt_data_t *kt = t->t_data;
1122 	kt_module_t *km;
1123 	mdb_map_t m;
1124 
1125 	for (km = mdb_list_next(&kt->k_modlist); km; km = mdb_list_next(km)) {
1126 		if (func(private, kt_module_to_map(km, &m), km->km_name) == -1)
1127 			break;
1128 	}
1129 
1130 	return (0);
1131 }
1132 
1133 const mdb_map_t *
1134 kt_addr_to_map(mdb_tgt_t *t, uintptr_t addr)
1135 {
1136 	kt_data_t *kt = t->t_data;
1137 	kt_module_t *km;
1138 
1139 	for (km = mdb_list_next(&kt->k_modlist); km; km = mdb_list_next(km)) {
1140 		if (addr - km->km_text_va < km->km_text_size ||
1141 		    addr - km->km_data_va < km->km_data_size ||
1142 		    addr - km->km_bss_va < km->km_bss_size)
1143 			return (kt_module_to_map(km, &kt->k_map));
1144 	}
1145 
1146 	(void) set_errno(EMDB_NOMAP);
1147 	return (NULL);
1148 }
1149 
1150 const mdb_map_t *
1151 kt_name_to_map(mdb_tgt_t *t, const char *name)
1152 {
1153 	kt_data_t *kt = t->t_data;
1154 	kt_module_t *km;
1155 	mdb_map_t m;
1156 
1157 	/*
1158 	 * If name is MDB_TGT_OBJ_EXEC, return the first module on the list,
1159 	 * which will be unix since we keep k_modlist in load order.
1160 	 */
1161 	if (name == MDB_TGT_OBJ_EXEC)
1162 		return (kt_module_to_map(mdb_list_next(&kt->k_modlist), &m));
1163 
1164 	if (name == MDB_TGT_OBJ_RTLD)
1165 		name = kt->k_rtld_name;
1166 
1167 	if ((km = kt_module_by_name(kt, name)) != NULL)
1168 		return (kt_module_to_map(km, &m));
1169 
1170 	(void) set_errno(EMDB_NOOBJ);
1171 	return (NULL);
1172 }
1173 
1174 static ctf_file_t *
1175 kt_load_ctfdata(mdb_tgt_t *t, kt_module_t *km)
1176 {
1177 	kt_data_t *kt = t->t_data;
1178 	int err;
1179 
1180 	if (km->km_ctfp != NULL)
1181 		return (km->km_ctfp);
1182 
1183 	if (km->km_ctf_va == NULL) {
1184 		(void) set_errno(EMDB_NOCTF);
1185 		return (NULL);
1186 	}
1187 
1188 	if (km->km_symtab == NULL)
1189 		kt_load_module(t->t_data, t, km);
1190 
1191 	if ((km->km_ctf_buf = mdb_alloc(km->km_ctf_size, UM_NOSLEEP)) == NULL) {
1192 		warn("failed to allocate memory to load %s debugging "
1193 		    "information", km->km_name);
1194 		return (NULL);
1195 	}
1196 
1197 	if (mdb_tgt_vread(t, km->km_ctf_buf, km->km_ctf_size,
1198 	    km->km_ctf_va) != km->km_ctf_size) {
1199 		warn("failed to read %lu bytes of debug data for %s at %p",
1200 		    (ulong_t)km->km_ctf_size, km->km_name,
1201 		    (void *)km->km_ctf_va);
1202 		mdb_free(km->km_ctf_buf, km->km_ctf_size);
1203 		km->km_ctf_buf = NULL;
1204 		return (NULL);
1205 	}
1206 
1207 	if ((km->km_ctfp = mdb_ctf_bufopen((const void *)km->km_ctf_buf,
1208 	    km->km_ctf_size, km->km_symbuf, &km->km_symtab_hdr,
1209 	    km->km_strtab, &km->km_strtab_hdr, &err)) == NULL) {
1210 		mdb_free(km->km_ctf_buf, km->km_ctf_size);
1211 		km->km_ctf_buf = NULL;
1212 		(void) set_errno(ctf_to_errno(err));
1213 		return (NULL);
1214 	}
1215 
1216 	mdb_dprintf(MDB_DBG_KMOD, "loaded %lu bytes of CTF data for %s\n",
1217 	    (ulong_t)km->km_ctf_size, km->km_name);
1218 
1219 	if (ctf_parent_name(km->km_ctfp) != NULL) {
1220 		mdb_var_t *v;
1221 
1222 		if ((v = mdb_nv_lookup(&kt->k_modules,
1223 		    ctf_parent_name(km->km_ctfp))) == NULL) {
1224 			warn("failed to load CTF data for %s - parent %s not "
1225 			    "loaded\n", km->km_name,
1226 			    ctf_parent_name(km->km_ctfp));
1227 		}
1228 
1229 		if (v != NULL) {
1230 			kt_module_t *pm = mdb_nv_get_cookie(v);
1231 
1232 			if (pm->km_ctfp == NULL)
1233 				(void) kt_load_ctfdata(t, pm);
1234 
1235 			if (pm->km_ctfp != NULL && ctf_import(km->km_ctfp,
1236 			    pm->km_ctfp) == CTF_ERR) {
1237 				warn("failed to import parent types into "
1238 				    "%s: %s\n", km->km_name,
1239 				    ctf_errmsg(ctf_errno(km->km_ctfp)));
1240 			}
1241 		}
1242 	}
1243 
1244 	return (km->km_ctfp);
1245 }
1246 
1247 ctf_file_t *
1248 kt_addr_to_ctf(mdb_tgt_t *t, uintptr_t addr)
1249 {
1250 	kt_data_t *kt = t->t_data;
1251 	kt_module_t *km;
1252 
1253 	for (km = mdb_list_next(&kt->k_modlist); km; km = mdb_list_next(km)) {
1254 		if (addr - km->km_text_va < km->km_text_size ||
1255 		    addr - km->km_data_va < km->km_data_size ||
1256 		    addr - km->km_bss_va < km->km_bss_size)
1257 			return (kt_load_ctfdata(t, km));
1258 	}
1259 
1260 	(void) set_errno(EMDB_NOMAP);
1261 	return (NULL);
1262 }
1263 
1264 ctf_file_t *
1265 kt_name_to_ctf(mdb_tgt_t *t, const char *name)
1266 {
1267 	kt_data_t *kt = t->t_data;
1268 	kt_module_t *km;
1269 
1270 	if (name == MDB_TGT_OBJ_EXEC)
1271 		name = KT_CTFPARENT;
1272 	else if (name == MDB_TGT_OBJ_RTLD)
1273 		name = kt->k_rtld_name;
1274 
1275 	if ((km = kt_module_by_name(kt, name)) != NULL)
1276 		return (kt_load_ctfdata(t, km));
1277 
1278 	(void) set_errno(EMDB_NOOBJ);
1279 	return (NULL);
1280 }
1281 
1282 /*ARGSUSED*/
1283 int
1284 kt_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1285 {
1286 	kt_data_t *kt = t->t_data;
1287 	bzero(tsp, sizeof (mdb_tgt_status_t));
1288 	tsp->st_state = (kt->k_xpv_domu || (kt->k_dumphdr != NULL)) ?
1289 	    MDB_TGT_DEAD : MDB_TGT_RUNNING;
1290 	return (0);
1291 }
1292 
1293 static ssize_t
1294 kt_xd_dumphdr(mdb_tgt_t *t, void *buf, size_t nbytes)
1295 {
1296 	kt_data_t *kt = t->t_data;
1297 
1298 	if (buf == NULL && nbytes == 0)
1299 		return (sizeof (dumphdr_t));
1300 
1301 	if (kt->k_dumphdr == NULL)
1302 		return (set_errno(ENODATA));
1303 
1304 	nbytes = MIN(nbytes, sizeof (dumphdr_t));
1305 	bcopy(kt->k_dumphdr, buf, nbytes);
1306 
1307 	return (nbytes);
1308 }
1309 
1310 void
1311 kt_destroy(mdb_tgt_t *t)
1312 {
1313 	kt_data_t *kt = t->t_data;
1314 	kt_module_t *km, *nkm;
1315 
1316 	(void) mdb_module_unload(KT_MODULE, 0);
1317 
1318 	if (kt->k_regs != NULL)
1319 		mdb_free(kt->k_regs, kt->k_regsize);
1320 
1321 	if (kt->k_symtab != NULL)
1322 		mdb_gelf_symtab_destroy(kt->k_symtab);
1323 
1324 	if (kt->k_dynsym != NULL)
1325 		mdb_gelf_symtab_destroy(kt->k_dynsym);
1326 
1327 	if (kt->k_dumphdr != NULL)
1328 		mdb_free(kt->k_dumphdr, sizeof (dumphdr_t));
1329 
1330 	mdb_gelf_destroy(kt->k_file);
1331 
1332 	(void) kt->k_kb_ops->kb_close(kt->k_cookie);
1333 
1334 	for (km = mdb_list_next(&kt->k_modlist); km; km = nkm) {
1335 		if (km->km_symtab)
1336 			mdb_gelf_symtab_destroy(km->km_symtab);
1337 
1338 		if (km->km_data)
1339 			mdb_free(km->km_data, km->km_datasz);
1340 
1341 		if (km->km_ctfp)
1342 			ctf_close(km->km_ctfp);
1343 
1344 		if (km->km_ctf_buf != NULL)
1345 			mdb_free(km->km_ctf_buf, km->km_ctf_size);
1346 
1347 		nkm = mdb_list_next(km);
1348 		strfree(km->km_name);
1349 		mdb_free(km, sizeof (kt_module_t));
1350 	}
1351 
1352 	mdb_nv_destroy(&kt->k_modules);
1353 
1354 	strfree(kt->k_kvmfile);
1355 	if (kt->k_symfile != NULL)
1356 		strfree(kt->k_symfile);
1357 
1358 	mdb_free(kt, sizeof (kt_data_t));
1359 }
1360 
1361 static int
1362 kt_data_stub(void)
1363 {
1364 	return (-1);
1365 }
1366 
1367 int
1368 mdb_kvm_tgt_create(mdb_tgt_t *t, int argc, const char *argv[])
1369 {
1370 	kt_data_t *kt = mdb_zalloc(sizeof (kt_data_t), UM_SLEEP);
1371 	mdb_kb_ops_t *kvm_kb_ops = libkvm_kb_ops();
1372 	int oflag = (t->t_flags & MDB_TGT_F_RDWR) ? O_RDWR : O_RDONLY;
1373 	struct utsname uts;
1374 	GElf_Sym sym;
1375 	pgcnt_t pmem;
1376 
1377 
1378 	if (argc == 2) {
1379 		kt->k_symfile = strdup(argv[0]);
1380 		kt->k_kvmfile = strdup(argv[1]);
1381 
1382 		kt->k_cookie = kvm_kb_ops->kb_open(kt->k_symfile,
1383 		    kt->k_kvmfile, NULL, oflag, (char *)mdb.m_pname);
1384 
1385 		if (kt->k_cookie == NULL)
1386 			goto err;
1387 
1388 		kt->k_xpv_domu = 0;
1389 		kt->k_kb_ops = kvm_kb_ops;
1390 	} else {
1391 #ifndef __x86
1392 		return (set_errno(EINVAL));
1393 #else
1394 		mdb_kb_ops_t *(*getops)(void);
1395 
1396 		kt->k_symfile = NULL;
1397 		kt->k_kvmfile = strdup(argv[0]);
1398 
1399 		getops = (mdb_kb_ops_t *(*)())dlsym(RTLD_NEXT, "mdb_kb_ops");
1400 
1401 		if (getops == NULL || (kt->k_kb_ops = getops()) == NULL) {
1402 			warn("failed to load KVM backend ops\n");
1403 			goto err;
1404 		}
1405 
1406 		kt->k_cookie = kt->k_kb_ops->kb_open(NULL, kt->k_kvmfile, NULL,
1407 		    oflag, (char *)mdb.m_pname);
1408 
1409 		if (kt->k_cookie == NULL)
1410 			goto err;
1411 
1412 		kt->k_xpv_domu = 1;
1413 #endif
1414 	}
1415 
1416 	if ((kt->k_fio = kt->k_kb_ops->kb_sym_io(kt->k_cookie,
1417 	    kt->k_symfile)) == NULL)
1418 		goto err;
1419 
1420 	if ((kt->k_file = mdb_gelf_create(kt->k_fio,
1421 	    ET_EXEC, GF_FILE)) == NULL) {
1422 		mdb_io_destroy(kt->k_fio);
1423 		goto err;
1424 	}
1425 
1426 	kt->k_symtab =
1427 	    mdb_gelf_symtab_create_file(kt->k_file, SHT_SYMTAB, MDB_TGT_SYMTAB);
1428 
1429 	kt->k_dynsym =
1430 	    mdb_gelf_symtab_create_file(kt->k_file, SHT_DYNSYM, MDB_TGT_DYNSYM);
1431 
1432 	if (mdb_gelf_symtab_lookup_by_name(kt->k_symtab, "kas",
1433 	    &sym, NULL) == -1) {
1434 		warn("'kas' symbol is missing from kernel\n");
1435 		goto err;
1436 	}
1437 
1438 	kt->k_as = (struct as *)(uintptr_t)sym.st_value;
1439 
1440 	if (mdb_gelf_symtab_lookup_by_name(kt->k_symtab, "platform",
1441 	    &sym, NULL) == -1) {
1442 		warn("'platform' symbol is missing from kernel\n");
1443 		goto err;
1444 	}
1445 
1446 	if (kt->k_kb_ops->kb_kread(kt->k_cookie, sym.st_value,
1447 	    kt->k_platform, MAXNAMELEN) <= 0) {
1448 		warn("failed to read 'platform' string from kernel");
1449 		goto err;
1450 	}
1451 
1452 	if (mdb_gelf_symtab_lookup_by_name(kt->k_symtab, "utsname",
1453 	    &sym, NULL) == -1) {
1454 		warn("'utsname' symbol is missing from kernel\n");
1455 		goto err;
1456 	}
1457 
1458 	if (kt->k_kb_ops->kb_kread(kt->k_cookie, sym.st_value, &uts,
1459 	    sizeof (uts)) <= 0) {
1460 		warn("failed to read 'utsname' struct from kernel");
1461 		goto err;
1462 	}
1463 
1464 	kt->k_dump_print_content = (void (*)())kt_data_stub;
1465 	kt->k_dump_find_curproc = kt_data_stub;
1466 
1467 	/*
1468 	 * We set k_ctfvalid based on the presence of the CTF vmem arena
1469 	 * symbol.  The CTF members were added to the end of struct module at
1470 	 * the same time, so this allows us to know whether we can use them.
1471 	 */
1472 	if (mdb_gelf_symtab_lookup_by_name(kt->k_symtab, "ctf_arena", &sym,
1473 	    NULL) == 0 && !(mdb.m_flags & MDB_FL_NOCTF))
1474 		kt->k_ctfvalid = 1;
1475 
1476 	(void) mdb_nv_create(&kt->k_modules, UM_SLEEP);
1477 	t->t_pshandle = kt->k_cookie;
1478 	t->t_data = kt;
1479 
1480 #if defined(__sparc)
1481 #if defined(__sparcv9)
1482 	kt_sparcv9_init(t);
1483 #else
1484 	kt_sparcv7_init(t);
1485 #endif
1486 #elif defined(__amd64)
1487 	kt_amd64_init(t);
1488 #elif defined(__i386)
1489 	kt_ia32_init(t);
1490 #else
1491 #error	"unknown ISA"
1492 #endif
1493 
1494 	/*
1495 	 * We read our representative thread ID (address) from the kernel's
1496 	 * global panic_thread.  It will remain 0 if this is a live kernel.
1497 	 */
1498 	(void) mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, &kt->k_tid, sizeof (void *),
1499 	    MDB_TGT_OBJ_EXEC, "panic_thread");
1500 
1501 	if ((mdb.m_flags & MDB_FL_ADB) && mdb_tgt_readsym(t, MDB_TGT_AS_VIRT,
1502 	    &pmem, sizeof (pmem), MDB_TGT_OBJ_EXEC, "physmem") == sizeof (pmem))
1503 		mdb_printf("physmem %lx\n", (ulong_t)pmem);
1504 
1505 	/*
1506 	 * If this is not a live kernel or a hypervisor dump, read the dump
1507 	 * header.  We don't have to sanity-check the header, as the open would
1508 	 * not have succeeded otherwise.
1509 	 */
1510 	if (!kt->k_xpv_domu && strcmp(kt->k_symfile, "/dev/ksyms") != 0) {
1511 		mdb_io_t *vmcore;
1512 
1513 		kt->k_dumphdr = mdb_alloc(sizeof (dumphdr_t), UM_SLEEP);
1514 
1515 		if ((vmcore = mdb_fdio_create_path(NULL, kt->k_kvmfile,
1516 		    O_RDONLY, 0)) == NULL) {
1517 			mdb_warn("failed to open %s", kt->k_kvmfile);
1518 			goto err;
1519 		}
1520 
1521 		if (IOP_READ(vmcore, kt->k_dumphdr, sizeof (dumphdr_t)) !=
1522 		    sizeof (dumphdr_t)) {
1523 			mdb_warn("failed to read dump header");
1524 			mdb_io_destroy(vmcore);
1525 			goto err;
1526 		}
1527 
1528 		mdb_io_destroy(vmcore);
1529 
1530 		(void) mdb_tgt_xdata_insert(t, "dumphdr",
1531 		    "dump header structure", kt_xd_dumphdr);
1532 	}
1533 
1534 	return (0);
1535 
1536 err:
1537 	if (kt->k_dumphdr != NULL)
1538 		mdb_free(kt->k_dumphdr, sizeof (dumphdr_t));
1539 
1540 	if (kt->k_symtab != NULL)
1541 		mdb_gelf_symtab_destroy(kt->k_symtab);
1542 
1543 	if (kt->k_dynsym != NULL)
1544 		mdb_gelf_symtab_destroy(kt->k_dynsym);
1545 
1546 	if (kt->k_file != NULL)
1547 		mdb_gelf_destroy(kt->k_file);
1548 
1549 	if (kt->k_cookie != NULL)
1550 		(void) kt->k_kb_ops->kb_close(kt->k_cookie);
1551 
1552 	mdb_free(kt, sizeof (kt_data_t));
1553 	return (-1);
1554 }
1555