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