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