![[BACK]](/icons/back.gif){kind=icon}
Return to pmap.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa64 / hppa64|
Return to pmap.c CVS log | Up to [local] / sys / arch / hppa64 / hppa64 |
1.1 nbrk 1: /* $OpenBSD: pmap.c,v 1.5 2007/04/13 18:57:49 art Exp $ */
2:
3: /*
4: * Copyright (c) 2005 Michael Shalayeff
5: * All rights reserved.
6: *
7: * Permission to use, copy, modify, and distribute this software for any
8: * purpose with or without fee is hereby granted, provided that the above
9: * copyright notice and this permission notice appear in all copies.
10: *
11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN
16: * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
17: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18: */
19:
20: #define PMAPDEBUG
21:
22: #include <sys/param.h>
23: #include <sys/systm.h>
24: #include <sys/lock.h>
25: #include <sys/user.h>
26: #include <sys/proc.h>
27: #include <sys/pool.h>
28: #include <sys/extent.h>
29:
30: #include <uvm/uvm.h>
31:
32: #include <machine/iomod.h>
33:
34: #include <dev/rndvar.h>
35:
36: #ifdef PMAPDEBUG
37: #define DPRINTF(l,s) do { \
38: if ((pmapdebug & (l)) == (l)) \
39: printf s; \
40: } while(0)
41: #define PDB_FOLLOW 0x00000001
42: #define PDB_INIT 0x00000002
43: #define PDB_ENTER 0x00000004
44: #define PDB_REMOVE 0x00000008
45: #define PDB_CREATE 0x00000010
46: #define PDB_PTPAGE 0x00000020
47: #define PDB_CACHE 0x00000040
48: #define PDB_BITS 0x00000080
49: #define PDB_COLLECT 0x00000100
50: #define PDB_PROTECT 0x00000200
51: #define PDB_EXTRACT 0x00000400
52: #define PDB_VP 0x00000800
53: #define PDB_PV 0x00001000
54: #define PDB_PARANOIA 0x00002000
55: #define PDB_WIRING 0x00004000
56: #define PDB_PMAP 0x00008000
57: #define PDB_STEAL 0x00010000
58: #define PDB_PHYS 0x00020000
59: #define PDB_POOL 0x00040000
60: int pmapdebug = 0
61: | PDB_INIT
62: /* | PDB_FOLLOW */
63: /* | PDB_VP */
64: /* | PDB_PV */
65: /* | PDB_ENTER */
66: /* | PDB_REMOVE */
67: /* | PDB_STEAL */
68: /* | PDB_PROTECT */
69: /* | PDB_PHYS */
70: ;
71: #else
72: #define DPRINTF(l,s) /* */
73: #endif
74:
75: paddr_t physical_steal, physical_end;
76:
77: struct pmap kernel_pmap_store;
78: struct pool pmap_pmap_pool;
79: struct pool pmap_pv_pool;
80: int pmap_pvlowat = 252;
81: int pmap_initialized;
82: int pmap_nkpdes = 32;
83:
84: pt_entry_t hppa_prot[8];
85: #define pmap_prot(m,vp) (hppa_prot[(vp)] | ((m) == pmap_kernel()? 0 : PTE_USER))
86:
87: pt_entry_t kernel_ptes[] = {
88: PTE_EXEC | PTE_ORDER | PTE_PREDICT | PTE_WIRED |
89: TLB_PAGE(0x000000) | PTE_PG4M,
90: PTE_WRITE | PTE_ORDER | PTE_DIRTY | PTE_WIRED |
91: TLB_PAGE(0x400000) | PTE_PG4M,
92: PTE_WRITE | PTE_ORDER | PTE_DIRTY | PTE_WIRED |
93: TLB_PAGE(0x800000) | PTE_PG4M,
94: PTE_WRITE | PTE_ORDER | PTE_DIRTY | PTE_WIRED |
95: TLB_PAGE(0xc00000) | PTE_PG4M
96: };
97:
98: #define pmap_pvh_attrs(a) \
99: (((a) & PTE_DIRTY) | ((a) ^ PTE_REFTRAP))
100:
101: struct vm_page *
102: pmap_pagealloc(int wait)
103: {
104: struct vm_page *pg;
105:
106: if ((pg = uvm_pagealloc(NULL, 0, NULL,
107: UVM_PGA_USERESERVE | UVM_PGA_ZERO)) == NULL)
108: printf("pmap_pagealloc fail\n");
109:
110: return (pg);
111: }
112:
113: volatile pt_entry_t *
114: pmap_pde_get(volatile u_int32_t *pd, vaddr_t va)
115: {
116: int i;
117:
118: DPRINTF(PDB_FOLLOW|PDB_VP,
119: ("pmap_pde_get(%p, 0x%lx)\n", pd, va));
120:
121: i = (va & PIE_MASK) >> PIE_SHIFT;
122: if (i) {
123: pd = (volatile u_int32_t *)((u_int64_t)pd[i] << PAGE_SHIFT);
124:
125: if (!pd)
126: return (NULL);
127: } else
128: pd += PAGE_SIZE / sizeof(*pd);
129:
130: i = (va & PDE_MASK) >> PDE_SHIFT;
131: return (pt_entry_t *)((u_int64_t)pd[i] << PAGE_SHIFT);
132: }
133:
134: void
135: pmap_pde_set(struct pmap *pm, vaddr_t va, paddr_t ptp)
136: {
137: volatile u_int32_t *pd = pm->pm_pdir;
138: int i;
139:
140: DPRINTF(PDB_FOLLOW|PDB_VP,
141: ("pmap_pde_set(%p, 0x%lx, 0x%lx)\n", pm, va, ptp));
142:
143: i = (va & PIE_MASK) >> PIE_SHIFT;
144: if (i)
145: pd = (volatile u_int32_t *)((u_int64_t)pd[i] << PAGE_SHIFT);
146: else
147: pd += PAGE_SIZE / sizeof(*pd);
148:
149: i = (va & PDE_MASK) >> PDE_SHIFT;
150: pd[i] = ptp >> PAGE_SHIFT;
151: }
152:
153: pt_entry_t *
154: pmap_pde_alloc(struct pmap *pm, vaddr_t va, struct vm_page **pdep)
155: {
156: struct vm_page *pg;
157: paddr_t pa;
158:
159: DPRINTF(PDB_FOLLOW|PDB_VP,
160: ("pmap_pde_alloc(%p, 0x%lx, %p)\n", pm, va, pdep));
161:
162: if ((pg = pmap_pagealloc(0)) == NULL)
163: return (NULL);
164:
165: pa = VM_PAGE_TO_PHYS(pg);
166:
167: DPRINTF(PDB_FOLLOW|PDB_VP, ("pmap_pde_alloc: pde %lx\n", pa));
168:
169: atomic_clearbits_int(&pg->pg_flags, PG_BUSY);
170: pg->wire_count = 1; /* no mappings yet */
171: pmap_pde_set(pm, va, pa);
172: pm->pm_stats.resident_count++; /* count PTP as resident */
173: pm->pm_ptphint = pg;
174: if (pdep)
175: *pdep = pg;
176: return ((pt_entry_t *)pa);
177: }
178:
179: static __inline struct vm_page *
180: pmap_pde_ptp(struct pmap *pm, volatile pt_entry_t *pde)
181: {
182: paddr_t pa = (paddr_t)pde;
183:
184: DPRINTF(PDB_FOLLOW|PDB_PV, ("pmap_pde_ptp(%p, %p)\n", pm, pde));
185:
186: if (pm->pm_ptphint && VM_PAGE_TO_PHYS(pm->pm_ptphint) == pa)
187: return (pm->pm_ptphint);
188:
189: DPRINTF(PDB_FOLLOW|PDB_PV, ("pmap_pde_ptp: lookup 0x%lx\n", pa));
190:
191: return (PHYS_TO_VM_PAGE(pa));
192: }
193:
194: static __inline void
195: pmap_pde_release(struct pmap *pmap, vaddr_t va, struct vm_page *ptp)
196: {
197: DPRINTF(PDB_FOLLOW|PDB_PV,
198: ("pmap_pde_release(%p, 0x%lx, %p)\n", pmap, va, ptp));
199:
200: if (pmap != pmap_kernel() && --ptp->wire_count <= 1) {
201: DPRINTF(PDB_FOLLOW|PDB_PV,
202: ("pmap_pde_release: disposing ptp %p\n", ptp));
203: pmap_pde_set(pmap, va, 0);
204: pmap->pm_stats.resident_count--;
205: if (pmap->pm_ptphint == ptp)
206: pmap->pm_ptphint = NULL;
207: ptp->wire_count = 0;
208: #ifdef DIAGNOSTIC
209: if (ptp->pg_flags & PG_BUSY)
210: panic("pmap_pde_release: busy page table page");
211: #endif
212: pdcache(HPPA_SID_KERNEL, (vaddr_t)ptp, PAGE_SIZE);
213: uvm_pagefree(ptp);
214: }
215: }
216:
217: static __inline pt_entry_t
218: pmap_pte_get(volatile pt_entry_t *pde, vaddr_t va)
219: {
220: DPRINTF(PDB_FOLLOW|PDB_VP,
221: ("pmap_pte_get(%p, 0x%lx)\n", pde, va));
222:
223: return (pde[(va & PTE_MASK) >> PTE_SHIFT]);
224: }
225:
226: static __inline void
227: pmap_pte_set(volatile pt_entry_t *pde, vaddr_t va, pt_entry_t pte)
228: {
229: DPRINTF(PDB_FOLLOW|PDB_VP,
230: ("pmap_pte_set(%p, 0x%lx, 0x%lx)\n", pde, va, pte));
231:
232: pde[(va & PTE_MASK) >> PTE_SHIFT] = pte;
233: }
234:
235: void
236: pmap_pte_flush(struct pmap *pmap, vaddr_t va, pt_entry_t pte)
237: {
238: if (pte & PTE_EXEC) {
239: ficache(pmap->pm_space, va, PAGE_SIZE);
240: pitlb(pmap->pm_space, va);
241: }
242: fdcache(pmap->pm_space, va, PAGE_SIZE);
243: pdtlb(pmap->pm_space, va);
244: }
245:
246: static __inline pt_entry_t
247: pmap_vp_find(struct pmap *pm, vaddr_t va)
248: {
249: volatile pt_entry_t *pde;
250:
251: if (!(pde = pmap_pde_get(pm->pm_pdir, va)))
252: return (0);
253:
254: return (pmap_pte_get(pde, va));
255: }
256:
257: #ifdef DDB
258: void
259: pmap_dump_table(pa_space_t space, vaddr_t sva)
260: {
261: pa_space_t sp;
262: volatile pt_entry_t *pde;
263: volatile u_int32_t *pd;
264: pt_entry_t pte;
265: vaddr_t va, pdemask;
266:
267: if (space)
268: pd = (u_int32_t *)mfctl(CR_VTOP);
269: else
270: pd = pmap_kernel()->pm_pdir;
271:
272: for (pdemask = 1, va = sva ? sva : 0;
273: va < VM_MAX_ADDRESS; va += PAGE_SIZE) {
274: if (pdemask != (va & (PDE_MASK|PIE_MASK))) {
275: pdemask = va & (PDE_MASK|PIE_MASK);
276: if (!(pde = pmap_pde_get(pd, va))) {
277: va += ~PDE_MASK + 1 - PAGE_SIZE;
278: continue;
279: }
280: printf("%x:%8p:\n", sp, pde);
281: }
282:
283: if (!(pte = pmap_pte_get(pde, va)))
284: continue;
285:
286: printf("0x%08lx-0x%08lx:%b\n",
287: va, PTE_PAGE(pte), PTE_GETBITS(pte), PTE_BITS);
288: }
289: }
290:
291: void
292: pmap_dump_pv(paddr_t pa)
293: {
294: struct vm_page *pg;
295: struct pv_entry *pve;
296:
297: pg = PHYS_TO_VM_PAGE(pa);
298: simple_lock(&pg->mdpage.pvh_lock);
299: for(pve = pg->mdpage.pvh_list; pve; pve = pve->pv_next)
300: printf("%x:%lx\n", pve->pv_pmap->pm_space, pve->pv_va);
301: simple_unlock(&pg->mdpage.pvh_lock);
302: }
303: #endif
304:
305: #ifdef PMAPDEBUG
306: int
307: pmap_check_alias(struct pv_entry *pve, vaddr_t va, pt_entry_t pte)
308: {
309: int ret;
310:
311: /* check for non-equ aliased mappings */
312: for (ret = 0; pve; pve = pve->pv_next) {
313: pte |= pmap_vp_find(pve->pv_pmap, pve->pv_va);
314: if ((va & HPPA_PGAOFF) != (pve->pv_va & HPPA_PGAOFF) &&
315: (pte & PTE_WRITE)) {
316: printf("pmap_check_alias: "
317: "aliased writable mapping 0x%x:0x%lx\n",
318: pve->pv_pmap->pm_space, pve->pv_va);
319: ret++;
320: }
321: }
322:
323: return (ret);
324: }
325: #endif
326:
327: static __inline struct pv_entry *
328: pmap_pv_alloc(void)
329: {
330: struct pv_entry *pv;
331:
332: DPRINTF(PDB_FOLLOW|PDB_PV, ("pmap_pv_alloc()\n"));
333:
334: pv = pool_get(&pmap_pv_pool, PR_NOWAIT);
335:
336: DPRINTF(PDB_FOLLOW|PDB_PV, ("pmap_pv_alloc: %p\n", pv));
337:
338: return (pv);
339: }
340:
341: void
342: pmap_pv_free(struct pv_entry *pv)
343: {
344: if (pv->pv_ptp)
345: pmap_pde_release(pv->pv_pmap, pv->pv_va, pv->pv_ptp);
346:
347: pool_put(&pmap_pv_pool, pv);
348: }
349:
350: void
351: pmap_pv_enter(struct vm_page *pg, struct pv_entry *pve, struct pmap *pm,
352: vaddr_t va, struct vm_page *pdep)
353: {
354: DPRINTF(PDB_FOLLOW|PDB_PV, ("pmap_pv_enter(%p, %p, %p, 0x%lx, %p)\n",
355: pg, pve, pm, va, pdep));
356: pve->pv_pmap = pm;
357: pve->pv_va = va;
358: pve->pv_ptp = pdep;
359: pve->pv_next = pg->mdpage.pvh_list;
360: pg->mdpage.pvh_list = pve;
361: #ifdef PMAPDEBUG
362: if (pmap_check_alias(pve, va, 0))
363: Debugger();
364: #endif
365: }
366:
367: struct pv_entry *
368: pmap_pv_remove(struct vm_page *pg, struct pmap *pmap, vaddr_t va)
369: {
370: struct pv_entry **pve, *pv;
371:
372: DPRINTF(PDB_FOLLOW|PDB_PV, ("pmap_pv_remove(%p, %p, 0x%lx)\n",
373: pg, pmap, va));
374:
375: simple_lock(&pg->mdpage.pvh_lock); /* lock pv_head */
376: for(pv = *(pve = &pg->mdpage.pvh_list);
377: pv; pv = *(pve = &(*pve)->pv_next))
378: if (pv->pv_pmap == pmap && pv->pv_va == va) {
379: *pve = pv->pv_next;
380: break;
381: }
382: simple_unlock(&pg->mdpage.pvh_lock); /* unlock, done! */
383: return (pv);
384: }
385:
386: const pt_entry_t hppa_pgs[] = {
387: PTE_PG4K,
388: PTE_PG16K,
389: PTE_PG64K,
390: PTE_PG256K,
391: PTE_PG1M,
392: PTE_PG4M,
393: PTE_PG16M,
394: PTE_PG64M
395: };
396: #define nhppa_pgs sizeof(hppa_pgs)/sizeof(hppa_pgs[0])
397:
398: void
399: pmap_maphys(paddr_t spa, paddr_t epa)
400: {
401: volatile pt_entry_t *pde, *epde, pte;
402: paddr_t pa, tpa;
403: int s, e, i;
404:
405: DPRINTF(PDB_INIT, ("pmap_maphys: mapping 0x%lx - 0x%lx\n", spa, epa));
406:
407: s = ffs(spa) - 12;
408: e = ffs(epa) - 12;
409:
410: if (s < e || (s == e && s / 2 < nhppa_pgs)) {
411: i = s / 2;
412: if (i > nhppa_pgs)
413: i = nhppa_pgs;
414: pa = spa;
415: spa = tpa = 0x1000 << ((i + 1) * 2);
416: } else if (s > e) {
417: i = e / 2;
418: if (i > nhppa_pgs)
419: i = nhppa_pgs;
420: epa = pa = epa & (0xfffff000 << ((i + 1) * 2));
421: tpa = epa;
422: } else {
423: i = s / 2;
424: if (i > nhppa_pgs)
425: i = nhppa_pgs;
426: pa = spa;
427: spa = tpa = epa;
428: }
429:
430: printf("pa 0x%lx tpa 0x%lx\n", pa, tpa);
431: while (pa < tpa) {
432: pte = TLB_PAGE(pa) | hppa_pgs[i - 1] |
433: PTE_WRITE | PTE_ORDER | PTE_DIRTY | PTE_WIRED;
434: pde = pmap_pde_get(pmap_kernel()->pm_pdir, pa);
435: epde = pde + (PTE_MASK >> PTE_SHIFT) + 1;
436: if (pa + (PTE_MASK + (1 << PTE_SHIFT)) > tpa)
437: epde = pde + ((tpa & PTE_MASK) >> PTE_SHIFT);
438: printf("pde %p epde %p pte 0x%lx\n", pde, epde, pte);
439: for (pde += (pa & PTE_MASK) >> PTE_SHIFT; pde < epde;)
440: *pde++ = pte;
441: pa += PTE_MASK + (1 << PTE_SHIFT);
442: pa &= ~(PTE_MASK | PAGE_MASK);
443: }
444:
445: if (spa < epa)
446: pmap_maphys(spa, epa);
447: }
448:
449: void
450: pmap_bootstrap(vstart)
451: vaddr_t vstart;
452: {
453: extern int resvphysmem, __rodata_end, __data_start;
454: vaddr_t va, eaddr, addr = round_page(vstart);
455: struct pmap *kpm;
456:
457: DPRINTF(PDB_FOLLOW|PDB_INIT, ("pmap_bootstrap(0x%lx)\n", vstart));
458:
459: uvm_setpagesize();
460:
461: hppa_prot[UVM_PROT_NONE] = PTE_ORDER|PTE_ACC_NONE;
462: hppa_prot[UVM_PROT_READ] = PTE_ORDER|PTE_READ;
463: hppa_prot[UVM_PROT_WRITE] = PTE_ORDER|PTE_WRITE;
464: hppa_prot[UVM_PROT_RW] = PTE_ORDER|PTE_READ|PTE_WRITE;
465: hppa_prot[UVM_PROT_EXEC] = PTE_ORDER|PTE_EXEC;
466: hppa_prot[UVM_PROT_RX] = PTE_ORDER|PTE_READ|PTE_EXEC;
467: hppa_prot[UVM_PROT_WX] = PTE_ORDER|PTE_WRITE|PTE_EXEC;
468: hppa_prot[UVM_PROT_RWX] = PTE_ORDER|PTE_READ|PTE_WRITE|PTE_EXEC;
469:
470: /*
471: * Initialize kernel pmap
472: */
473: kpm = &kernel_pmap_store;
474: bzero(kpm, sizeof(*kpm));
475: simple_lock_init(&kpm->pm_lock);
476: kpm->pm_refcount = 1;
477: kpm->pm_space = HPPA_SID_KERNEL;
478: TAILQ_INIT(&kpm->pm_pglist);
479: kpm->pm_pdir = (u_int32_t *)mfctl(CR_VTOP);
480:
481: /*
482: * Allocate various tables and structures.
483: */
484:
485: if (&__rodata_end < &__data_start) {
486: physical_steal = (vaddr_t)&__rodata_end;
487: physical_end = (vaddr_t)&__data_start;
488: DPRINTF(PDB_INIT, ("physpool: 0x%lx @ 0x%lx\n",
489: physical_end - physical_steal, physical_steal));
490: }
491:
492: /* map enough PDEs to map initial physmem */
493: for (va = 0x1000000, eaddr = ptoa(physmem);
494: va < eaddr; addr += PAGE_SIZE, va += 1 << PDE_SHIFT) {
495: bzero((void *)addr, PAGE_SIZE);
496: pmap_pde_set(kpm, va, addr);
497: kpm->pm_stats.resident_count++; /* count PTP as resident */
498: }
499:
500: /* map a little of initial kmem */
501: for (va = VM_MIN_KERNEL_ADDRESS + ((pmap_nkpdes - 1) << PDE_SHIFT);
502: va >= VM_MIN_KERNEL_ADDRESS;
503: addr += PAGE_SIZE, va -= 1 << PDE_SHIFT) {
504: bzero((void *)addr, PAGE_SIZE);
505: pmap_pde_set(kpm, va, addr);
506: kpm->pm_stats.resident_count++; /* count PTP as resident */
507: }
508:
509: pmap_maphys(0x1000000, ctob(physmem));
510:
511: eaddr = physmem - atop(round_page(MSGBUFSIZE));
512: resvphysmem = atop(addr);
513: DPRINTF(PDB_INIT, ("physmem: 0x%lx - 0x%lx\n", resvphysmem, eaddr));
514: uvm_page_physload(0, physmem,
515: resvphysmem, eaddr, VM_FREELIST_DEFAULT);
516: }
517:
518: void
519: pmap_init()
520: {
521: DPRINTF(PDB_FOLLOW|PDB_INIT, ("pmap_init()\n"));
522:
523: pool_init(&pmap_pmap_pool, sizeof(struct pmap), 0, 0, 0, "pmappl",
524: &pool_allocator_nointr);
525: pool_init(&pmap_pv_pool, sizeof(struct pv_entry),0,0,0, "pmappv", NULL);
526: pool_setlowat(&pmap_pv_pool, pmap_pvlowat);
527: pool_sethiwat(&pmap_pv_pool, pmap_pvlowat * 32);
528:
529: pmap_initialized = 1;
530:
531: DPRINTF(PDB_FOLLOW|PDB_INIT, ("pmap_init(): done\n"));
532: }
533:
534: #ifdef PMAP_STEAL_MEMORY
535: vaddr_t
536: pmap_steal_memory(vsize_t size, vaddr_t *vstartp, vaddr_t *vendp)
537: {
538: vaddr_t va;
539: int npg;
540:
541: DPRINTF(PDB_FOLLOW|PDB_PHYS,
542: ("pmap_steal_memory(0x%lx, %p, %p)\n", size, vstartp, vendp));
543:
544: size = round_page(size);
545: npg = atop(size);
546:
547: if (vm_physmem[0].avail_end - vm_physmem[0].avail_start < npg)
548: panic("pmap_steal_memory: no more");
549:
550: if (vstartp)
551: *vstartp = VM_MIN_KERNEL_ADDRESS;
552: if (vendp)
553: *vendp = VM_MAX_KERNEL_ADDRESS;
554:
555: vm_physmem[0].end -= npg;
556: vm_physmem[0].avail_end -= npg;
557: va = ptoa(vm_physmem[0].avail_end) - size;
558: bzero((void *)va, size);
559:
560: DPRINTF(PDB_FOLLOW|PDB_PHYS, ("pmap_steal_memory: 0x%lx\n", va));
561:
562: return (va);
563: }
564: #else
565: void
566: pmap_virtual_space(vaddr_t *startp, vaddr_t *endp)
567: {
568: *startp = VM_MIN_KERNEL_ADDRESS;
569: *endp = VM_MAX_KERNEL_ADDRESS;
570: }
571: #endif /* PMAP_STEAL_MEMORY */
572:
573: #ifdef PMAP_GROWKERNEL
574: vaddr_t
575: pmap_growkernel(vaddr_t kva)
576: {
577: vaddr_t va;
578:
579: DPRINTF(PDB_FOLLOW|PDB_PHYS, ("pmap_growkernel(0x%lx)\n", kva));
580:
581: va = VM_MIN_KERNEL_ADDRESS + (pmap_nkpdes << PDE_SHIFT);
582: DPRINTF(PDB_PHYS, ("pmap_growkernel: was va 0x%lx\n", va));
583: if (va < kva) {
584: simple_lock(&pmap_kernel()->pm_obj.vmobjlock);
585:
586: for ( ; va < kva ; pmap_nkpdes++, va += 1 << PDE_SHIFT)
587: if (uvm.page_init_done) {
588: if (!pmap_pde_alloc(pmap_kernel(), va, NULL))
589: break;
590: } else {
591: paddr_t pa;
592:
593: pa = pmap_steal_memory(PAGE_SIZE, NULL, NULL);
594: if (pa)
595: panic("pmap_growkernel: out of memory");
596: pmap_pde_set(pmap_kernel(), va, pa);
597: pmap_kernel()->pm_stats.resident_count++;
598: }
599:
600: simple_unlock(&pmap_kernel()->pm_obj.vmobjlock);
601: }
602: DPRINTF(PDB_PHYS|PDB_VP, ("pmap_growkernel: now va 0x%lx\n", va));
603: return (va);
604: }
605: #endif /* PMAP_GROWKERNEL */
606:
607: struct pmap *
608: pmap_create()
609: {
610: struct pmap *pmap;
611: struct vm_page *pg;
612: pa_space_t space;
613: paddr_t pa;
614:
615: DPRINTF(PDB_FOLLOW|PDB_PMAP, ("pmap_create()\n"));
616:
617: pmap = pool_get(&pmap_pmap_pool, PR_WAITOK);
618:
619: simple_lock_init(&pmap->pm_lock);
620: pmap->pm_refcount = 1;
621: pmap->pm_ptphint = NULL;
622:
623: TAILQ_INIT(&pmap->pm_pglist);
624: if (uvm_pglistalloc(2 * PAGE_SIZE, 0, VM_MIN_KERNEL_ADDRESS,
625: PAGE_SIZE, 2 * PAGE_SIZE, &pmap->pm_pglist, 1, 1))
626: panic("pmap_create: no pages");
627:
628: pg = TAILQ_FIRST(&pmap->pm_pglist);
629: atomic_clearbits_int(&pg->pg_flags, PG_BUSY|PG_CLEAN);
630: pmap->pm_pdir = (u_int32_t *)(pa = VM_PAGE_TO_PHYS(pg));
631: bzero((void *)pa, PAGE_SIZE);
632:
633: /* set the first PIE that's covering low 2g of the address space */
634: pg = TAILQ_LAST(&pmap->pm_pglist, pglist);
635: atomic_clearbits_int(&pg->pg_flags, PG_BUSY|PG_CLEAN);
636: *pmap->pm_pdir = (pa = VM_PAGE_TO_PHYS(pg)) >> PAGE_SHIFT;
637: bzero((void *)pa, PAGE_SIZE);
638:
639: /* TODO for (space = 1 + (arc4random() & HPPA_SID_MAX);
640: pmap_sdir_get(space); space = (space + 1) % HPPA_SID_MAX); */
641: pmap->pm_space = space;
642:
643: pmap->pm_stats.resident_count = 2;
644: pmap->pm_stats.wired_count = 0;
645:
646: return (pmap);
647: }
648:
649: void
650: pmap_destroy(pmap)
651: struct pmap *pmap;
652: {
653: int refs;
654:
655: DPRINTF(PDB_FOLLOW|PDB_PMAP, ("pmap_destroy(%p)\n", pmap));
656:
657: simple_lock(&pmap->pm_lock);
658: refs = --pmap->pm_refcount;
659: simple_unlock(&pmap->pm_lock);
660:
661: if (refs > 0)
662: return;
663:
664: uvm_pglistfree(&pmap->pm_pglist);
665: TAILQ_INIT(&pmap->pm_pglist);
666: pool_put(&pmap_pmap_pool, pmap);
667: }
668:
669: /*
670: * Add a reference to the specified pmap.
671: */
672: void
673: pmap_reference(struct pmap *pmap)
674: {
675: DPRINTF(PDB_FOLLOW|PDB_PMAP, ("pmap_reference(%p)\n", pmap));
676:
677: simple_lock(&pmap->pm_lock);
678: pmap->pm_refcount++;
679: simple_unlock(&pmap->pm_lock);
680: }
681:
682: void
683: pmap_collect(struct pmap *pmap)
684: {
685: DPRINTF(PDB_FOLLOW|PDB_PMAP, ("pmap_collect(%p)\n", pmap));
686: /* nothing yet */
687: }
688:
689: int
690: pmap_enter(pmap, va, pa, prot, flags)
691: struct pmap *pmap;
692: vaddr_t va;
693: paddr_t pa;
694: vm_prot_t prot;
695: int flags;
696: {
697: volatile pt_entry_t *pde;
698: pt_entry_t pte;
699: struct vm_page *pg, *ptp = NULL;
700: struct pv_entry *pve;
701: boolean_t wired = (flags & PMAP_WIRED) != 0;
702:
703: DPRINTF(PDB_FOLLOW|PDB_ENTER,
704: ("pmap_enter(%p, 0x%lx, 0x%lx, 0x%x, 0x%x)\n",
705: pmap, va, pa, prot, flags));
706:
707: simple_lock(&pmap->pm_lock);
708:
709: if (!(pde = pmap_pde_get(pmap->pm_pdir, va)) &&
710: !(pde = pmap_pde_alloc(pmap, va, &ptp))) {
711: if (flags & PMAP_CANFAIL) {
712: simple_unlock(&pmap->pm_lock);
713: return (ENOMEM);
714: }
715:
716: panic("pmap_enter: cannot allocate pde");
717: }
718:
719: if (!ptp)
720: ptp = pmap_pde_ptp(pmap, pde);
721:
722: if ((pte = pmap_pte_get(pde, va))) {
723:
724: DPRINTF(PDB_ENTER,
725: ("pmap_enter: remapping 0x%lx -> 0x%lx\n", pte, pa));
726:
727: pmap_pte_flush(pmap, va, pte);
728: if (wired && !(pte & PTE_WIRED))
729: pmap->pm_stats.wired_count++;
730: else if (!wired && (pte & PTE_WIRED))
731: pmap->pm_stats.wired_count--;
732: pte &= PTE_UNCACHABLE|PTE_DIRTY|PTE_REFTRAP;
733:
734: if (PTE_PAGE(pte) == pa) {
735: DPRINTF(PDB_FOLLOW|PDB_ENTER,
736: ("pmap_enter: same page\n"));
737: goto enter;
738: }
739:
740: pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte));
741: simple_lock(&pg->mdpage.pvh_lock);
742: pve = pmap_pv_remove(pg, pmap, va);
743: pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
744: } else {
745: DPRINTF(PDB_ENTER,
746: ("pmap_enter: new mapping 0x%lx -> 0x%lx\n", va, pa));
747: pte = PTE_REFTRAP;
748: pve = NULL;
749: pmap->pm_stats.resident_count++;
750: if (wired)
751: pmap->pm_stats.wired_count++;
752: if (ptp)
753: ptp->wire_count++;
754: simple_lock(&pg->mdpage.pvh_lock);
755: }
756:
757: if (pmap_initialized && (pg = PHYS_TO_VM_PAGE(pa))) {
758: if (!pve && !(pve = pmap_pv_alloc())) {
759: if (flags & PMAP_CANFAIL) {
760: simple_unlock(&pg->mdpage.pvh_lock);
761: simple_unlock(&pmap->pm_lock);
762: return (ENOMEM);
763: }
764: panic("pmap_enter: no pv entries available");
765: }
766: pmap_pv_enter(pg, pve, pmap, va, ptp);
767: } else if (pve)
768: pmap_pv_free(pve);
769: simple_unlock(&pg->mdpage.pvh_lock);
770:
771: enter:
772: /* preserve old ref & mod */
773: pte = TLB_PAGE(pa) | pmap_prot(pmap, prot);
774: if (wired)
775: pte |= PTE_WIRED;
776: pmap_pte_set(pde, va, pte);
777:
778: simple_unlock(&pmap->pm_lock);
779:
780: DPRINTF(PDB_FOLLOW|PDB_ENTER, ("pmap_enter: leaving\n"));
781:
782: return (0);
783: }
784:
785: void
786: pmap_remove(pmap, sva, eva)
787: struct pmap *pmap;
788: vaddr_t sva;
789: vaddr_t eva;
790: {
791: struct pv_entry *pve;
792: volatile pt_entry_t *pde;
793: pt_entry_t pte;
794: struct vm_page *pg;
795: vaddr_t pdemask;
796: int batch;
797:
798: DPRINTF(PDB_FOLLOW|PDB_REMOVE,
799: ("pmap_remove(%p, 0x%lx, 0x%lx)\n", pmap, sva, eva));
800:
801: simple_lock(&pmap->pm_lock);
802:
803: for (batch = 0, pdemask = 1; sva < eva; sva += PAGE_SIZE) {
804: if (pdemask != (sva & PDE_MASK)) {
805: pdemask = sva & PDE_MASK;
806: if (!(pde = pmap_pde_get(pmap->pm_pdir, sva))) {
807: sva += ~PDE_MASK + 1 - PAGE_SIZE;
808: continue;
809: }
810: batch = pdemask == sva && sva + ~PDE_MASK + 1 <= eva;
811: }
812:
813: if ((pte = pmap_pte_get(pde, sva))) {
814:
815: /* TODO measure here the speed tradeoff
816: * for flushing whole PT vs per-page
817: * in case of non-complete pde fill
818: */
819: pmap_pte_flush(pmap, sva, pte);
820: if (pte & PTE_WIRED)
821: pmap->pm_stats.wired_count--;
822: pmap->pm_stats.resident_count--;
823:
824: /* iff properly accounted pde will be dropped anyway */
825: if (!batch)
826: pmap_pte_set(pde, sva, 0);
827:
828: if (pmap_initialized &&
829: (pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte)))) {
830:
831: simple_lock(&pg->mdpage.pvh_lock);
832: pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
833: if ((pve = pmap_pv_remove(pg, pmap, sva)))
834: pmap_pv_free(pve);
835: simple_unlock(&pg->mdpage.pvh_lock);
836: }
837: }
838: }
839:
840: simple_unlock(&pmap->pm_lock);
841:
842: DPRINTF(PDB_FOLLOW|PDB_REMOVE, ("pmap_remove: leaving\n"));
843: }
844:
845: void
846: pmap_write_protect(pmap, sva, eva, prot)
847: struct pmap *pmap;
848: vaddr_t sva;
849: vaddr_t eva;
850: vm_prot_t prot;
851: {
852: struct vm_page *pg;
853: volatile pt_entry_t *pde;
854: pt_entry_t pte;
855: u_int tlbprot, pdemask;
856:
857: DPRINTF(PDB_FOLLOW|PDB_PMAP,
858: ("pmap_write_protect(%p, %lx, %lx, %x)\n", pmap, sva, eva, prot));
859:
860: sva = trunc_page(sva);
861: tlbprot = pmap_prot(pmap, prot);
862:
863: simple_lock(&pmap->pm_lock);
864:
865: for (pdemask = 1; sva < eva; sva += PAGE_SIZE) {
866: if (pdemask != (sva & PDE_MASK)) {
867: pdemask = sva & PDE_MASK;
868: if (!(pde = pmap_pde_get(pmap->pm_pdir, sva))) {
869: sva += ~PDE_MASK + 1 - PAGE_SIZE;
870: continue;
871: }
872: }
873: if ((pte = pmap_pte_get(pde, sva))) {
874:
875: DPRINTF(PDB_PMAP,
876: ("pmap_write_protect: va=0x%lx pte=0x%lx\n",
877: sva, pte));
878: /*
879: * Determine if mapping is changing.
880: * If not, nothing to do.
881: */
882: if ((pte & PTE_ACC_MASK) == tlbprot)
883: continue;
884:
885: pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte));
886: simple_lock(&pg->mdpage.pvh_lock);
887: pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
888: simple_unlock(&pg->mdpage.pvh_lock);
889:
890: pmap_pte_flush(pmap, sva, pte);
891: pte &= ~PTE_ACC_MASK;
892: pte |= tlbprot;
893: pmap_pte_set(pde, sva, pte);
894: }
895: }
896:
897: simple_unlock(&pmap->pm_lock);
898: }
899:
900: void
901: pmap_page_remove(pg)
902: struct vm_page *pg;
903: {
904: struct pv_entry *pve, *ppve;
905:
906: DPRINTF(PDB_FOLLOW|PDB_PV, ("pmap_page_remove(%p)\n", pg));
907:
908: if (pg->mdpage.pvh_list == NULL)
909: return;
910:
911: simple_lock(&pg->mdpage.pvh_lock);
912: for (pve = pg->mdpage.pvh_list; pve;
913: pve = (ppve = pve)->pv_next, pmap_pv_free(ppve)) {
914: struct pmap *pmap = pve->pv_pmap;
915: vaddr_t va = pve->pv_va;
916: volatile pt_entry_t *pde;
917: pt_entry_t pte;
918:
919: simple_lock(&pmap->pm_lock);
920:
921: pde = pmap_pde_get(pmap->pm_pdir, va);
922: pte = pmap_pte_get(pde, va);
923: pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
924:
925: pmap_pte_flush(pmap, va, pte);
926: if (pte & PTE_WIRED)
927: pmap->pm_stats.wired_count--;
928: pmap->pm_stats.resident_count--;
929:
930: pmap_pte_set(pde, va, 0);
931: simple_unlock(&pmap->pm_lock);
932: }
933: pg->mdpage.pvh_list = NULL;
934: simple_unlock(&pg->mdpage.pvh_lock);
935:
936: DPRINTF(PDB_FOLLOW|PDB_PV, ("pmap_page_remove: leaving\n"));
937:
938: }
939:
940: void
941: pmap_unwire(pmap, va)
942: struct pmap *pmap;
943: vaddr_t va;
944: {
945: volatile pt_entry_t *pde;
946: pt_entry_t pte = 0;
947:
948: DPRINTF(PDB_FOLLOW|PDB_PMAP, ("pmap_unwire(%p, 0x%lx)\n", pmap, va));
949:
950: simple_lock(&pmap->pm_lock);
951: if ((pde = pmap_pde_get(pmap->pm_pdir, va))) {
952: pte = pmap_pte_get(pde, va);
953:
954: if (pte & PTE_WIRED) {
955: pte &= ~PTE_WIRED;
956: pmap->pm_stats.wired_count--;
957: pmap_pte_set(pde, va, pte);
958: }
959: }
960: simple_unlock(&pmap->pm_lock);
961:
962: DPRINTF(PDB_FOLLOW|PDB_PMAP, ("pmap_unwire: leaving\n"));
963:
964: #ifdef DIAGNOSTIC
965: if (!pte)
966: panic("pmap_unwire: invalid va 0x%lx", va);
967: #endif
968: }
969:
970: boolean_t
971: pmap_changebit(struct vm_page *pg, pt_entry_t set, pt_entry_t clear)
972: {
973: struct pv_entry *pve;
974: pt_entry_t res;
975:
976: DPRINTF(PDB_FOLLOW|PDB_BITS,
977: ("pmap_changebit(%p, %lx, %lx)\n", pg, set, clear));
978:
979: simple_lock(&pg->mdpage.pvh_lock);
980: res = pg->mdpage.pvh_attrs = 0;
981: for(pve = pg->mdpage.pvh_list; pve; pve = pve->pv_next) {
982: struct pmap *pmap = pve->pv_pmap;
983: vaddr_t va = pve->pv_va;
984: volatile pt_entry_t *pde;
985: pt_entry_t opte, pte;
986:
987: simple_lock(&pmap->pm_lock);
988: if ((pde = pmap_pde_get(pmap->pm_pdir, va))) {
989: opte = pte = pmap_pte_get(pde, va);
990: #ifdef PMAPDEBUG
991: if (!pte) {
992: printf("pmap_changebit: zero pte for 0x%lx\n",
993: va);
994: continue;
995: }
996: #endif
997: pte &= ~clear;
998: pte |= set;
999: pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
1000: res |= pmap_pvh_attrs(opte);
1001:
1002: if (opte != pte) {
1003: pmap_pte_flush(pmap, va, opte);
1004: pmap_pte_set(pde, va, pte);
1005: }
1006: }
1007: simple_unlock(&pmap->pm_lock);
1008: }
1009: simple_unlock(&pg->mdpage.pvh_lock);
1010:
1011: return ((res & (clear | set)) != 0);
1012: }
1013:
1014: boolean_t
1015: pmap_testbit(struct vm_page *pg, pt_entry_t bit)
1016: {
1017: struct pv_entry *pve;
1018: pt_entry_t pte;
1019:
1020: DPRINTF(PDB_FOLLOW|PDB_BITS, ("pmap_testbit(%p, %lx)\n", pg, bit));
1021:
1022: simple_lock(&pg->mdpage.pvh_lock);
1023: for(pve = pg->mdpage.pvh_list; !(pg->mdpage.pvh_attrs & bit) && pve;
1024: pve = pve->pv_next) {
1025: simple_lock(&pve->pv_pmap->pm_lock);
1026: pte = pmap_vp_find(pve->pv_pmap, pve->pv_va);
1027: simple_unlock(&pve->pv_pmap->pm_lock);
1028: pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
1029: }
1030: simple_unlock(&pg->mdpage.pvh_lock);
1031:
1032: return ((pg->mdpage.pvh_attrs & bit) != 0);
1033: }
1034:
1035: boolean_t
1036: pmap_extract(pmap, va, pap)
1037: struct pmap *pmap;
1038: vaddr_t va;
1039: paddr_t *pap;
1040: {
1041: pt_entry_t pte;
1042:
1043: DPRINTF(PDB_FOLLOW|PDB_EXTRACT, ("pmap_extract(%p, %lx)\n", pmap, va));
1044:
1045: simple_lock(&pmap->pm_lock);
1046: pte = pmap_vp_find(pmap, va);
1047: simple_unlock(&pmap->pm_lock);
1048:
1049: if (pte) {
1050: if (pap)
1051: *pap = PTE_PAGE(pte) | (va & PAGE_MASK);
1052: return (TRUE);
1053: }
1054:
1055: return (FALSE);
1056: }
1057:
1058: void
1059: pmap_activate(struct proc *p)
1060: {
1061: struct pmap *pmap = p->p_vmspace->vm_map.pmap;
1062: struct pcb *pcb = &p->p_addr->u_pcb;
1063:
1064: pcb->pcb_space = pmap->pm_space;
1065: pcb->pcb_uva = (vaddr_t)p->p_addr;
1066: }
1067:
1068: void
1069: pmap_deactivate(struct proc *p)
1070: {
1071:
1072: }
1073:
1074: static __inline void
1075: pmap_flush_page(struct vm_page *pg, int purge)
1076: {
1077: struct pv_entry *pve;
1078:
1079: /* purge cache for all possible mappings for the pa */
1080: simple_lock(&pg->mdpage.pvh_lock);
1081: for(pve = pg->mdpage.pvh_list; pve; pve = pve->pv_next)
1082: if (purge)
1083: pdcache(pve->pv_pmap->pm_space, pve->pv_va, PAGE_SIZE);
1084: else
1085: fdcache(pve->pv_pmap->pm_space, pve->pv_va, PAGE_SIZE);
1086: simple_unlock(&pg->mdpage.pvh_lock);
1087: }
1088:
1089: void
1090: pmap_zero_page(struct vm_page *pg)
1091: {
1092: paddr_t pa = VM_PAGE_TO_PHYS(pg);
1093:
1094: DPRINTF(PDB_FOLLOW|PDB_PHYS, ("pmap_zero_page(%lx)\n", pa));
1095:
1096: pmap_flush_page(pg, 1);
1097: bzero((void *)pa, PAGE_SIZE);
1098: fdcache(HPPA_SID_KERNEL, pa, PAGE_SIZE);
1099: }
1100:
1101: void
1102: pmap_copy_page(struct vm_page *srcpg, struct vm_page *dstpg)
1103: {
1104: paddr_t spa = VM_PAGE_TO_PHYS(srcpg);
1105: paddr_t dpa = VM_PAGE_TO_PHYS(dstpg);
1106: DPRINTF(PDB_FOLLOW|PDB_PHYS, ("pmap_copy_page(%lx, %lx)\n", spa, dpa));
1107:
1108: pmap_flush_page(srcpg, 0);
1109: pmap_flush_page(dstpg, 1);
1110: bcopy((void *)spa, (void *)dpa, PAGE_SIZE);
1111: pdcache(HPPA_SID_KERNEL, spa, PAGE_SIZE);
1112: fdcache(HPPA_SID_KERNEL, dpa, PAGE_SIZE);
1113: }
1114:
1115: void
1116: pmap_kenter_pa(va, pa, prot)
1117: vaddr_t va;
1118: paddr_t pa;
1119: vm_prot_t prot;
1120: {
1121: volatile pt_entry_t *pde;
1122: pt_entry_t pte, opte;
1123:
1124: DPRINTF(PDB_FOLLOW|PDB_ENTER,
1125: ("pmap_kenter_pa(%lx, %lx, %x)\n", va, pa, prot));
1126:
1127: simple_lock(&pmap->pm_lock);
1128:
1129: if (!(pde = pmap_pde_get(pmap_kernel()->pm_pdir, va)) &&
1130: !(pde = pmap_pde_alloc(pmap_kernel(), va, NULL)))
1131: panic("pmap_kenter_pa: cannot allocate pde for va=0x%lx", va);
1132: opte = pmap_pte_get(pde, va);
1133: pte = TLB_PAGE(pa) | PTE_WIRED | PTE_REFTRAP |
1134: pmap_prot(pmap_kernel(), prot);
1135: if (pa >= 0xf0000000ULL /* TODO (HPPA_IOBEGIN & HPPA_PHYSMAP) */)
1136: pte |= PTE_UNCACHABLE | PTE_ORDER;
1137: DPRINTF(PDB_ENTER, ("pmap_kenter_pa: pde %p va %lx pte %lx\n",
1138: pde, va, pte));
1139: pmap_pte_set(pde, va, pte);
1140: pmap_kernel()->pm_stats.wired_count++;
1141: pmap_kernel()->pm_stats.resident_count++;
1142: if (opte)
1143: pmap_pte_flush(pmap_kernel(), va, opte);
1144:
1145: #ifdef PMAPDEBUG
1146: {
1147: struct vm_page *pg;
1148:
1149: if (pmap_initialized && (pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte)))) {
1150:
1151: simple_lock(&pg->mdpage.pvh_lock);
1152: if (pmap_check_alias(pg->mdpage.pvh_list, va, pte))
1153: Debugger();
1154: simple_unlock(&pg->mdpage.pvh_lock);
1155: }
1156: }
1157: #endif
1158: simple_unlock(&pmap->pm_lock);
1159:
1160: DPRINTF(PDB_FOLLOW|PDB_ENTER, ("pmap_kenter_pa: leaving\n"));
1161: }
1162:
1163: void
1164: pmap_kremove(va, size)
1165: vaddr_t va;
1166: vsize_t size;
1167: {
1168: struct pv_entry *pve;
1169: vaddr_t eva, pdemask;
1170: volatile pt_entry_t *pde;
1171: pt_entry_t pte;
1172: struct vm_page *pg;
1173:
1174: DPRINTF(PDB_FOLLOW|PDB_REMOVE,
1175: ("pmap_kremove(%lx, %lx)\n", va, size));
1176: #ifdef PMAPDEBUG
1177: if (va < ptoa(physmem)) {
1178: printf("pmap_kremove(%lx, %lx): unmapping physmem\n", va, size);
1179: return;
1180: }
1181: #endif
1182:
1183: simple_lock(&pmap->pm_lock);
1184:
1185: for (pdemask = 1, eva = va + size; va < eva; va += PAGE_SIZE) {
1186: if (pdemask != (va & PDE_MASK)) {
1187: pdemask = va & PDE_MASK;
1188: if (!(pde = pmap_pde_get(pmap_kernel()->pm_pdir, va))) {
1189: va += ~PDE_MASK + 1 - PAGE_SIZE;
1190: continue;
1191: }
1192: }
1193: if (!(pte = pmap_pte_get(pde, va))) {
1194: #ifdef DEBUG
1195: printf("pmap_kremove: unmapping unmapped 0x%lx\n", va);
1196: #endif
1197: continue;
1198: }
1199:
1200: pmap_pte_flush(pmap_kernel(), va, pte);
1201: pmap_pte_set(pde, va, 0);
1202: if (pmap_initialized && (pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte)))) {
1203:
1204: simple_lock(&pg->mdpage.pvh_lock);
1205: pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
1206: /* just in case we have enter/kenter mismatch */
1207: if ((pve = pmap_pv_remove(pg, pmap_kernel(), va)))
1208: pmap_pv_free(pve);
1209: simple_unlock(&pg->mdpage.pvh_lock);
1210: }
1211: }
1212:
1213: simple_unlock(&pmap->pm_lock);
1214:
1215: DPRINTF(PDB_FOLLOW|PDB_REMOVE, ("pmap_kremove: leaving\n"));
1216: }