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 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * This part of the file contains the mdb support for dcmds:
28 * ::memseg_list
29 * and walkers for:
30 * memseg - a memseg list walker for ::memseg_list
31 *
32 */
33
34 #include <sys/types.h>
35 #include <sys/machparam.h>
36 #include <sys/controlregs.h>
37 #include <sys/mach_mmu.h>
38 #ifdef __xpv
39 #include <sys/hypervisor.h>
40 #endif
41 #include <vm/as.h>
42
43 #include <mdb/mdb_modapi.h>
44 #include <mdb/mdb_target.h>
45
46 #include <vm/page.h>
47 #include <vm/hat_i86.h>
48
49 struct pfn2pp {
50 pfn_t pfn;
51 page_t *pp;
52 };
53
54 static int do_va2pa(uintptr_t, struct as *, int, physaddr_t *, pfn_t *);
55 static void init_mmu(void);
56
57 int
58 platform_vtop(uintptr_t addr, struct as *asp, physaddr_t *pap)
59 {
60 if (asp == NULL)
61 return (DCMD_ERR);
62
63 init_mmu();
64
65 if (mmu.num_level == 0)
66 return (DCMD_ERR);
67
68 return (do_va2pa(addr, asp, 0, pap, NULL));
69 }
70
71 /*
72 * ::memseg_list dcmd and walker to implement it.
73 */
74 /*ARGSUSED*/
75 int
76 memseg_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
77 {
78 struct memseg ms;
79
80 if (!(flags & DCMD_ADDRSPEC)) {
81 if (mdb_pwalk_dcmd("memseg", "memseg_list",
82 0, NULL, 0) == -1) {
83 mdb_warn("can't walk memseg");
84 return (DCMD_ERR);
85 }
86 return (DCMD_OK);
87 }
88
89 if (DCMD_HDRSPEC(flags))
90 mdb_printf("%<u>%?s %?s %?s %?s %?s%</u>\n", "ADDR",
91 "PAGES", "EPAGES", "BASE", "END");
92
93 if (mdb_vread(&ms, sizeof (struct memseg), addr) == -1) {
94 mdb_warn("can't read memseg at %#lx", addr);
95 return (DCMD_ERR);
96 }
97
98 mdb_printf("%0?lx %0?lx %0?lx %0?lx %0?lx\n", addr,
99 ms.pages, ms.epages, ms.pages_base, ms.pages_end);
100
101 return (DCMD_OK);
102 }
103
104 /*
105 * walk the memseg structures
106 */
107 int
108 memseg_walk_init(mdb_walk_state_t *wsp)
109 {
110 if (wsp->walk_addr != NULL) {
111 mdb_warn("memseg only supports global walks\n");
112 return (WALK_ERR);
113 }
114
115 if (mdb_readvar(&wsp->walk_addr, "memsegs") == -1) {
116 mdb_warn("symbol 'memsegs' not found");
117 return (WALK_ERR);
118 }
119
120 wsp->walk_data = mdb_alloc(sizeof (struct memseg), UM_SLEEP);
121 return (WALK_NEXT);
122
123 }
124
125 int
126 memseg_walk_step(mdb_walk_state_t *wsp)
127 {
128 int status;
129
130 if (wsp->walk_addr == 0) {
131 return (WALK_DONE);
132 }
133
134 if (mdb_vread(wsp->walk_data, sizeof (struct memseg),
135 wsp->walk_addr) == -1) {
136 mdb_warn("failed to read struct memseg at %p", wsp->walk_addr);
137 return (WALK_DONE);
138 }
139
140 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
141 wsp->walk_cbdata);
142
143 wsp->walk_addr = (uintptr_t)(((struct memseg *)wsp->walk_data)->next);
144
145 return (status);
146 }
147
148 void
149 memseg_walk_fini(mdb_walk_state_t *wsp)
150 {
151 mdb_free(wsp->walk_data, sizeof (struct memseg));
152 }
153
154 /*
155 * Now HAT related dcmds.
156 */
157
158 static struct hat *khat; /* value of kas.a_hat */
159 struct hat_mmu_info mmu;
160 uintptr_t kernelbase;
161
162 /*
163 * stuff for i86xpv images
164 */
165 static int is_xpv;
166 static uintptr_t mfn_list_addr; /* kernel MFN list address */
167 uintptr_t xen_virt_start; /* address of mfn_to_pfn[] table */
168 ulong_t mfn_count; /* number of pfn's in the MFN list */
169 pfn_t *mfn_list; /* local MFN list copy */
170
171 /*
172 * read mmu parameters from kernel
173 */
174 static void
175 init_mmu(void)
176 {
177 struct as kas;
178
179 if (mmu.num_level != 0)
180 return;
181
182 if (mdb_readsym(&mmu, sizeof (mmu), "mmu") == -1)
183 mdb_warn("Can't use HAT information before mmu_init()\n");
184 if (mdb_readsym(&kas, sizeof (kas), "kas") == -1)
185 mdb_warn("Couldn't find kas - kernel's struct as\n");
186 if (mdb_readsym(&kernelbase, sizeof (kernelbase), "kernelbase") == -1)
187 mdb_warn("Couldn't find kernelbase\n");
188 khat = kas.a_hat;
189
190 /*
191 * Is this a paravirtualized domain image?
192 */
193 if (mdb_readsym(&mfn_list_addr, sizeof (mfn_list_addr),
194 "mfn_list") == -1 ||
195 mdb_readsym(&xen_virt_start, sizeof (xen_virt_start),
196 "xen_virt_start") == -1 ||
197 mdb_readsym(&mfn_count, sizeof (mfn_count), "mfn_count") == -1) {
198 mfn_list_addr = NULL;
199 }
200
201 is_xpv = mfn_list_addr != NULL;
202
203 #ifndef _KMDB
204 /*
205 * recreate the local mfn_list
206 */
207 if (is_xpv) {
208 size_t sz = mfn_count * sizeof (pfn_t);
209 mfn_list = mdb_zalloc(sz, UM_SLEEP);
210
211 if (mdb_vread(mfn_list, sz, (uintptr_t)mfn_list_addr) == -1) {
212 mdb_warn("Failed to read MFN list\n");
213 mdb_free(mfn_list, sz);
214 mfn_list = NULL;
215 }
216 }
217 #endif
218 }
219
220 void
221 free_mmu(void)
222 {
223 #ifdef __xpv
224 if (mfn_list != NULL)
225 mdb_free(mfn_list, mfn_count * sizeof (mfn_t));
226 #endif
227 }
228
229 #ifdef __xpv
230
231 #ifdef _KMDB
232
233 /*
234 * Convert between MFNs and PFNs. Since we're in kmdb we can go directly
235 * through the machine to phys mapping and the MFN list.
236 */
237
238 pfn_t
239 mdb_mfn_to_pfn(mfn_t mfn)
240 {
241 pfn_t pfn;
242 mfn_t tmp;
243 pfn_t *pfn_list;
244
245 if (mfn_list_addr == NULL)
246 return (-(pfn_t)1);
247
248 pfn_list = (pfn_t *)xen_virt_start;
249 if (mdb_vread(&pfn, sizeof (pfn), (uintptr_t)(pfn_list + mfn)) == -1)
250 return (-(pfn_t)1);
251
252 if (mdb_vread(&tmp, sizeof (tmp),
253 (uintptr_t)(mfn_list_addr + (pfn * sizeof (mfn_t)))) == -1)
254 return (-(pfn_t)1);
255
256 if (pfn >= mfn_count || tmp != mfn)
257 return (-(pfn_t)1);
258
259 return (pfn);
260 }
261
262 mfn_t
263 mdb_pfn_to_mfn(pfn_t pfn)
264 {
265 mfn_t mfn;
266
267 init_mmu();
268
269 if (mfn_list_addr == NULL || pfn >= mfn_count)
270 return (-(mfn_t)1);
271
272 if (mdb_vread(&mfn, sizeof (mfn),
273 (uintptr_t)(mfn_list_addr + (pfn * sizeof (mfn_t)))) == -1)
274 return (-(mfn_t)1);
275
276 return (mfn);
277 }
278
279 #else /* _KMDB */
280
281 /*
282 * Convert between MFNs and PFNs. Since a crash dump doesn't include the
283 * MFN->PFN translation table (it's part of the hypervisor, not our image)
284 * we do the MFN->PFN translation by searching the PFN->MFN (mfn_list)
285 * table, if it's there.
286 */
287
288 pfn_t
289 mdb_mfn_to_pfn(mfn_t mfn)
290 {
291 pfn_t pfn;
292
293 init_mmu();
294
295 if (mfn_list == NULL)
296 return (-(pfn_t)1);
297
298 for (pfn = 0; pfn < mfn_count; ++pfn) {
299 if (mfn_list[pfn] != mfn)
300 continue;
301 return (pfn);
302 }
303
304 return (-(pfn_t)1);
305 }
306
307 mfn_t
308 mdb_pfn_to_mfn(pfn_t pfn)
309 {
310 init_mmu();
311
312 if (mfn_list == NULL || pfn >= mfn_count)
313 return (-(mfn_t)1);
314
315 return (mfn_list[pfn]);
316 }
317
318 #endif /* _KMDB */
319
320 static paddr_t
321 mdb_ma_to_pa(uint64_t ma)
322 {
323 pfn_t pfn = mdb_mfn_to_pfn(mmu_btop(ma));
324 if (pfn == -(pfn_t)1)
325 return (-(paddr_t)1);
326
327 return (mmu_ptob((paddr_t)pfn) | (ma & (MMU_PAGESIZE - 1)));
328 }
329
330 #else /* __xpv */
331
332 #define mdb_ma_to_pa(ma) (ma)
333 #define mdb_mfn_to_pfn(mfn) (mfn)
334 #define mdb_pfn_to_mfn(pfn) (pfn)
335
336 #endif /* __xpv */
337
338 /*
339 * ::mfntopfn dcmd translates hypervisor machine page number
340 * to physical page number
341 */
342 /*ARGSUSED*/
343 int
344 mfntopfn_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
345 {
346 pfn_t pfn;
347
348 if ((flags & DCMD_ADDRSPEC) == 0) {
349 mdb_warn("MFN missing\n");
350 return (DCMD_USAGE);
351 }
352
353 if ((pfn = mdb_mfn_to_pfn((pfn_t)addr)) == -(pfn_t)1) {
354 mdb_warn("Invalid mfn %lr\n", (pfn_t)addr);
355 return (DCMD_ERR);
356 }
357
358 mdb_printf("%lr\n", pfn);
359
360 return (DCMD_OK);
361 }
362
363 /*
364 * ::pfntomfn dcmd translates physical page number to
365 * hypervisor machine page number
366 */
367 /*ARGSUSED*/
368 int
369 pfntomfn_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
370 {
371 pfn_t mfn;
372
373 if ((flags & DCMD_ADDRSPEC) == 0) {
374 mdb_warn("PFN missing\n");
375 return (DCMD_USAGE);
376 }
377
378 if ((mfn = mdb_pfn_to_mfn((pfn_t)addr)) == -(pfn_t)1) {
379 mdb_warn("Invalid pfn %lr\n", (pfn_t)addr);
380 return (DCMD_ABORT);
381 }
382
383 mdb_printf("%lr\n", mfn);
384
385 if (flags & DCMD_LOOP)
386 mdb_set_dot(addr + 1);
387 return (DCMD_OK);
388 }
389
390 static pfn_t
391 pte2mfn(x86pte_t pte, uint_t level)
392 {
393 pfn_t mfn;
394 if (level > 0 && (pte & PT_PAGESIZE))
395 mfn = mmu_btop(pte & PT_PADDR_LGPG);
396 else
397 mfn = mmu_btop(pte & PT_PADDR);
398 return (mfn);
399 }
400
401 /*
402 * Print a PTE in more human friendly way. The PTE is assumed to be in
403 * a level 0 page table, unless -l specifies another level.
404 *
405 * The PTE value can be specified as the -p option, since on a 32 bit kernel
406 * with PAE running it's larger than a uintptr_t.
407 */
408 static int
409 do_pte_dcmd(int level, uint64_t pte)
410 {
411 static char *attr[] = {
412 "wrback", "wrthru", "uncached", "uncached",
413 "wrback", "wrthru", "wrcombine", "uncached"};
414 int pat_index = 0;
415 pfn_t mfn;
416
417 mdb_printf("pte=%llr: ", pte);
418 if (PTE_GET(pte, mmu.pt_nx))
419 mdb_printf("noexec ");
420
421 mfn = pte2mfn(pte, level);
422 mdb_printf("%s=0x%lr ", is_xpv ? "mfn" : "pfn", mfn);
423
424 if (PTE_GET(pte, PT_NOCONSIST))
425 mdb_printf("noconsist ");
426
427 if (PTE_GET(pte, PT_NOSYNC))
428 mdb_printf("nosync ");
429
430 if (PTE_GET(pte, mmu.pt_global))
431 mdb_printf("global ");
432
433 if (level > 0 && PTE_GET(pte, PT_PAGESIZE))
434 mdb_printf("largepage ");
435
436 if (level > 0 && PTE_GET(pte, PT_MOD))
437 mdb_printf("mod ");
438
439 if (level > 0 && PTE_GET(pte, PT_REF))
440 mdb_printf("ref ");
441
442 if (PTE_GET(pte, PT_USER))
443 mdb_printf("user ");
444
445 if (PTE_GET(pte, PT_WRITABLE))
446 mdb_printf("write ");
447
448 /*
449 * Report non-standard cacheability
450 */
451 pat_index = 0;
452 if (level > 0) {
453 if (PTE_GET(pte, PT_PAGESIZE) && PTE_GET(pte, PT_PAT_LARGE))
454 pat_index += 4;
455 } else {
456 if (PTE_GET(pte, PT_PAT_4K))
457 pat_index += 4;
458 }
459
460 if (PTE_GET(pte, PT_NOCACHE))
461 pat_index += 2;
462
463 if (PTE_GET(pte, PT_WRITETHRU))
464 pat_index += 1;
465
466 if (pat_index != 0)
467 mdb_printf("%s", attr[pat_index]);
468
469 if (PTE_GET(pte, PT_VALID) == 0)
470 mdb_printf(" !VALID ");
471
472 mdb_printf("\n");
473 return (DCMD_OK);
474 }
475
476 /*
477 * Print a PTE in more human friendly way. The PTE is assumed to be in
478 * a level 0 page table, unless -l specifies another level.
479 *
480 * The PTE value can be specified as the -p option, since on a 32 bit kernel
481 * with PAE running it's larger than a uintptr_t.
482 */
483 /*ARGSUSED*/
484 int
485 pte_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
486 {
487 int level = 0;
488 uint64_t pte = 0;
489 char *level_str = NULL;
490 char *pte_str = NULL;
491
492 init_mmu();
493
494 if (mmu.num_level == 0)
495 return (DCMD_ERR);
496
497 if (mdb_getopts(argc, argv,
498 'p', MDB_OPT_STR, &pte_str,
499 'l', MDB_OPT_STR, &level_str) != argc)
500 return (DCMD_USAGE);
501
502 /*
503 * parse the PTE to decode, if it's 0, we don't do anything
504 */
505 if (pte_str != NULL) {
506 pte = mdb_strtoull(pte_str);
507 } else {
508 if ((flags & DCMD_ADDRSPEC) == 0)
509 return (DCMD_USAGE);
510 pte = addr;
511 }
512 if (pte == 0)
513 return (DCMD_OK);
514
515 /*
516 * parse the level if supplied
517 */
518 if (level_str != NULL) {
519 level = mdb_strtoull(level_str);
520 if (level < 0 || level > mmu.max_level)
521 return (DCMD_ERR);
522 }
523
524 return (do_pte_dcmd(level, pte));
525 }
526
527 static size_t
528 va2entry(htable_t *htable, uintptr_t addr)
529 {
530 size_t entry = (addr - htable->ht_vaddr);
531
532 entry >>= mmu.level_shift[htable->ht_level];
533 return (entry & HTABLE_NUM_PTES(htable) - 1);
534 }
535
536 static x86pte_t
537 get_pte(hat_t *hat, htable_t *htable, uintptr_t addr)
538 {
539 x86pte_t buf;
540 x86pte32_t *pte32 = (x86pte32_t *)&buf;
541 size_t len;
542
543 if (htable->ht_flags & HTABLE_VLP) {
544 uintptr_t ptr = (uintptr_t)hat->hat_vlp_ptes;
545 ptr += va2entry(htable, addr) << mmu.pte_size_shift;
546 len = mdb_vread(&buf, mmu.pte_size, ptr);
547 } else {
548 paddr_t paddr = mmu_ptob((paddr_t)htable->ht_pfn);
549 paddr += va2entry(htable, addr) << mmu.pte_size_shift;
550 len = mdb_pread(&buf, mmu.pte_size, paddr);
551 }
552
553 if (len != mmu.pte_size)
554 return (0);
555
556 if (mmu.pte_size == sizeof (x86pte_t))
557 return (buf);
558 return (*pte32);
559 }
560
561 static int
562 do_va2pa(uintptr_t addr, struct as *asp, int print_level, physaddr_t *pap,
563 pfn_t *mfnp)
564 {
565 struct as as;
566 struct hat *hatp;
567 struct hat hat;
568 htable_t *ht;
569 htable_t htable;
570 uintptr_t base;
571 int h;
572 int level;
573 int found = 0;
574 x86pte_t pte;
575 physaddr_t paddr;
576
577 if (asp != NULL) {
578 if (mdb_vread(&as, sizeof (as), (uintptr_t)asp) == -1) {
579 mdb_warn("Couldn't read struct as\n");
580 return (DCMD_ERR);
581 }
582 hatp = as.a_hat;
583 } else {
584 hatp = khat;
585 }
586
587 /*
588 * read the hat and its hash table
589 */
590 if (mdb_vread(&hat, sizeof (hat), (uintptr_t)hatp) == -1) {
591 mdb_warn("Couldn't read struct hat\n");
592 return (DCMD_ERR);
593 }
594
595 /*
596 * read the htable hashtable
597 */
598 for (level = 0; level <= mmu.max_level; ++level) {
599 if (level == TOP_LEVEL(&hat))
600 base = 0;
601 else
602 base = addr & mmu.level_mask[level + 1];
603
604 for (h = 0; h < hat.hat_num_hash; ++h) {
605 if (mdb_vread(&ht, sizeof (htable_t *),
606 (uintptr_t)(hat.hat_ht_hash + h)) == -1) {
607 mdb_warn("Couldn't read htable\n");
608 return (DCMD_ERR);
609 }
610 for (; ht != NULL; ht = htable.ht_next) {
611 if (mdb_vread(&htable, sizeof (htable_t),
612 (uintptr_t)ht) == -1) {
613 mdb_warn("Couldn't read htable\n");
614 return (DCMD_ERR);
615 }
616
617 if (htable.ht_vaddr != base ||
618 htable.ht_level != level)
619 continue;
620
621 pte = get_pte(&hat, &htable, addr);
622
623 if (print_level) {
624 mdb_printf("\tlevel=%d htable=%p "
625 "pte=%llr\n", level, ht, pte);
626 }
627
628 if (!PTE_ISVALID(pte)) {
629 mdb_printf("Address %p is unmapped.\n",
630 addr);
631 return (DCMD_ERR);
632 }
633
634 if (found)
635 continue;
636
637 if (PTE_IS_LGPG(pte, level))
638 paddr = mdb_ma_to_pa(pte &
639 PT_PADDR_LGPG);
640 else
641 paddr = mdb_ma_to_pa(pte & PT_PADDR);
642 paddr += addr & mmu.level_offset[level];
643 if (pap != NULL)
644 *pap = paddr;
645 if (mfnp != NULL)
646 *mfnp = pte2mfn(pte, level);
647 found = 1;
648 }
649 }
650 }
651
652 done:
653 if (!found)
654 return (DCMD_ERR);
655 return (DCMD_OK);
656 }
657
658 int
659 va2pfn_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
660 {
661 uintptr_t addrspace;
662 char *addrspace_str = NULL;
663 int piped = flags & DCMD_PIPE_OUT;
664 pfn_t pfn;
665 pfn_t mfn;
666 int rc;
667
668 init_mmu();
669
670 if (mmu.num_level == 0)
671 return (DCMD_ERR);
672
673 if (mdb_getopts(argc, argv,
674 'a', MDB_OPT_STR, &addrspace_str) != argc)
675 return (DCMD_USAGE);
676
677 if ((flags & DCMD_ADDRSPEC) == 0)
678 return (DCMD_USAGE);
679
680 /*
681 * parse the address space
682 */
683 if (addrspace_str != NULL)
684 addrspace = mdb_strtoull(addrspace_str);
685 else
686 addrspace = 0;
687
688 rc = do_va2pa(addr, (struct as *)addrspace, !piped, NULL, &mfn);
689
690 if (rc != DCMD_OK)
691 return (rc);
692
693 if ((pfn = mdb_mfn_to_pfn(mfn)) == -(pfn_t)1) {
694 mdb_warn("Invalid mfn %lr\n", mfn);
695 return (DCMD_ERR);
696 }
697
698 if (piped) {
699 mdb_printf("0x%lr\n", pfn);
700 return (DCMD_OK);
701 }
702
703 mdb_printf("Virtual address 0x%p maps pfn 0x%lr", addr, pfn);
704
705 if (is_xpv)
706 mdb_printf(" (mfn 0x%lr)", mfn);
707
708 mdb_printf("\n");
709
710 return (DCMD_OK);
711 }
712
713 /*
714 * Report all hat's that either use PFN as a page table or that map the page.
715 */
716 static int
717 do_report_maps(pfn_t pfn)
718 {
719 struct hat *hatp;
720 struct hat hat;
721 htable_t *ht;
722 htable_t htable;
723 uintptr_t base;
724 int h;
725 int level;
726 int entry;
727 x86pte_t pte;
728 x86pte_t buf;
729 x86pte32_t *pte32 = (x86pte32_t *)&buf;
730 physaddr_t paddr;
731 size_t len;
732
733 /*
734 * The hats are kept in a list with khat at the head.
735 */
736 for (hatp = khat; hatp != NULL; hatp = hat.hat_next) {
737 /*
738 * read the hat and its hash table
739 */
740 if (mdb_vread(&hat, sizeof (hat), (uintptr_t)hatp) == -1) {
741 mdb_warn("Couldn't read struct hat\n");
742 return (DCMD_ERR);
743 }
744
745 /*
746 * read the htable hashtable
747 */
748 paddr = 0;
749 for (h = 0; h < hat.hat_num_hash; ++h) {
750 if (mdb_vread(&ht, sizeof (htable_t *),
751 (uintptr_t)(hat.hat_ht_hash + h)) == -1) {
752 mdb_warn("Couldn't read htable\n");
753 return (DCMD_ERR);
754 }
755 for (; ht != NULL; ht = htable.ht_next) {
756 if (mdb_vread(&htable, sizeof (htable_t),
757 (uintptr_t)ht) == -1) {
758 mdb_warn("Couldn't read htable\n");
759 return (DCMD_ERR);
760 }
761
762 /*
763 * only report kernel addresses once
764 */
765 if (hatp != khat &&
766 htable.ht_vaddr >= kernelbase)
767 continue;
768
769 /*
770 * Is the PFN a pagetable itself?
771 */
772 if (htable.ht_pfn == pfn) {
773 mdb_printf("Pagetable for "
774 "hat=%p htable=%p\n", hatp, ht);
775 continue;
776 }
777
778 /*
779 * otherwise, examine page mappings
780 */
781 level = htable.ht_level;
782 if (level > mmu.max_page_level)
783 continue;
784 paddr = mmu_ptob((physaddr_t)htable.ht_pfn);
785 for (entry = 0;
786 entry < HTABLE_NUM_PTES(&htable);
787 ++entry) {
788
789 base = htable.ht_vaddr + entry *
790 mmu.level_size[level];
791
792 /*
793 * only report kernel addresses once
794 */
795 if (hatp != khat &&
796 base >= kernelbase)
797 continue;
798
799 len = mdb_pread(&buf, mmu.pte_size,
800 paddr + entry * mmu.pte_size);
801 if (len != mmu.pte_size)
802 return (DCMD_ERR);
803 if (mmu.pte_size == sizeof (x86pte_t))
804 pte = buf;
805 else
806 pte = *pte32;
807
808 if ((pte & PT_VALID) == 0)
809 continue;
810 if (level == 0 || !(pte & PT_PAGESIZE))
811 pte &= PT_PADDR;
812 else
813 pte &= PT_PADDR_LGPG;
814 if (mmu_btop(mdb_ma_to_pa(pte)) != pfn)
815 continue;
816 mdb_printf("hat=%p maps addr=%p\n",
817 hatp, (caddr_t)base);
818 }
819 }
820 }
821 }
822
823 done:
824 return (DCMD_OK);
825 }
826
827 /*
828 * given a PFN as its address argument, prints out the uses of it
829 */
830 /*ARGSUSED*/
831 int
832 report_maps_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
833 {
834 pfn_t pfn;
835 uint_t mflag = 0;
836
837 init_mmu();
838
839 if (mmu.num_level == 0)
840 return (DCMD_ERR);
841
842 if ((flags & DCMD_ADDRSPEC) == 0)
843 return (DCMD_USAGE);
844
845 if (mdb_getopts(argc, argv,
846 'm', MDB_OPT_SETBITS, TRUE, &mflag, NULL) != argc)
847 return (DCMD_USAGE);
848
849 pfn = (pfn_t)addr;
850 if (mflag)
851 pfn = mdb_mfn_to_pfn(pfn);
852
853 return (do_report_maps(pfn));
854 }
855
856 static int
857 do_ptable_dcmd(pfn_t pfn)
858 {
859 struct hat *hatp;
860 struct hat hat;
861 htable_t *ht;
862 htable_t htable;
863 uintptr_t base;
864 int h;
865 int level;
866 int entry;
867 uintptr_t pagesize;
868 x86pte_t pte;
869 x86pte_t buf;
870 x86pte32_t *pte32 = (x86pte32_t *)&buf;
871 physaddr_t paddr;
872 size_t len;
873
874 /*
875 * The hats are kept in a list with khat at the head.
876 */
877 for (hatp = khat; hatp != NULL; hatp = hat.hat_next) {
878 /*
879 * read the hat and its hash table
880 */
881 if (mdb_vread(&hat, sizeof (hat), (uintptr_t)hatp) == -1) {
882 mdb_warn("Couldn't read struct hat\n");
883 return (DCMD_ERR);
884 }
885
886 /*
887 * read the htable hashtable
888 */
889 paddr = 0;
890 for (h = 0; h < hat.hat_num_hash; ++h) {
891 if (mdb_vread(&ht, sizeof (htable_t *),
892 (uintptr_t)(hat.hat_ht_hash + h)) == -1) {
893 mdb_warn("Couldn't read htable\n");
894 return (DCMD_ERR);
895 }
896 for (; ht != NULL; ht = htable.ht_next) {
897 if (mdb_vread(&htable, sizeof (htable_t),
898 (uintptr_t)ht) == -1) {
899 mdb_warn("Couldn't read htable\n");
900 return (DCMD_ERR);
901 }
902
903 /*
904 * Is this the PFN for this htable
905 */
906 if (htable.ht_pfn == pfn)
907 goto found_it;
908 }
909 }
910 }
911
912 found_it:
913 if (htable.ht_pfn == pfn) {
914 mdb_printf("htable=%p\n", ht);
915 level = htable.ht_level;
916 base = htable.ht_vaddr;
917 pagesize = mmu.level_size[level];
918 } else {
919 mdb_printf("Unknown pagetable - assuming level/addr 0");
920 level = 0; /* assume level == 0 for PFN */
921 base = 0;
922 pagesize = MMU_PAGESIZE;
923 }
924
925 paddr = mmu_ptob((physaddr_t)pfn);
926 for (entry = 0; entry < mmu.ptes_per_table; ++entry) {
927 len = mdb_pread(&buf, mmu.pte_size,
928 paddr + entry * mmu.pte_size);
929 if (len != mmu.pte_size)
930 return (DCMD_ERR);
931 if (mmu.pte_size == sizeof (x86pte_t))
932 pte = buf;
933 else
934 pte = *pte32;
935
936 if (pte == 0)
937 continue;
938
939 mdb_printf("[%3d] va=%p ", entry, base + entry * pagesize);
940 do_pte_dcmd(level, pte);
941 }
942
943 done:
944 return (DCMD_OK);
945 }
946
947 /*
948 * Dump the page table at the given PFN
949 */
950 /*ARGSUSED*/
951 int
952 ptable_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
953 {
954 pfn_t pfn;
955 uint_t mflag = 0;
956
957 init_mmu();
958
959 if (mmu.num_level == 0)
960 return (DCMD_ERR);
961
962 if ((flags & DCMD_ADDRSPEC) == 0)
963 return (DCMD_USAGE);
964
965 if (mdb_getopts(argc, argv,
966 'm', MDB_OPT_SETBITS, TRUE, &mflag, NULL) != argc)
967 return (DCMD_USAGE);
968
969 pfn = (pfn_t)addr;
970 if (mflag)
971 pfn = mdb_mfn_to_pfn(pfn);
972
973 return (do_ptable_dcmd(pfn));
974 }
975
976 static int
977 do_htables_dcmd(hat_t *hatp)
978 {
979 struct hat hat;
980 htable_t *ht;
981 htable_t htable;
982 int h;
983
984 /*
985 * read the hat and its hash table
986 */
987 if (mdb_vread(&hat, sizeof (hat), (uintptr_t)hatp) == -1) {
988 mdb_warn("Couldn't read struct hat\n");
989 return (DCMD_ERR);
990 }
991
992 /*
993 * read the htable hashtable
994 */
995 for (h = 0; h < hat.hat_num_hash; ++h) {
996 if (mdb_vread(&ht, sizeof (htable_t *),
997 (uintptr_t)(hat.hat_ht_hash + h)) == -1) {
998 mdb_warn("Couldn't read htable ptr\\n");
999 return (DCMD_ERR);
1000 }
1001 for (; ht != NULL; ht = htable.ht_next) {
1002 mdb_printf("%p\n", ht);
1003 if (mdb_vread(&htable, sizeof (htable_t),
1004 (uintptr_t)ht) == -1) {
1005 mdb_warn("Couldn't read htable\n");
1006 return (DCMD_ERR);
1007 }
1008 }
1009 }
1010 return (DCMD_OK);
1011 }
1012
1013 /*
1014 * Dump the htables for the given hat
1015 */
1016 /*ARGSUSED*/
1017 int
1018 htables_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1019 {
1020 hat_t *hat;
1021
1022 init_mmu();
1023
1024 if (mmu.num_level == 0)
1025 return (DCMD_ERR);
1026
1027 if ((flags & DCMD_ADDRSPEC) == 0)
1028 return (DCMD_USAGE);
1029
1030 hat = (hat_t *)addr;
1031
1032 return (do_htables_dcmd(hat));
1033 }