3d772d312762acb3cc0211f2832f9e545f80c094
[dragonfly.git] / sys / platform / pc64 / x86_64 / pmap.c
1 /*
2  * Copyright (c) 1991 Regents of the University of California.
3  * Copyright (c) 1994 John S. Dyson
4  * Copyright (c) 1994 David Greenman
5  * Copyright (c) 2003 Peter Wemm
6  * Copyright (c) 2005-2008 Alan L. Cox <alc@cs.rice.edu>
7  * Copyright (c) 2008, 2009 The DragonFly Project.
8  * Copyright (c) 2008, 2009 Jordan Gordeev.
9  * Copyright (c) 2011-2012 Matthew Dillon
10  * All rights reserved.
11  *
12  * This code is derived from software contributed to Berkeley by
13  * the Systems Programming Group of the University of Utah Computer
14  * Science Department and William Jolitz of UUNET Technologies Inc.
15  *
16  * Redistribution and use in source and binary forms, with or without
17  * modification, are permitted provided that the following conditions
18  * are met:
19  * 1. Redistributions of source code must retain the above copyright
20  *    notice, this list of conditions and the following disclaimer.
21  * 2. Redistributions in binary form must reproduce the above copyright
22  *    notice, this list of conditions and the following disclaimer in the
23  *    documentation and/or other materials provided with the distribution.
24  * 3. All advertising materials mentioning features or use of this software
25  *    must display the following acknowledgement:
26  *      This product includes software developed by the University of
27  *      California, Berkeley and its contributors.
28  * 4. Neither the name of the University nor the names of its contributors
29  *    may be used to endorse or promote products derived from this software
30  *    without specific prior written permission.
31  *
32  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
33  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
34  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
35  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
36  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
40  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
41  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
42  * SUCH DAMAGE.
43  */
44 /*
45  * Manage physical address maps for x86-64 systems.
46  */
47
48 #if JG
49 #include "opt_disable_pse.h"
50 #include "opt_pmap.h"
51 #endif
52 #include "opt_msgbuf.h"
53
54 #include <sys/param.h>
55 #include <sys/systm.h>
56 #include <sys/kernel.h>
57 #include <sys/proc.h>
58 #include <sys/msgbuf.h>
59 #include <sys/vmmeter.h>
60 #include <sys/mman.h>
61
62 #include <vm/vm.h>
63 #include <vm/vm_param.h>
64 #include <sys/sysctl.h>
65 #include <sys/lock.h>
66 #include <vm/vm_kern.h>
67 #include <vm/vm_page.h>
68 #include <vm/vm_map.h>
69 #include <vm/vm_object.h>
70 #include <vm/vm_extern.h>
71 #include <vm/vm_pageout.h>
72 #include <vm/vm_pager.h>
73 #include <vm/vm_zone.h>
74
75 #include <sys/user.h>
76 #include <sys/thread2.h>
77 #include <sys/sysref2.h>
78 #include <sys/spinlock2.h>
79 #include <vm/vm_page2.h>
80
81 #include <machine/cputypes.h>
82 #include <machine/md_var.h>
83 #include <machine/specialreg.h>
84 #include <machine/smp.h>
85 #include <machine_base/apic/apicreg.h>
86 #include <machine/globaldata.h>
87 #include <machine/pmap.h>
88 #include <machine/pmap_inval.h>
89 #include <machine/inttypes.h>
90
91 #include <ddb/ddb.h>
92
93 #define PMAP_KEEP_PDIRS
94 #ifndef PMAP_SHPGPERPROC
95 #define PMAP_SHPGPERPROC 2000
96 #endif
97
98 #if defined(DIAGNOSTIC)
99 #define PMAP_DIAGNOSTIC
100 #endif
101
102 #define MINPV 2048
103
104 /*
105  * pmap debugging will report who owns a pv lock when blocking.
106  */
107 #ifdef PMAP_DEBUG
108
109 #define PMAP_DEBUG_DECL         ,const char *func, int lineno
110 #define PMAP_DEBUG_ARGS         , __func__, __LINE__
111 #define PMAP_DEBUG_COPY         , func, lineno
112
113 #define pv_get(pmap, pindex)            _pv_get(pmap, pindex            \
114                                                         PMAP_DEBUG_ARGS)
115 #define pv_lock(pv)                     _pv_lock(pv                     \
116                                                         PMAP_DEBUG_ARGS)
117 #define pv_hold_try(pv)                 _pv_hold_try(pv                 \
118                                                         PMAP_DEBUG_ARGS)
119 #define pv_alloc(pmap, pindex, isnewp)  _pv_alloc(pmap, pindex, isnewp  \
120                                                         PMAP_DEBUG_ARGS)
121
122 #else
123
124 #define PMAP_DEBUG_DECL
125 #define PMAP_DEBUG_ARGS
126 #define PMAP_DEBUG_COPY
127
128 #define pv_get(pmap, pindex)            _pv_get(pmap, pindex)
129 #define pv_lock(pv)                     _pv_lock(pv)
130 #define pv_hold_try(pv)                 _pv_hold_try(pv)
131 #define pv_alloc(pmap, pindex, isnewp)  _pv_alloc(pmap, pindex, isnewp)
132
133 #endif
134
135 /*
136  * Get PDEs and PTEs for user/kernel address space
137  */
138 #define pdir_pde(m, v) (m[(vm_offset_t)(v) >> PDRSHIFT])
139
140 #define pmap_pde_v(pte)         ((*(pd_entry_t *)pte & PG_V) != 0)
141 #define pmap_pte_w(pte)         ((*(pt_entry_t *)pte & PG_W) != 0)
142 #define pmap_pte_m(pte)         ((*(pt_entry_t *)pte & PG_M) != 0)
143 #define pmap_pte_u(pte)         ((*(pt_entry_t *)pte & PG_A) != 0)
144 #define pmap_pte_v(pte)         ((*(pt_entry_t *)pte & PG_V) != 0)
145
146 /*
147  * Given a map and a machine independent protection code,
148  * convert to a vax protection code.
149  */
150 #define pte_prot(m, p)          \
151         (protection_codes[p & (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE)])
152 static int protection_codes[8];
153
154 struct pmap kernel_pmap;
155 static TAILQ_HEAD(,pmap)        pmap_list = TAILQ_HEAD_INITIALIZER(pmap_list);
156
157 MALLOC_DEFINE(M_OBJPMAP, "objpmap", "pmaps associated with VM objects");
158
159 vm_paddr_t avail_start;         /* PA of first available physical page */
160 vm_paddr_t avail_end;           /* PA of last available physical page */
161 vm_offset_t virtual2_start;     /* cutout free area prior to kernel start */
162 vm_offset_t virtual2_end;
163 vm_offset_t virtual_start;      /* VA of first avail page (after kernel bss) */
164 vm_offset_t virtual_end;        /* VA of last avail page (end of kernel AS) */
165 vm_offset_t KvaStart;           /* VA start of KVA space */
166 vm_offset_t KvaEnd;             /* VA end of KVA space (non-inclusive) */
167 vm_offset_t KvaSize;            /* max size of kernel virtual address space */
168 static boolean_t pmap_initialized = FALSE;      /* Has pmap_init completed? */
169 static int pgeflag;             /* PG_G or-in */
170 static int pseflag;             /* PG_PS or-in */
171
172 static int ndmpdp;
173 static vm_paddr_t dmaplimit;
174 static int nkpt;
175 vm_offset_t kernel_vm_end = VM_MIN_KERNEL_ADDRESS;
176
177 static uint64_t KPTbase;
178 static uint64_t KPTphys;
179 static uint64_t KPDphys;        /* phys addr of kernel level 2 */
180 static uint64_t KPDbase;        /* phys addr of kernel level 2 @ KERNBASE */
181 uint64_t KPDPphys;      /* phys addr of kernel level 3 */
182 uint64_t KPML4phys;     /* phys addr of kernel level 4 */
183
184 static uint64_t DMPDphys;       /* phys addr of direct mapped level 2 */
185 static uint64_t DMPDPphys;      /* phys addr of direct mapped level 3 */
186
187 /*
188  * Data for the pv entry allocation mechanism
189  */
190 static vm_zone_t pvzone;
191 static struct vm_zone pvzone_store;
192 static struct vm_object pvzone_obj;
193 static int pv_entry_max=0, pv_entry_high_water=0;
194 static int pmap_pagedaemon_waken = 0;
195 static struct pv_entry *pvinit;
196
197 /*
198  * All those kernel PT submaps that BSD is so fond of
199  */
200 pt_entry_t *CMAP1 = NULL, *ptmmap;
201 caddr_t CADDR1 = NULL, ptvmmap = NULL;
202 static pt_entry_t *msgbufmap;
203 struct msgbuf *msgbufp=NULL;
204
205 /*
206  * Crashdump maps.
207  */
208 static pt_entry_t *pt_crashdumpmap;
209 static caddr_t crashdumpmap;
210
211 static int pmap_yield_count = 64;
212 SYSCTL_INT(_machdep, OID_AUTO, pmap_yield_count, CTLFLAG_RW,
213     &pmap_yield_count, 0, "Yield during init_pt/release");
214 static int pmap_mmu_optimize = 0;
215 SYSCTL_INT(_machdep, OID_AUTO, pmap_mmu_optimize, CTLFLAG_RW,
216     &pmap_mmu_optimize, 0, "Share page table pages when possible");
217
218 #define DISABLE_PSE
219
220 static void pv_hold(pv_entry_t pv);
221 static int _pv_hold_try(pv_entry_t pv
222                                 PMAP_DEBUG_DECL);
223 static void pv_drop(pv_entry_t pv);
224 static void _pv_lock(pv_entry_t pv
225                                 PMAP_DEBUG_DECL);
226 static void pv_unlock(pv_entry_t pv);
227 static pv_entry_t _pv_alloc(pmap_t pmap, vm_pindex_t pindex, int *isnew
228                                 PMAP_DEBUG_DECL);
229 static pv_entry_t _pv_get(pmap_t pmap, vm_pindex_t pindex
230                                 PMAP_DEBUG_DECL);
231 static pv_entry_t pv_get_try(pmap_t pmap, vm_pindex_t pindex, int *errorp);
232 static pv_entry_t pv_find(pmap_t pmap, vm_pindex_t pindex);
233 static void pv_put(pv_entry_t pv);
234 static void pv_free(pv_entry_t pv);
235 static void *pv_pte_lookup(pv_entry_t pv, vm_pindex_t pindex);
236 static pv_entry_t pmap_allocpte(pmap_t pmap, vm_pindex_t ptepindex,
237                       pv_entry_t *pvpp);
238 static pv_entry_t pmap_allocpte_seg(pmap_t pmap, vm_pindex_t ptepindex,
239                       pv_entry_t *pvpp, vm_map_entry_t entry, vm_offset_t va);
240 static void pmap_remove_pv_pte(pv_entry_t pv, pv_entry_t pvp,
241                       struct pmap_inval_info *info);
242 static vm_page_t pmap_remove_pv_page(pv_entry_t pv);
243 static int pmap_release_pv(pv_entry_t pv);
244
245 static void pmap_remove_callback(pmap_t pmap, struct pmap_inval_info *info,
246                       pv_entry_t pte_pv, pv_entry_t pt_pv, int sharept,
247                       vm_offset_t va, pt_entry_t *ptep, void *arg __unused);
248 static void pmap_protect_callback(pmap_t pmap, struct pmap_inval_info *info,
249                       pv_entry_t pte_pv, pv_entry_t pt_pv, int sharept,
250                       vm_offset_t va, pt_entry_t *ptep, void *arg __unused);
251
252 static void i386_protection_init (void);
253 static void create_pagetables(vm_paddr_t *firstaddr);
254 static void pmap_remove_all (vm_page_t m);
255 static boolean_t pmap_testbit (vm_page_t m, int bit);
256
257 static pt_entry_t * pmap_pte_quick (pmap_t pmap, vm_offset_t va);
258 static vm_offset_t pmap_kmem_choose(vm_offset_t addr);
259
260 static unsigned pdir4mb;
261
262 static int
263 pv_entry_compare(pv_entry_t pv1, pv_entry_t pv2)
264 {
265         if (pv1->pv_pindex < pv2->pv_pindex)
266                 return(-1);
267         if (pv1->pv_pindex > pv2->pv_pindex)
268                 return(1);
269         return(0);
270 }
271
272 RB_GENERATE2(pv_entry_rb_tree, pv_entry, pv_entry,
273              pv_entry_compare, vm_pindex_t, pv_pindex);
274
275 /*
276  * Move the kernel virtual free pointer to the next
277  * 2MB.  This is used to help improve performance
278  * by using a large (2MB) page for much of the kernel
279  * (.text, .data, .bss)
280  */
281 static
282 vm_offset_t
283 pmap_kmem_choose(vm_offset_t addr)
284 {
285         vm_offset_t newaddr = addr;
286
287         newaddr = (addr + (NBPDR - 1)) & ~(NBPDR - 1);
288         return newaddr;
289 }
290
291 /*
292  * pmap_pte_quick:
293  *
294  *      Super fast pmap_pte routine best used when scanning the pv lists.
295  *      This eliminates many course-grained invltlb calls.  Note that many of
296  *      the pv list scans are across different pmaps and it is very wasteful
297  *      to do an entire invltlb when checking a single mapping.
298  */
299 static __inline pt_entry_t *pmap_pte(pmap_t pmap, vm_offset_t va);
300
301 static
302 pt_entry_t *
303 pmap_pte_quick(pmap_t pmap, vm_offset_t va)
304 {
305         return pmap_pte(pmap, va);
306 }
307
308 /*
309  * Returns the pindex of a page table entry (representing a terminal page).
310  * There are NUPTE_TOTAL page table entries possible (a huge number)
311  *
312  * x86-64 has a 48-bit address space, where bit 47 is sign-extended out.
313  * We want to properly translate negative KVAs.
314  */
315 static __inline
316 vm_pindex_t
317 pmap_pte_pindex(vm_offset_t va)
318 {
319         return ((va >> PAGE_SHIFT) & (NUPTE_TOTAL - 1));
320 }
321
322 /*
323  * Returns the pindex of a page table.
324  */
325 static __inline
326 vm_pindex_t
327 pmap_pt_pindex(vm_offset_t va)
328 {
329         return (NUPTE_TOTAL + ((va >> PDRSHIFT) & (NUPT_TOTAL - 1)));
330 }
331
332 /*
333  * Returns the pindex of a page directory.
334  */
335 static __inline
336 vm_pindex_t
337 pmap_pd_pindex(vm_offset_t va)
338 {
339         return (NUPTE_TOTAL + NUPT_TOTAL +
340                 ((va >> PDPSHIFT) & (NUPD_TOTAL - 1)));
341 }
342
343 static __inline
344 vm_pindex_t
345 pmap_pdp_pindex(vm_offset_t va)
346 {
347         return (NUPTE_TOTAL + NUPT_TOTAL + NUPD_TOTAL +
348                 ((va >> PML4SHIFT) & (NUPDP_TOTAL - 1)));
349 }
350
351 static __inline
352 vm_pindex_t
353 pmap_pml4_pindex(void)
354 {
355         return (NUPTE_TOTAL + NUPT_TOTAL + NUPD_TOTAL + NUPDP_TOTAL);
356 }
357
358 /*
359  * Return various clipped indexes for a given VA
360  *
361  * Returns the index of a pte in a page table, representing a terminal
362  * page.
363  */
364 static __inline
365 vm_pindex_t
366 pmap_pte_index(vm_offset_t va)
367 {
368         return ((va >> PAGE_SHIFT) & ((1ul << NPTEPGSHIFT) - 1));
369 }
370
371 /*
372  * Returns the index of a pt in a page directory, representing a page
373  * table.
374  */
375 static __inline
376 vm_pindex_t
377 pmap_pt_index(vm_offset_t va)
378 {
379         return ((va >> PDRSHIFT) & ((1ul << NPDEPGSHIFT) - 1));
380 }
381
382 /*
383  * Returns the index of a pd in a page directory page, representing a page
384  * directory.
385  */
386 static __inline
387 vm_pindex_t
388 pmap_pd_index(vm_offset_t va)
389 {
390         return ((va >> PDPSHIFT) & ((1ul << NPDPEPGSHIFT) - 1));
391 }
392
393 /*
394  * Returns the index of a pdp in the pml4 table, representing a page
395  * directory page.
396  */
397 static __inline
398 vm_pindex_t
399 pmap_pdp_index(vm_offset_t va)
400 {
401         return ((va >> PML4SHIFT) & ((1ul << NPML4EPGSHIFT) - 1));
402 }
403
404 /*
405  * Generic procedure to index a pte from a pt, pd, or pdp.
406  *
407  * NOTE: Normally passed pindex as pmap_xx_index().  pmap_xx_pindex() is NOT
408  *       a page table page index but is instead of PV lookup index.
409  */
410 static
411 void *
412 pv_pte_lookup(pv_entry_t pv, vm_pindex_t pindex)
413 {
414         pt_entry_t *pte;
415
416         pte = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pv->pv_m));
417         return(&pte[pindex]);
418 }
419
420 /*
421  * Return pointer to PDP slot in the PML4
422  */
423 static __inline
424 pml4_entry_t *
425 pmap_pdp(pmap_t pmap, vm_offset_t va)
426 {
427         return (&pmap->pm_pml4[pmap_pdp_index(va)]);
428 }
429
430 /*
431  * Return pointer to PD slot in the PDP given a pointer to the PDP
432  */
433 static __inline
434 pdp_entry_t *
435 pmap_pdp_to_pd(pml4_entry_t *pdp, vm_offset_t va)
436 {
437         pdp_entry_t *pd;
438
439         pd = (pdp_entry_t *)PHYS_TO_DMAP(*pdp & PG_FRAME);
440         return (&pd[pmap_pd_index(va)]);
441 }
442
443 /*
444  * Return pointer to PD slot in the PDP
445  **/
446 static __inline
447 pdp_entry_t *
448 pmap_pd(pmap_t pmap, vm_offset_t va)
449 {
450         pml4_entry_t *pdp;
451
452         pdp = pmap_pdp(pmap, va);
453         if ((*pdp & PG_V) == 0)
454                 return NULL;
455         return (pmap_pdp_to_pd(pdp, va));
456 }
457
458 /*
459  * Return pointer to PT slot in the PD given a pointer to the PD
460  */
461 static __inline
462 pd_entry_t *
463 pmap_pd_to_pt(pdp_entry_t *pd, vm_offset_t va)
464 {
465         pd_entry_t *pt;
466
467         pt = (pd_entry_t *)PHYS_TO_DMAP(*pd & PG_FRAME);
468         return (&pt[pmap_pt_index(va)]);
469 }
470
471 /*
472  * Return pointer to PT slot in the PD
473  */
474 static __inline
475 pd_entry_t *
476 pmap_pt(pmap_t pmap, vm_offset_t va)
477 {
478         pdp_entry_t *pd;
479
480         pd = pmap_pd(pmap, va);
481         if (pd == NULL || (*pd & PG_V) == 0)
482                  return NULL;
483         return (pmap_pd_to_pt(pd, va));
484 }
485
486 /*
487  * Return pointer to PTE slot in the PT given a pointer to the PT
488  */
489 static __inline
490 pt_entry_t *
491 pmap_pt_to_pte(pd_entry_t *pt, vm_offset_t va)
492 {
493         pt_entry_t *pte;
494
495         pte = (pt_entry_t *)PHYS_TO_DMAP(*pt & PG_FRAME);
496         return (&pte[pmap_pte_index(va)]);
497 }
498
499 /*
500  * Return pointer to PTE slot in the PT
501  */
502 static __inline
503 pt_entry_t *
504 pmap_pte(pmap_t pmap, vm_offset_t va)
505 {
506         pd_entry_t *pt;
507
508         pt = pmap_pt(pmap, va);
509         if (pt == NULL || (*pt & PG_V) == 0)
510                  return NULL;
511         if ((*pt & PG_PS) != 0)
512                 return ((pt_entry_t *)pt);
513         return (pmap_pt_to_pte(pt, va));
514 }
515
516 /*
517  * Of all the layers (PTE, PT, PD, PDP, PML4) the best one to cache is
518  * the PT layer.  This will speed up core pmap operations considerably.
519  */
520 static __inline
521 void
522 pv_cache(pv_entry_t pv, vm_pindex_t pindex)
523 {
524         if (pindex >= pmap_pt_pindex(0) && pindex <= pmap_pd_pindex(0))
525                 pv->pv_pmap->pm_pvhint = pv;
526 }
527
528
529 /*
530  * KVM - return address of PT slot in PD
531  */
532 static __inline
533 pd_entry_t *
534 vtopt(vm_offset_t va)
535 {
536         uint64_t mask = ((1ul << (NPDEPGSHIFT + NPDPEPGSHIFT +
537                                   NPML4EPGSHIFT)) - 1);
538
539         return (PDmap + ((va >> PDRSHIFT) & mask));
540 }
541
542 /*
543  * KVM - return address of PTE slot in PT
544  */
545 static __inline
546 pt_entry_t *
547 vtopte(vm_offset_t va)
548 {
549         uint64_t mask = ((1ul << (NPTEPGSHIFT + NPDEPGSHIFT +
550                                   NPDPEPGSHIFT + NPML4EPGSHIFT)) - 1);
551
552         return (PTmap + ((va >> PAGE_SHIFT) & mask));
553 }
554
555 static uint64_t
556 allocpages(vm_paddr_t *firstaddr, long n)
557 {
558         uint64_t ret;
559
560         ret = *firstaddr;
561         bzero((void *)ret, n * PAGE_SIZE);
562         *firstaddr += n * PAGE_SIZE;
563         return (ret);
564 }
565
566 static
567 void
568 create_pagetables(vm_paddr_t *firstaddr)
569 {
570         long i;         /* must be 64 bits */
571         long nkpt_base;
572         long nkpt_phys;
573         int j;
574
575         /*
576          * We are running (mostly) V=P at this point
577          *
578          * Calculate NKPT - number of kernel page tables.  We have to
579          * accomodoate prealloction of the vm_page_array, dump bitmap,
580          * MSGBUF_SIZE, and other stuff.  Be generous.
581          *
582          * Maxmem is in pages.
583          *
584          * ndmpdp is the number of 1GB pages we wish to map.
585          */
586         ndmpdp = (ptoa(Maxmem) + NBPDP - 1) >> PDPSHIFT;
587         if (ndmpdp < 4)         /* Minimum 4GB of dirmap */
588                 ndmpdp = 4;
589         KKASSERT(ndmpdp <= NKPDPE * NPDEPG);
590
591         /*
592          * Starting at the beginning of kvm (not KERNBASE).
593          */
594         nkpt_phys = (Maxmem * sizeof(struct vm_page) + NBPDR - 1) / NBPDR;
595         nkpt_phys += (Maxmem * sizeof(struct pv_entry) + NBPDR - 1) / NBPDR;
596         nkpt_phys += ((nkpt + nkpt + 1 + NKPML4E + NKPDPE + NDMPML4E +
597                        ndmpdp) + 511) / 512;
598         nkpt_phys += 128;
599
600         /*
601          * Starting at KERNBASE - map 2G worth of page table pages.
602          * KERNBASE is offset -2G from the end of kvm.
603          */
604         nkpt_base = (NPDPEPG - KPDPI) * NPTEPG; /* typically 2 x 512 */
605
606         /*
607          * Allocate pages
608          */
609         KPTbase = allocpages(firstaddr, nkpt_base);
610         KPTphys = allocpages(firstaddr, nkpt_phys);
611         KPML4phys = allocpages(firstaddr, 1);
612         KPDPphys = allocpages(firstaddr, NKPML4E);
613         KPDphys = allocpages(firstaddr, NKPDPE);
614
615         /*
616          * Calculate the page directory base for KERNBASE,
617          * that is where we start populating the page table pages.
618          * Basically this is the end - 2.
619          */
620         KPDbase = KPDphys + ((NKPDPE - (NPDPEPG - KPDPI)) << PAGE_SHIFT);
621
622         DMPDPphys = allocpages(firstaddr, NDMPML4E);
623         if ((amd_feature & AMDID_PAGE1GB) == 0)
624                 DMPDphys = allocpages(firstaddr, ndmpdp);
625         dmaplimit = (vm_paddr_t)ndmpdp << PDPSHIFT;
626
627         /*
628          * Fill in the underlying page table pages for the area around
629          * KERNBASE.  This remaps low physical memory to KERNBASE.
630          *
631          * Read-only from zero to physfree
632          * XXX not fully used, underneath 2M pages
633          */
634         for (i = 0; (i << PAGE_SHIFT) < *firstaddr; i++) {
635                 ((pt_entry_t *)KPTbase)[i] = i << PAGE_SHIFT;
636                 ((pt_entry_t *)KPTbase)[i] |= PG_RW | PG_V | PG_G;
637         }
638
639         /*
640          * Now map the initial kernel page tables.  One block of page
641          * tables is placed at the beginning of kernel virtual memory,
642          * and another block is placed at KERNBASE to map the kernel binary,
643          * data, bss, and initial pre-allocations.
644          */
645         for (i = 0; i < nkpt_base; i++) {
646                 ((pd_entry_t *)KPDbase)[i] = KPTbase + (i << PAGE_SHIFT);
647                 ((pd_entry_t *)KPDbase)[i] |= PG_RW | PG_V;
648         }
649         for (i = 0; i < nkpt_phys; i++) {
650                 ((pd_entry_t *)KPDphys)[i] = KPTphys + (i << PAGE_SHIFT);
651                 ((pd_entry_t *)KPDphys)[i] |= PG_RW | PG_V;
652         }
653
654         /*
655          * Map from zero to end of allocations using 2M pages as an
656          * optimization.  This will bypass some of the KPTBase pages
657          * above in the KERNBASE area.
658          */
659         for (i = 0; (i << PDRSHIFT) < *firstaddr; i++) {
660                 ((pd_entry_t *)KPDbase)[i] = i << PDRSHIFT;
661                 ((pd_entry_t *)KPDbase)[i] |= PG_RW | PG_V | PG_PS | PG_G;
662         }
663
664         /*
665          * And connect up the PD to the PDP.  The kernel pmap is expected
666          * to pre-populate all of its PDs.  See NKPDPE in vmparam.h.
667          */
668         for (i = 0; i < NKPDPE; i++) {
669                 ((pdp_entry_t *)KPDPphys)[NPDPEPG - NKPDPE + i] =
670                                 KPDphys + (i << PAGE_SHIFT);
671                 ((pdp_entry_t *)KPDPphys)[NPDPEPG - NKPDPE + i] |=
672                                 PG_RW | PG_V | PG_U;
673         }
674
675         /*
676          * Now set up the direct map space using either 2MB or 1GB pages
677          * Preset PG_M and PG_A because demotion expects it.
678          *
679          * When filling in entries in the PD pages make sure any excess
680          * entries are set to zero as we allocated enough PD pages
681          */
682         if ((amd_feature & AMDID_PAGE1GB) == 0) {
683                 for (i = 0; i < NPDEPG * ndmpdp; i++) {
684                         ((pd_entry_t *)DMPDphys)[i] = i << PDRSHIFT;
685                         ((pd_entry_t *)DMPDphys)[i] |= PG_RW | PG_V | PG_PS |
686                                                        PG_G | PG_M | PG_A;
687                 }
688
689                 /*
690                  * And the direct map space's PDP
691                  */
692                 for (i = 0; i < ndmpdp; i++) {
693                         ((pdp_entry_t *)DMPDPphys)[i] = DMPDphys +
694                                                         (i << PAGE_SHIFT);
695                         ((pdp_entry_t *)DMPDPphys)[i] |= PG_RW | PG_V | PG_U;
696                 }
697         } else {
698                 for (i = 0; i < ndmpdp; i++) {
699                         ((pdp_entry_t *)DMPDPphys)[i] =
700                                                 (vm_paddr_t)i << PDPSHIFT;
701                         ((pdp_entry_t *)DMPDPphys)[i] |= PG_RW | PG_V | PG_PS |
702                                                          PG_G | PG_M | PG_A;
703                 }
704         }
705
706         /* And recursively map PML4 to itself in order to get PTmap */
707         ((pdp_entry_t *)KPML4phys)[PML4PML4I] = KPML4phys;
708         ((pdp_entry_t *)KPML4phys)[PML4PML4I] |= PG_RW | PG_V | PG_U;
709
710         /*
711          * Connect the Direct Map slots up to the PML4
712          */
713         for (j = 0; j < NDMPML4E; ++j) {
714                 ((pdp_entry_t *)KPML4phys)[DMPML4I + j] =
715                         (DMPDPphys + ((vm_paddr_t)j << PML4SHIFT)) |
716                         PG_RW | PG_V | PG_U;
717         }
718
719         /*
720          * Connect the KVA slot up to the PML4
721          */
722         ((pdp_entry_t *)KPML4phys)[KPML4I] = KPDPphys;
723         ((pdp_entry_t *)KPML4phys)[KPML4I] |= PG_RW | PG_V | PG_U;
724 }
725
726 /*
727  *      Bootstrap the system enough to run with virtual memory.
728  *
729  *      On the i386 this is called after mapping has already been enabled
730  *      and just syncs the pmap module with what has already been done.
731  *      [We can't call it easily with mapping off since the kernel is not
732  *      mapped with PA == VA, hence we would have to relocate every address
733  *      from the linked base (virtual) address "KERNBASE" to the actual
734  *      (physical) address starting relative to 0]
735  */
736 void
737 pmap_bootstrap(vm_paddr_t *firstaddr)
738 {
739         vm_offset_t va;
740         pt_entry_t *pte;
741         struct mdglobaldata *gd;
742         int pg;
743
744         KvaStart = VM_MIN_KERNEL_ADDRESS;
745         KvaEnd = VM_MAX_KERNEL_ADDRESS;
746         KvaSize = KvaEnd - KvaStart;
747
748         avail_start = *firstaddr;
749
750         /*
751          * Create an initial set of page tables to run the kernel in.
752          */
753         create_pagetables(firstaddr);
754
755         virtual2_start = KvaStart;
756         virtual2_end = PTOV_OFFSET;
757
758         virtual_start = (vm_offset_t) PTOV_OFFSET + *firstaddr;
759         virtual_start = pmap_kmem_choose(virtual_start);
760
761         virtual_end = VM_MAX_KERNEL_ADDRESS;
762
763         /* XXX do %cr0 as well */
764         load_cr4(rcr4() | CR4_PGE | CR4_PSE);
765         load_cr3(KPML4phys);
766
767         /*
768          * Initialize protection array.
769          */
770         i386_protection_init();
771
772         /*
773          * The kernel's pmap is statically allocated so we don't have to use
774          * pmap_create, which is unlikely to work correctly at this part of
775          * the boot sequence (XXX and which no longer exists).
776          */
777         kernel_pmap.pm_pml4 = (pdp_entry_t *) (PTOV_OFFSET + KPML4phys);
778         kernel_pmap.pm_count = 1;
779         kernel_pmap.pm_active = (cpumask_t)-1 & ~CPUMASK_LOCK;
780         RB_INIT(&kernel_pmap.pm_pvroot);
781         spin_init(&kernel_pmap.pm_spin);
782         lwkt_token_init(&kernel_pmap.pm_token, "kpmap_tok");
783
784         /*
785          * Reserve some special page table entries/VA space for temporary
786          * mapping of pages.
787          */
788 #define SYSMAP(c, p, v, n)      \
789         v = (c)va; va += ((n)*PAGE_SIZE); p = pte; pte += (n);
790
791         va = virtual_start;
792         pte = vtopte(va);
793
794         /*
795          * CMAP1/CMAP2 are used for zeroing and copying pages.
796          */
797         SYSMAP(caddr_t, CMAP1, CADDR1, 1)
798
799         /*
800          * Crashdump maps.
801          */
802         SYSMAP(caddr_t, pt_crashdumpmap, crashdumpmap, MAXDUMPPGS);
803
804         /*
805          * ptvmmap is used for reading arbitrary physical pages via
806          * /dev/mem.
807          */
808         SYSMAP(caddr_t, ptmmap, ptvmmap, 1)
809
810         /*
811          * msgbufp is used to map the system message buffer.
812          * XXX msgbufmap is not used.
813          */
814         SYSMAP(struct msgbuf *, msgbufmap, msgbufp,
815                atop(round_page(MSGBUF_SIZE)))
816
817         virtual_start = va;
818
819         *CMAP1 = 0;
820
821         /*
822          * PG_G is terribly broken on SMP because we IPI invltlb's in some
823          * cases rather then invl1pg.  Actually, I don't even know why it
824          * works under UP because self-referential page table mappings
825          */
826 #ifdef SMP
827         pgeflag = 0;
828 #else
829         if (cpu_feature & CPUID_PGE)
830                 pgeflag = PG_G;
831 #endif
832         
833 /*
834  * Initialize the 4MB page size flag
835  */
836         pseflag = 0;
837 /*
838  * The 4MB page version of the initial
839  * kernel page mapping.
840  */
841         pdir4mb = 0;
842
843 #if !defined(DISABLE_PSE)
844         if (cpu_feature & CPUID_PSE) {
845                 pt_entry_t ptditmp;
846                 /*
847                  * Note that we have enabled PSE mode
848                  */
849                 pseflag = PG_PS;
850                 ptditmp = *(PTmap + x86_64_btop(KERNBASE));
851                 ptditmp &= ~(NBPDR - 1);
852                 ptditmp |= PG_V | PG_RW | PG_PS | PG_U | pgeflag;
853                 pdir4mb = ptditmp;
854
855 #ifndef SMP
856                 /*
857                  * Enable the PSE mode.  If we are SMP we can't do this
858                  * now because the APs will not be able to use it when
859                  * they boot up.
860                  */
861                 load_cr4(rcr4() | CR4_PSE);
862
863                 /*
864                  * We can do the mapping here for the single processor
865                  * case.  We simply ignore the old page table page from
866                  * now on.
867                  */
868                 /*
869                  * For SMP, we still need 4K pages to bootstrap APs,
870                  * PSE will be enabled as soon as all APs are up.
871                  */
872                 PTD[KPTDI] = (pd_entry_t)ptditmp;
873                 cpu_invltlb();
874 #endif
875         }
876 #endif
877
878         /*
879          * We need to finish setting up the globaldata page for the BSP.
880          * locore has already populated the page table for the mdglobaldata
881          * portion.
882          */
883         pg = MDGLOBALDATA_BASEALLOC_PAGES;
884         gd = &CPU_prvspace[0].mdglobaldata;
885
886         cpu_invltlb();
887 }
888
889 #ifdef SMP
890 /*
891  * Set 4mb pdir for mp startup
892  */
893 void
894 pmap_set_opt(void)
895 {
896         if (pseflag && (cpu_feature & CPUID_PSE)) {
897                 load_cr4(rcr4() | CR4_PSE);
898                 if (pdir4mb && mycpu->gd_cpuid == 0) {  /* only on BSP */
899                         cpu_invltlb();
900                 }
901         }
902 }
903 #endif
904
905 /*
906  *      Initialize the pmap module.
907  *      Called by vm_init, to initialize any structures that the pmap
908  *      system needs to map virtual memory.
909  *      pmap_init has been enhanced to support in a fairly consistant
910  *      way, discontiguous physical memory.
911  */
912 void
913 pmap_init(void)
914 {
915         int i;
916         int initial_pvs;
917
918         /*
919          * Allocate memory for random pmap data structures.  Includes the
920          * pv_head_table.
921          */
922
923         for (i = 0; i < vm_page_array_size; i++) {
924                 vm_page_t m;
925
926                 m = &vm_page_array[i];
927                 TAILQ_INIT(&m->md.pv_list);
928         }
929
930         /*
931          * init the pv free list
932          */
933         initial_pvs = vm_page_array_size;
934         if (initial_pvs < MINPV)
935                 initial_pvs = MINPV;
936         pvzone = &pvzone_store;
937         pvinit = (void *)kmem_alloc(&kernel_map,
938                                     initial_pvs * sizeof (struct pv_entry));
939         zbootinit(pvzone, "PV ENTRY", sizeof (struct pv_entry),
940                   pvinit, initial_pvs);
941
942         /*
943          * Now it is safe to enable pv_table recording.
944          */
945         pmap_initialized = TRUE;
946 }
947
948 /*
949  * Initialize the address space (zone) for the pv_entries.  Set a
950  * high water mark so that the system can recover from excessive
951  * numbers of pv entries.
952  */
953 void
954 pmap_init2(void)
955 {
956         int shpgperproc = PMAP_SHPGPERPROC;
957         int entry_max;
958
959         TUNABLE_INT_FETCH("vm.pmap.shpgperproc", &shpgperproc);
960         pv_entry_max = shpgperproc * maxproc + vm_page_array_size;
961         TUNABLE_INT_FETCH("vm.pmap.pv_entries", &pv_entry_max);
962         pv_entry_high_water = 9 * (pv_entry_max / 10);
963
964         /*
965          * Subtract out pages already installed in the zone (hack)
966          */
967         entry_max = pv_entry_max - vm_page_array_size;
968         if (entry_max <= 0)
969                 entry_max = 1;
970
971         zinitna(pvzone, &pvzone_obj, NULL, 0, entry_max, ZONE_INTERRUPT, 1);
972 }
973
974
975 /***************************************************
976  * Low level helper routines.....
977  ***************************************************/
978
979 /*
980  * this routine defines the region(s) of memory that should
981  * not be tested for the modified bit.
982  */
983 static __inline
984 int
985 pmap_track_modified(vm_pindex_t pindex)
986 {
987         vm_offset_t va = (vm_offset_t)pindex << PAGE_SHIFT;
988         if ((va < clean_sva) || (va >= clean_eva)) 
989                 return 1;
990         else
991                 return 0;
992 }
993
994 /*
995  * Extract the physical page address associated with the map/VA pair.
996  * The page must be wired for this to work reliably.
997  *
998  * XXX for the moment we're using pv_find() instead of pv_get(), as
999  *     callers might be expecting non-blocking operation.
1000  */
1001 vm_paddr_t 
1002 pmap_extract(pmap_t pmap, vm_offset_t va)
1003 {
1004         vm_paddr_t rtval;
1005         pv_entry_t pt_pv;
1006         pt_entry_t *ptep;
1007
1008         rtval = 0;
1009         if (va >= VM_MAX_USER_ADDRESS) {
1010                 /*
1011                  * Kernel page directories might be direct-mapped and
1012                  * there is typically no PV tracking of pte's
1013                  */
1014                 pd_entry_t *pt;
1015
1016                 pt = pmap_pt(pmap, va);
1017                 if (pt && (*pt & PG_V)) {
1018                         if (*pt & PG_PS) {
1019                                 rtval = *pt & PG_PS_FRAME;
1020                                 rtval |= va & PDRMASK;
1021                         } else {
1022                                 ptep = pmap_pt_to_pte(pt, va);
1023                                 if (*pt & PG_V) {
1024                                         rtval = *ptep & PG_FRAME;
1025                                         rtval |= va & PAGE_MASK;
1026                                 }
1027                         }
1028                 }
1029         } else {
1030                 /*
1031                  * User pages currently do not direct-map the page directory
1032                  * and some pages might not used managed PVs.  But all PT's
1033                  * will have a PV.
1034                  */
1035                 pt_pv = pv_find(pmap, pmap_pt_pindex(va));
1036                 if (pt_pv) {
1037                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(va));
1038                         if (*ptep & PG_V) {
1039                                 rtval = *ptep & PG_FRAME;
1040                                 rtval |= va & PAGE_MASK;
1041                         }
1042                         pv_drop(pt_pv);
1043                 }
1044         }
1045         return rtval;
1046 }
1047
1048 /*
1049  * Extract the physical page address associated kernel virtual address.
1050  */
1051 vm_paddr_t
1052 pmap_kextract(vm_offset_t va)
1053 {
1054         pd_entry_t pt;          /* pt entry in pd */
1055         vm_paddr_t pa;
1056
1057         if (va >= DMAP_MIN_ADDRESS && va < DMAP_MAX_ADDRESS) {
1058                 pa = DMAP_TO_PHYS(va);
1059         } else {
1060                 pt = *vtopt(va);
1061                 if (pt & PG_PS) {
1062                         pa = (pt & PG_PS_FRAME) | (va & PDRMASK);
1063                 } else {
1064                         /*
1065                          * Beware of a concurrent promotion that changes the
1066                          * PDE at this point!  For example, vtopte() must not
1067                          * be used to access the PTE because it would use the
1068                          * new PDE.  It is, however, safe to use the old PDE
1069                          * because the page table page is preserved by the
1070                          * promotion.
1071                          */
1072                         pa = *pmap_pt_to_pte(&pt, va);
1073                         pa = (pa & PG_FRAME) | (va & PAGE_MASK);
1074                 }
1075         }
1076         return pa;
1077 }
1078
1079 /***************************************************
1080  * Low level mapping routines.....
1081  ***************************************************/
1082
1083 /*
1084  * Routine: pmap_kenter
1085  * Function:
1086  *      Add a wired page to the KVA
1087  *      NOTE! note that in order for the mapping to take effect -- you
1088  *      should do an invltlb after doing the pmap_kenter().
1089  */
1090 void 
1091 pmap_kenter(vm_offset_t va, vm_paddr_t pa)
1092 {
1093         pt_entry_t *pte;
1094         pt_entry_t npte;
1095         pmap_inval_info info;
1096
1097         pmap_inval_init(&info);                         /* XXX remove */
1098         npte = pa | PG_RW | PG_V | pgeflag;
1099         pte = vtopte(va);
1100         pmap_inval_interlock(&info, &kernel_pmap, va);  /* XXX remove */
1101         *pte = npte;
1102         pmap_inval_deinterlock(&info, &kernel_pmap);    /* XXX remove */
1103         pmap_inval_done(&info);                         /* XXX remove */
1104 }
1105
1106 /*
1107  * Routine: pmap_kenter_quick
1108  * Function:
1109  *      Similar to pmap_kenter(), except we only invalidate the
1110  *      mapping on the current CPU.
1111  */
1112 void
1113 pmap_kenter_quick(vm_offset_t va, vm_paddr_t pa)
1114 {
1115         pt_entry_t *pte;
1116         pt_entry_t npte;
1117
1118         npte = pa | PG_RW | PG_V | pgeflag;
1119         pte = vtopte(va);
1120         *pte = npte;
1121         cpu_invlpg((void *)va);
1122 }
1123
1124 void
1125 pmap_kenter_sync(vm_offset_t va)
1126 {
1127         pmap_inval_info info;
1128
1129         pmap_inval_init(&info);
1130         pmap_inval_interlock(&info, &kernel_pmap, va);
1131         pmap_inval_deinterlock(&info, &kernel_pmap);
1132         pmap_inval_done(&info);
1133 }
1134
1135 void
1136 pmap_kenter_sync_quick(vm_offset_t va)
1137 {
1138         cpu_invlpg((void *)va);
1139 }
1140
1141 /*
1142  * remove a page from the kernel pagetables
1143  */
1144 void
1145 pmap_kremove(vm_offset_t va)
1146 {
1147         pt_entry_t *pte;
1148         pmap_inval_info info;
1149
1150         pmap_inval_init(&info);
1151         pte = vtopte(va);
1152         pmap_inval_interlock(&info, &kernel_pmap, va);
1153         (void)pte_load_clear(pte);
1154         pmap_inval_deinterlock(&info, &kernel_pmap);
1155         pmap_inval_done(&info);
1156 }
1157
1158 void
1159 pmap_kremove_quick(vm_offset_t va)
1160 {
1161         pt_entry_t *pte;
1162         pte = vtopte(va);
1163         (void)pte_load_clear(pte);
1164         cpu_invlpg((void *)va);
1165 }
1166
1167 /*
1168  * XXX these need to be recoded.  They are not used in any critical path.
1169  */
1170 void
1171 pmap_kmodify_rw(vm_offset_t va)
1172 {
1173         atomic_set_long(vtopte(va), PG_RW);
1174         cpu_invlpg((void *)va);
1175 }
1176
1177 void
1178 pmap_kmodify_nc(vm_offset_t va)
1179 {
1180         atomic_set_long(vtopte(va), PG_N);
1181         cpu_invlpg((void *)va);
1182 }
1183
1184 /*
1185  * Used to map a range of physical addresses into kernel virtual
1186  * address space during the low level boot, typically to map the
1187  * dump bitmap, message buffer, and vm_page_array.
1188  *
1189  * These mappings are typically made at some pointer after the end of the
1190  * kernel text+data.
1191  *
1192  * We could return PHYS_TO_DMAP(start) here and not allocate any
1193  * via (*virtp), but then kmem from userland and kernel dumps won't
1194  * have access to the related pointers.
1195  */
1196 vm_offset_t
1197 pmap_map(vm_offset_t *virtp, vm_paddr_t start, vm_paddr_t end, int prot)
1198 {
1199         vm_offset_t va;
1200         vm_offset_t va_start;
1201
1202         /*return PHYS_TO_DMAP(start);*/
1203
1204         va_start = *virtp;
1205         va = va_start;
1206
1207         while (start < end) {
1208                 pmap_kenter_quick(va, start);
1209                 va += PAGE_SIZE;
1210                 start += PAGE_SIZE;
1211         }
1212         *virtp = va;
1213         return va_start;
1214 }
1215
1216
1217 /*
1218  * Add a list of wired pages to the kva
1219  * this routine is only used for temporary
1220  * kernel mappings that do not need to have
1221  * page modification or references recorded.
1222  * Note that old mappings are simply written
1223  * over.  The page *must* be wired.
1224  */
1225 void
1226 pmap_qenter(vm_offset_t va, vm_page_t *m, int count)
1227 {
1228         vm_offset_t end_va;
1229
1230         end_va = va + count * PAGE_SIZE;
1231                 
1232         while (va < end_va) {
1233                 pt_entry_t *pte;
1234
1235                 pte = vtopte(va);
1236                 *pte = VM_PAGE_TO_PHYS(*m) | PG_RW | PG_V | pgeflag;
1237                 cpu_invlpg((void *)va);
1238                 va += PAGE_SIZE;
1239                 m++;
1240         }
1241         smp_invltlb();
1242 }
1243
1244 /*
1245  * This routine jerks page mappings from the
1246  * kernel -- it is meant only for temporary mappings.
1247  *
1248  * MPSAFE, INTERRUPT SAFE (cluster callback)
1249  */
1250 void
1251 pmap_qremove(vm_offset_t va, int count)
1252 {
1253         vm_offset_t end_va;
1254
1255         end_va = va + count * PAGE_SIZE;
1256
1257         while (va < end_va) {
1258                 pt_entry_t *pte;
1259
1260                 pte = vtopte(va);
1261                 (void)pte_load_clear(pte);
1262                 cpu_invlpg((void *)va);
1263                 va += PAGE_SIZE;
1264         }
1265         smp_invltlb();
1266 }
1267
1268 /*
1269  * Create a new thread and optionally associate it with a (new) process.
1270  * NOTE! the new thread's cpu may not equal the current cpu.
1271  */
1272 void
1273 pmap_init_thread(thread_t td)
1274 {
1275         /* enforce pcb placement & alignment */
1276         td->td_pcb = (struct pcb *)(td->td_kstack + td->td_kstack_size) - 1;
1277         td->td_pcb = (struct pcb *)((intptr_t)td->td_pcb & ~(intptr_t)0xF);
1278         td->td_savefpu = &td->td_pcb->pcb_save;
1279         td->td_sp = (char *)td->td_pcb; /* no -16 */
1280 }
1281
1282 /*
1283  * This routine directly affects the fork perf for a process.
1284  */
1285 void
1286 pmap_init_proc(struct proc *p)
1287 {
1288 }
1289
1290 /*
1291  * Initialize pmap0/vmspace0.  This pmap is not added to pmap_list because
1292  * it, and IdlePTD, represents the template used to update all other pmaps.
1293  *
1294  * On architectures where the kernel pmap is not integrated into the user
1295  * process pmap, this pmap represents the process pmap, not the kernel pmap.
1296  * kernel_pmap should be used to directly access the kernel_pmap.
1297  */
1298 void
1299 pmap_pinit0(struct pmap *pmap)
1300 {
1301         pmap->pm_pml4 = (pml4_entry_t *)(PTOV_OFFSET + KPML4phys);
1302         pmap->pm_count = 1;
1303         pmap->pm_active = 0;
1304         pmap->pm_pvhint = NULL;
1305         RB_INIT(&pmap->pm_pvroot);
1306         spin_init(&pmap->pm_spin);
1307         lwkt_token_init(&pmap->pm_token, "pmap_tok");
1308         bzero(&pmap->pm_stats, sizeof pmap->pm_stats);
1309 }
1310
1311 /*
1312  * Initialize a preallocated and zeroed pmap structure,
1313  * such as one in a vmspace structure.
1314  */
1315 static void
1316 pmap_pinit_simple(struct pmap *pmap)
1317 {
1318         /*
1319          * Misc initialization
1320          */
1321         pmap->pm_count = 1;
1322         pmap->pm_active = 0;
1323         pmap->pm_pvhint = NULL;
1324         pmap->pm_flags = PMAP_FLAG_SIMPLE;
1325
1326         /*
1327          * Don't blow up locks/tokens on re-use (XXX fix/use drop code
1328          * for this).
1329          */
1330         if (pmap->pm_pmlpv == NULL) {
1331                 RB_INIT(&pmap->pm_pvroot);
1332                 bzero(&pmap->pm_stats, sizeof pmap->pm_stats);
1333                 spin_init(&pmap->pm_spin);
1334                 lwkt_token_init(&pmap->pm_token, "pmap_tok");
1335         }
1336 }
1337
1338 void
1339 pmap_pinit(struct pmap *pmap)
1340 {
1341         pv_entry_t pv;
1342         int j;
1343
1344         pmap_pinit_simple(pmap);
1345         pmap->pm_flags &= ~PMAP_FLAG_SIMPLE;
1346
1347         /*
1348          * No need to allocate page table space yet but we do need a valid
1349          * page directory table.
1350          */
1351         if (pmap->pm_pml4 == NULL) {
1352                 pmap->pm_pml4 =
1353                     (pml4_entry_t *)kmem_alloc_pageable(&kernel_map, PAGE_SIZE);
1354         }
1355
1356         /*
1357          * Allocate the page directory page, which wires it even though
1358          * it isn't being entered into some higher level page table (it
1359          * being the highest level).  If one is already cached we don't
1360          * have to do anything.
1361          */
1362         if ((pv = pmap->pm_pmlpv) == NULL) {
1363                 pv = pmap_allocpte(pmap, pmap_pml4_pindex(), NULL);
1364                 pmap->pm_pmlpv = pv;
1365                 pmap_kenter((vm_offset_t)pmap->pm_pml4,
1366                             VM_PAGE_TO_PHYS(pv->pv_m));
1367                 pv_put(pv);
1368
1369                 /*
1370                  * Install DMAP and KMAP.
1371                  */
1372                 for (j = 0; j < NDMPML4E; ++j) {
1373                         pmap->pm_pml4[DMPML4I + j] =
1374                                 (DMPDPphys + ((vm_paddr_t)j << PML4SHIFT)) |
1375                                 PG_RW | PG_V | PG_U;
1376                 }
1377                 pmap->pm_pml4[KPML4I] = KPDPphys | PG_RW | PG_V | PG_U;
1378
1379                 /*
1380                  * install self-referential address mapping entry
1381                  */
1382                 pmap->pm_pml4[PML4PML4I] = VM_PAGE_TO_PHYS(pv->pv_m) |
1383                                            PG_V | PG_RW | PG_A | PG_M;
1384         } else {
1385                 KKASSERT(pv->pv_m->flags & PG_MAPPED);
1386                 KKASSERT(pv->pv_m->flags & PG_WRITEABLE);
1387         }
1388         KKASSERT(pmap->pm_pml4[255] == 0);
1389         KKASSERT(RB_ROOT(&pmap->pm_pvroot) == pv);
1390         KKASSERT(pv->pv_entry.rbe_left == NULL);
1391         KKASSERT(pv->pv_entry.rbe_right == NULL);
1392 }
1393
1394 /*
1395  * Clean up a pmap structure so it can be physically freed.  This routine
1396  * is called by the vmspace dtor function.  A great deal of pmap data is
1397  * left passively mapped to improve vmspace management so we have a bit
1398  * of cleanup work to do here.
1399  */
1400 void
1401 pmap_puninit(pmap_t pmap)
1402 {
1403         pv_entry_t pv;
1404         vm_page_t p;
1405
1406         KKASSERT(pmap->pm_active == 0);
1407         if ((pv = pmap->pm_pmlpv) != NULL) {
1408                 if (pv_hold_try(pv) == 0)
1409                         pv_lock(pv);
1410                 p = pmap_remove_pv_page(pv);
1411                 pv_free(pv);
1412                 pmap_kremove((vm_offset_t)pmap->pm_pml4);
1413                 vm_page_busy_wait(p, FALSE, "pgpun");
1414                 KKASSERT(p->flags & (PG_FICTITIOUS|PG_UNMANAGED));
1415                 vm_page_unwire(p, 0);
1416                 vm_page_flag_clear(p, PG_MAPPED | PG_WRITEABLE);
1417
1418                 /*
1419                  * XXX eventually clean out PML4 static entries and
1420                  * use vm_page_free_zero()
1421                  */
1422                 vm_page_free(p);
1423                 pmap->pm_pmlpv = NULL;
1424         }
1425         if (pmap->pm_pml4) {
1426                 KKASSERT(pmap->pm_pml4 != (void *)(PTOV_OFFSET + KPML4phys));
1427                 kmem_free(&kernel_map, (vm_offset_t)pmap->pm_pml4, PAGE_SIZE);
1428                 pmap->pm_pml4 = NULL;
1429         }
1430         KKASSERT(pmap->pm_stats.resident_count == 0);
1431         KKASSERT(pmap->pm_stats.wired_count == 0);
1432 }
1433
1434 /*
1435  * Wire in kernel global address entries.  To avoid a race condition
1436  * between pmap initialization and pmap_growkernel, this procedure
1437  * adds the pmap to the master list (which growkernel scans to update),
1438  * then copies the template.
1439  */
1440 void
1441 pmap_pinit2(struct pmap *pmap)
1442 {
1443         spin_lock(&pmap_spin);
1444         TAILQ_INSERT_TAIL(&pmap_list, pmap, pm_pmnode);
1445         spin_unlock(&pmap_spin);
1446 }
1447
1448 /*
1449  * This routine is called when various levels in the page table need to
1450  * be populated.  This routine cannot fail.
1451  *
1452  * This function returns two locked pv_entry's, one representing the
1453  * requested pv and one representing the requested pv's parent pv.  If
1454  * the pv did not previously exist it will be mapped into its parent
1455  * and wired, otherwise no additional wire count will be added.
1456  */
1457 static
1458 pv_entry_t
1459 pmap_allocpte(pmap_t pmap, vm_pindex_t ptepindex, pv_entry_t *pvpp)
1460 {
1461         pt_entry_t *ptep;
1462         pv_entry_t pv;
1463         pv_entry_t pvp;
1464         vm_pindex_t pt_pindex;
1465         vm_page_t m;
1466         int isnew;
1467         int ispt;
1468
1469         /*
1470          * If the pv already exists and we aren't being asked for the
1471          * parent page table page we can just return it.  A locked+held pv
1472          * is returned.
1473          */
1474         ispt = 0;
1475         pv = pv_alloc(pmap, ptepindex, &isnew);
1476         if (isnew == 0 && pvpp == NULL)
1477                 return(pv);
1478
1479         /*
1480          * This is a new PV, we have to resolve its parent page table and
1481          * add an additional wiring to the page if necessary.
1482          */
1483
1484         /*
1485          * Special case terminal PVs.  These are not page table pages so
1486          * no vm_page is allocated (the caller supplied the vm_page).  If
1487          * pvpp is non-NULL we are being asked to also removed the pt_pv
1488          * for this pv.
1489          *
1490          * Note that pt_pv's are only returned for user VAs. We assert that
1491          * a pt_pv is not being requested for kernel VAs.
1492          */
1493         if (ptepindex < pmap_pt_pindex(0)) {
1494                 if (ptepindex >= NUPTE_USER)
1495                         KKASSERT(pvpp == NULL);
1496                 else
1497                         KKASSERT(pvpp != NULL);
1498                 if (pvpp) {
1499                         pt_pindex = NUPTE_TOTAL + (ptepindex >> NPTEPGSHIFT);
1500                         pvp = pmap_allocpte(pmap, pt_pindex, NULL);
1501                         if (isnew)
1502                                 vm_page_wire_quick(pvp->pv_m);
1503                         *pvpp = pvp;
1504                 } else {
1505                         pvp = NULL;
1506                 }
1507                 return(pv);
1508         }
1509
1510         /*
1511          * Non-terminal PVs allocate a VM page to represent the page table,
1512          * so we have to resolve pvp and calculate ptepindex for the pvp
1513          * and then for the page table entry index in the pvp for
1514          * fall-through.
1515          */
1516         if (ptepindex < pmap_pd_pindex(0)) {
1517                 /*
1518                  * pv is PT, pvp is PD
1519                  */
1520                 ptepindex = (ptepindex - pmap_pt_pindex(0)) >> NPDEPGSHIFT;
1521                 ptepindex += NUPTE_TOTAL + NUPT_TOTAL;
1522                 pvp = pmap_allocpte(pmap, ptepindex, NULL);
1523                 if (!isnew)
1524                         goto notnew;
1525
1526                 /*
1527                  * PT index in PD
1528                  */
1529                 ptepindex = pv->pv_pindex - pmap_pt_pindex(0);
1530                 ptepindex &= ((1ul << NPDEPGSHIFT) - 1);
1531                 ispt = 1;
1532         } else if (ptepindex < pmap_pdp_pindex(0)) {
1533                 /*
1534                  * pv is PD, pvp is PDP
1535                  *
1536                  * SIMPLE PMAP NOTE: Simple pmaps do not allocate above
1537                  *                   the PD.
1538                  */
1539                 ptepindex = (ptepindex - pmap_pd_pindex(0)) >> NPDPEPGSHIFT;
1540                 ptepindex += NUPTE_TOTAL + NUPT_TOTAL + NUPD_TOTAL;
1541
1542                 if (pmap->pm_flags & PMAP_FLAG_SIMPLE) {
1543                         KKASSERT(pvpp == NULL);
1544                         pvp = NULL;
1545                 } else {
1546                         pvp = pmap_allocpte(pmap, ptepindex, NULL);
1547                 }
1548                 if (!isnew)
1549                         goto notnew;
1550
1551                 /*
1552                  * PD index in PDP
1553                  */
1554                 ptepindex = pv->pv_pindex - pmap_pd_pindex(0);
1555                 ptepindex &= ((1ul << NPDPEPGSHIFT) - 1);
1556         } else if (ptepindex < pmap_pml4_pindex()) {
1557                 /*
1558                  * pv is PDP, pvp is the root pml4 table
1559                  */
1560                 pvp = pmap_allocpte(pmap, pmap_pml4_pindex(), NULL);
1561                 if (!isnew)
1562                         goto notnew;
1563
1564                 /*
1565                  * PDP index in PML4
1566                  */
1567                 ptepindex = pv->pv_pindex - pmap_pdp_pindex(0);
1568                 ptepindex &= ((1ul << NPML4EPGSHIFT) - 1);
1569         } else {
1570                 /*
1571                  * pv represents the top-level PML4, there is no parent.
1572                  */
1573                 pvp = NULL;
1574                 if (!isnew)
1575                         goto notnew;
1576         }
1577
1578         /*
1579          * This code is only reached if isnew is TRUE and this is not a
1580          * terminal PV.  We need to allocate a vm_page for the page table
1581          * at this level and enter it into the parent page table.
1582          *
1583          * page table pages are marked PG_WRITEABLE and PG_MAPPED.
1584          */
1585         for (;;) {
1586                 m = vm_page_alloc(NULL, pv->pv_pindex,
1587                                   VM_ALLOC_NORMAL | VM_ALLOC_SYSTEM |
1588                                   VM_ALLOC_INTERRUPT);
1589                 if (m)
1590                         break;
1591                 vm_wait(0);
1592         }
1593         vm_page_spin_lock(m);
1594         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_list);
1595         pv->pv_m = m;
1596         vm_page_flag_set(m, PG_MAPPED | PG_WRITEABLE);
1597         vm_page_spin_unlock(m);
1598         vm_page_unmanage(m);    /* m must be spinunlocked */
1599
1600         if ((m->flags & PG_ZERO) == 0) {
1601                 pmap_zero_page(VM_PAGE_TO_PHYS(m));
1602         }
1603 #ifdef PMAP_DEBUG
1604         else {
1605                 pmap_page_assertzero(VM_PAGE_TO_PHYS(m));
1606         }
1607 #endif
1608         m->valid = VM_PAGE_BITS_ALL;
1609         vm_page_flag_clear(m, PG_ZERO);
1610         vm_page_wire(m);        /* wire for mapping in parent */
1611
1612         /*
1613          * Wire the page into pvp, bump the wire-count for pvp's page table
1614          * page.  Bump the resident_count for the pmap.  There is no pvp
1615          * for the top level, address the pm_pml4[] array directly.
1616          *
1617          * If the caller wants the parent we return it, otherwise
1618          * we just put it away.
1619          *
1620          * No interlock is needed for pte 0 -> non-zero.
1621          *
1622          * In the situation where *ptep is valid we might have an unmanaged
1623          * page table page shared from another page table which we need to
1624          * unshare before installing our private page table page.
1625          */
1626         if (pvp) {
1627                 ptep = pv_pte_lookup(pvp, ptepindex);
1628                 if (*ptep & PG_V) {
1629                         pt_entry_t pte;
1630                         pmap_inval_info info;
1631
1632                         kprintf("pmap_allocpte: restate shared pg table pg\n");
1633
1634                         if (ispt == 0) {
1635                                 panic("pmap_allocpte: unexpected pte %p/%d",
1636                                       pvp, (int)ptepindex);
1637                         }
1638                         pmap_inval_init(&info);
1639                         pmap_inval_interlock(&info, pmap, (vm_offset_t)-1);
1640                         pte = pte_load_clear(ptep);
1641                         pmap_inval_deinterlock(&info, pmap);
1642                         pmap_inval_done(&info);
1643                         if (vm_page_unwire_quick(PHYS_TO_VM_PAGE(pte & PG_FRAME)))
1644                                 panic("pmap_allocpte: shared pgtable pg bad wirecount");
1645                 } else {
1646                         vm_page_wire_quick(pvp->pv_m);
1647                 }
1648                 *ptep = VM_PAGE_TO_PHYS(m) | (PG_U | PG_RW | PG_V |
1649                                               PG_A | PG_M);
1650         }
1651         vm_page_wakeup(m);
1652 notnew:
1653         if (pvpp)
1654                 *pvpp = pvp;
1655         else if (pvp)
1656                 pv_put(pvp);
1657         return (pv);
1658 }
1659
1660 /*
1661  * This version of pmap_allocpte() checks for possible segment optimizations
1662  * that would allow page-table sharing.  It can be called for terminal
1663  * page or page table page ptepindex's.
1664  *
1665  * The function is called with page table page ptepindex's for fictitious
1666  * and unmanaged terminal pages.  That is, we don't want to allocate a
1667  * terminal pv, we just want the pt_pv.  pvpp is usually passed as NULL
1668  * for this case.
1669  *
1670  * This function can return a pv and *pvpp associated with the passed in pmap
1671  * OR a pv and *pvpp associated with the shared pmap.  In the latter case
1672  * an unmanaged page table page will be entered into the pass in pmap.
1673  */
1674 static
1675 pv_entry_t
1676 pmap_allocpte_seg(pmap_t pmap, vm_pindex_t ptepindex, pv_entry_t *pvpp,
1677                   vm_map_entry_t entry, vm_offset_t va)
1678 {
1679         struct pmap_inval_info info;
1680         vm_object_t object;
1681         pmap_t obpmap;
1682         pmap_t *obpmapp;
1683         vm_offset_t b;
1684         pv_entry_t pte_pv;      /* in original or shared pmap */
1685         pv_entry_t pt_pv;       /* in original or shared pmap */
1686         pv_entry_t proc_pd_pv;  /* in original pmap */
1687         pv_entry_t proc_pt_pv;  /* in original pmap */
1688         pv_entry_t xpv;         /* PT in shared pmap */
1689         pd_entry_t *pt;         /* PT entry in PD of original pmap */
1690         pd_entry_t opte;        /* contents of *pt */
1691         pd_entry_t npte;        /* contents of *pt */
1692         vm_page_t m;
1693
1694         /*
1695          * Basic tests, require a non-NULL vm_map_entry, require proper
1696          * alignment and type for the vm_map_entry, require that the
1697          * underlying object already be allocated.
1698          *
1699          * We currently allow any type of object to use this optimization.
1700          * The object itself does NOT have to be sized to a multiple of the
1701          * segment size, but the memory mapping does.
1702          */
1703         if (entry == NULL ||
1704             pmap_mmu_optimize == 0 ||                   /* not enabled */
1705             ptepindex >= pmap_pd_pindex(0) ||           /* not terminal */
1706             entry->inheritance != VM_INHERIT_SHARE ||   /* not shared */
1707             entry->maptype != VM_MAPTYPE_NORMAL ||      /* weird map type */
1708             entry->object.vm_object == NULL ||          /* needs VM object */
1709             (entry->offset & SEG_MASK) ||               /* must be aligned */
1710             (entry->start & SEG_MASK)) {
1711                 return(pmap_allocpte(pmap, ptepindex, pvpp));
1712         }
1713
1714         /*
1715          * Make sure the full segment can be represented.
1716          */
1717         b = va & ~(vm_offset_t)SEG_MASK;
1718         if (b < entry->start && b + SEG_SIZE > entry->end)
1719                 return(pmap_allocpte(pmap, ptepindex, pvpp));
1720
1721         /*
1722          * If the full segment can be represented dive the VM object's
1723          * shared pmap, allocating as required.
1724          */
1725         object = entry->object.vm_object;
1726
1727         if (entry->protection & VM_PROT_WRITE)
1728                 obpmapp = &object->md.pmap_rw;
1729         else
1730                 obpmapp = &object->md.pmap_ro;
1731
1732         /*
1733          * We allocate what appears to be a normal pmap but because portions
1734          * of this pmap are shared with other unrelated pmaps we have to
1735          * set pm_active to point to all cpus.
1736          *
1737          * XXX Currently using pmap_spin to interlock the update, can't use
1738          *     vm_object_hold/drop because the token might already be held
1739          *     shared OR exclusive and we don't know.
1740          */
1741         while ((obpmap = *obpmapp) == NULL) {
1742                 obpmap = kmalloc(sizeof(*obpmap), M_OBJPMAP, M_WAITOK|M_ZERO);
1743                 pmap_pinit_simple(obpmap);
1744                 pmap_pinit2(obpmap);
1745                 spin_lock(&pmap_spin);
1746                 if (*obpmapp != NULL) {
1747                         /*
1748                          * Handle race
1749                          */
1750                         spin_unlock(&pmap_spin);
1751                         pmap_release(obpmap);
1752                         pmap_puninit(obpmap);
1753                         kfree(obpmap, M_OBJPMAP);
1754                 } else {
1755                         obpmap->pm_active = smp_active_mask;
1756                         *obpmapp = obpmap;
1757                         spin_unlock(&pmap_spin);
1758                 }
1759         }
1760
1761         /*
1762          * Layering is: PTE, PT, PD, PDP, PML4.  We have to return the
1763          * pte/pt using the shared pmap from the object but also adjust
1764          * the process pmap's page table page as a side effect.
1765          */
1766
1767         /*
1768          * Resolve the terminal PTE and PT in the shared pmap.  This is what
1769          * we will return.  This is true if ptepindex represents a terminal
1770          * page, otherwise pte_pv is actually the PT and pt_pv is actually
1771          * the PD.
1772          */
1773         pt_pv = NULL;
1774         pte_pv = pmap_allocpte(obpmap, ptepindex, &pt_pv);
1775         if (ptepindex >= pmap_pt_pindex(0))
1776                 xpv = pte_pv;
1777         else
1778                 xpv = pt_pv;
1779
1780         /*
1781          * Resolve the PD in the process pmap so we can properly share the
1782          * page table page.  Lock order is bottom-up (leaf first)!
1783          *
1784          * NOTE: proc_pt_pv can be NULL.
1785          */
1786         proc_pt_pv = pv_get(pmap, pmap_pt_pindex(b));
1787         proc_pd_pv = pmap_allocpte(pmap, pmap_pd_pindex(b), NULL);
1788
1789         /*
1790          * xpv is the page table page pv from the shared object
1791          * (for convenience).
1792          *
1793          * Calculate the pte value for the PT to load into the process PD.
1794          * If we have to change it we must properly dispose of the previous
1795          * entry.
1796          */
1797         pt = pv_pte_lookup(proc_pd_pv, pmap_pt_index(b));
1798         npte = VM_PAGE_TO_PHYS(xpv->pv_m) |
1799                (PG_U | PG_RW | PG_V | PG_A | PG_M);
1800
1801         /*
1802          * Dispose of previous entry if it was local to the process pmap.
1803          * (This should zero-out *pt)
1804          */
1805         if (proc_pt_pv) {
1806                 pmap_release_pv(proc_pt_pv);
1807                 proc_pt_pv = NULL;
1808                 /* relookup */
1809                 pt = pv_pte_lookup(proc_pd_pv, pmap_pt_index(b));
1810         }
1811
1812         /*
1813          * Handle remaining cases.
1814          */
1815         if (*pt == 0) {
1816                 *pt = npte;
1817                 vm_page_wire_quick(xpv->pv_m);
1818                 vm_page_wire_quick(proc_pd_pv->pv_m);
1819                 atomic_add_long(&pmap->pm_stats.resident_count, 1);
1820         } else if (*pt != npte) {
1821                 pmap_inval_init(&info);
1822                 pmap_inval_interlock(&info, pmap, (vm_offset_t)-1);
1823
1824                 opte = pte_load_clear(pt);
1825                 KKASSERT(opte && opte != npte);
1826
1827                 *pt = npte;
1828                 vm_page_wire_quick(xpv->pv_m);  /* pgtable pg that is npte */
1829
1830                 /*
1831                  * Clean up opte, bump the wire_count for the process
1832                  * PD page representing the new entry if it was
1833                  * previously empty.
1834                  *
1835                  * If the entry was not previously empty and we have
1836                  * a PT in the proc pmap then opte must match that
1837                  * pt.  The proc pt must be retired (this is done
1838                  * later on in this procedure).
1839                  *
1840                  * NOTE: replacing valid pte, wire_count on proc_pd_pv
1841                  * stays the same.
1842                  */
1843                 KKASSERT(opte & PG_V);
1844                 m = PHYS_TO_VM_PAGE(opte & PG_FRAME);
1845                 if (vm_page_unwire_quick(m)) {
1846                         panic("pmap_allocpte_seg: "
1847                               "bad wire count %p",
1848                               m);
1849                 }
1850
1851                 pmap_inval_deinterlock(&info, pmap);
1852                 pmap_inval_done(&info);
1853         }
1854
1855         /*
1856          * The existing process page table was replaced and must be destroyed
1857          * here.
1858          */
1859         if (proc_pd_pv)
1860                 pv_put(proc_pd_pv);
1861         if (pvpp)
1862                 *pvpp = pt_pv;
1863         else
1864                 pv_put(pt_pv);
1865
1866         return (pte_pv);
1867 }
1868
1869 /*
1870  * Release any resources held by the given physical map.
1871  *
1872  * Called when a pmap initialized by pmap_pinit is being released.  Should
1873  * only be called if the map contains no valid mappings.
1874  *
1875  * Caller must hold pmap->pm_token
1876  */
1877 struct pmap_release_info {
1878         pmap_t  pmap;
1879         int     retry;
1880 };
1881
1882 static int pmap_release_callback(pv_entry_t pv, void *data);
1883
1884 void
1885 pmap_release(struct pmap *pmap)
1886 {
1887         struct pmap_release_info info;
1888
1889         KASSERT(pmap->pm_active == 0,
1890                 ("pmap still active! %016jx", (uintmax_t)pmap->pm_active));
1891
1892         spin_lock(&pmap_spin);
1893         TAILQ_REMOVE(&pmap_list, pmap, pm_pmnode);
1894         spin_unlock(&pmap_spin);
1895
1896         /*
1897          * Pull pv's off the RB tree in order from low to high and release
1898          * each page.
1899          */
1900         info.pmap = pmap;
1901         do {
1902                 info.retry = 0;
1903                 spin_lock(&pmap->pm_spin);
1904                 RB_SCAN(pv_entry_rb_tree, &pmap->pm_pvroot, NULL,
1905                         pmap_release_callback, &info);
1906                 spin_unlock(&pmap->pm_spin);
1907         } while (info.retry);
1908
1909
1910         /*
1911          * One resident page (the pml4 page) should remain.
1912          * No wired pages should remain.
1913          */
1914         KKASSERT(pmap->pm_stats.resident_count ==
1915                  ((pmap->pm_flags & PMAP_FLAG_SIMPLE) ? 0 : 1));
1916
1917         KKASSERT(pmap->pm_stats.wired_count == 0);
1918 }
1919
1920 static int
1921 pmap_release_callback(pv_entry_t pv, void *data)
1922 {
1923         struct pmap_release_info *info = data;
1924         pmap_t pmap = info->pmap;
1925         int r;
1926
1927         if (pv_hold_try(pv)) {
1928                 spin_unlock(&pmap->pm_spin);
1929         } else {
1930                 spin_unlock(&pmap->pm_spin);
1931                 pv_lock(pv);
1932                 if (pv->pv_pmap != pmap) {
1933                         pv_put(pv);
1934                         spin_lock(&pmap->pm_spin);
1935                         info->retry = 1;
1936                         return(-1);
1937                 }
1938         }
1939         r = pmap_release_pv(pv);
1940         spin_lock(&pmap->pm_spin);
1941         return(r);
1942 }
1943
1944 /*
1945  * Called with held (i.e. also locked) pv.  This function will dispose of
1946  * the lock along with the pv.
1947  */
1948 static int
1949 pmap_release_pv(pv_entry_t pv)
1950 {
1951         vm_page_t p;
1952
1953         /*
1954          * The pmap is currently not spinlocked, pv is held+locked.
1955          * Remove the pv's page from its parent's page table.  The
1956          * parent's page table page's wire_count will be decremented.
1957          */
1958         pmap_remove_pv_pte(pv, NULL, NULL);
1959
1960         /*
1961          * Terminal pvs are unhooked from their vm_pages.  Because
1962          * terminal pages aren't page table pages they aren't wired
1963          * by us, so we have to be sure not to unwire them either.
1964          */
1965         if (pv->pv_pindex < pmap_pt_pindex(0)) {
1966                 pmap_remove_pv_page(pv);
1967                 goto skip;
1968         }
1969
1970         /*
1971          * We leave the top-level page table page cached, wired, and
1972          * mapped in the pmap until the dtor function (pmap_puninit())
1973          * gets called.
1974          *
1975          * Since we are leaving the top-level pv intact we need
1976          * to break out of what would otherwise be an infinite loop.
1977          */
1978         if (pv->pv_pindex == pmap_pml4_pindex()) {
1979                 pv_put(pv);
1980                 return(-1);
1981         }
1982
1983         /*
1984          * For page table pages (other than the top-level page),
1985          * remove and free the vm_page.  The representitive mapping
1986          * removed above by pmap_remove_pv_pte() did not undo the
1987          * last wire_count so we have to do that as well.
1988          */
1989         p = pmap_remove_pv_page(pv);
1990         vm_page_busy_wait(p, FALSE, "pmaprl");
1991         if (p->wire_count != 1) {
1992                 kprintf("p->wire_count was %016lx %d\n",
1993                         pv->pv_pindex, p->wire_count);
1994         }
1995         KKASSERT(p->wire_count == 1);
1996         KKASSERT(p->flags & PG_UNMANAGED);
1997
1998         vm_page_unwire(p, 0);
1999         KKASSERT(p->wire_count == 0);
2000
2001         /*
2002          * Theoretically this page, if not the pml4 page, should contain
2003          * all-zeros.  But its just too dangerous to mark it PG_ZERO.  Free
2004          * normally.
2005          */
2006         vm_page_free(p);
2007 skip:
2008         pv_free(pv);
2009         return 0;
2010 }
2011
2012 /*
2013  * This function will remove the pte associated with a pv from its parent.
2014  * Terminal pv's are supported.  The removal will be interlocked if info
2015  * is non-NULL.  The caller must dispose of pv instead of just unlocking
2016  * it.
2017  *
2018  * The wire count will be dropped on the parent page table.  The wire
2019  * count on the page being removed (pv->pv_m) from the parent page table
2020  * is NOT touched.  Note that terminal pages will not have any additional
2021  * wire counts while page table pages will have at least one representing
2022  * the mapping, plus others representing sub-mappings.
2023  *
2024  * NOTE: Cannot be called on kernel page table pages, only KVM terminal
2025  *       pages and user page table and terminal pages.
2026  *
2027  * The pv must be locked.
2028  *
2029  * XXX must lock parent pv's if they exist to remove pte XXX
2030  */
2031 static
2032 void
2033 pmap_remove_pv_pte(pv_entry_t pv, pv_entry_t pvp, struct pmap_inval_info *info)
2034 {
2035         vm_pindex_t ptepindex = pv->pv_pindex;
2036         pmap_t pmap = pv->pv_pmap;
2037         vm_page_t p;
2038         int gotpvp = 0;
2039
2040         KKASSERT(pmap);
2041
2042         if (ptepindex == pmap_pml4_pindex()) {
2043                 /*
2044                  * We are the top level pml4 table, there is no parent.
2045                  */
2046                 p = pmap->pm_pmlpv->pv_m;
2047         } else if (ptepindex >= pmap_pdp_pindex(0)) {
2048                 /*
2049                  * Remove a PDP page from the pml4e.  This can only occur
2050                  * with user page tables.  We do not have to lock the
2051                  * pml4 PV so just ignore pvp.
2052                  */
2053                 vm_pindex_t pml4_pindex;
2054                 vm_pindex_t pdp_index;
2055                 pml4_entry_t *pdp;
2056
2057                 pdp_index = ptepindex - pmap_pdp_pindex(0);
2058                 if (pvp == NULL) {
2059                         pml4_pindex = pmap_pml4_pindex();
2060                         pvp = pv_get(pv->pv_pmap, pml4_pindex);
2061                         KKASSERT(pvp);
2062                         gotpvp = 1;
2063                 }
2064                 pdp = &pmap->pm_pml4[pdp_index & ((1ul << NPML4EPGSHIFT) - 1)];
2065                 KKASSERT((*pdp & PG_V) != 0);
2066                 p = PHYS_TO_VM_PAGE(*pdp & PG_FRAME);
2067                 *pdp = 0;
2068                 KKASSERT(info == NULL);
2069         } else if (ptepindex >= pmap_pd_pindex(0)) {
2070                 /*
2071                  * Remove a PD page from the pdp
2072                  *
2073                  * SIMPLE PMAP NOTE: Non-existant pvp's are ok in the case
2074                  *                   of a simple pmap because it stops at
2075                  *                   the PD page.
2076                  */
2077                 vm_pindex_t pdp_pindex;
2078                 vm_pindex_t pd_index;
2079                 pdp_entry_t *pd;
2080
2081                 pd_index = ptepindex - pmap_pd_pindex(0);
2082
2083                 if (pvp == NULL) {
2084                         pdp_pindex = NUPTE_TOTAL + NUPT_TOTAL + NUPD_TOTAL +
2085                                      (pd_index >> NPML4EPGSHIFT);
2086                         pvp = pv_get(pv->pv_pmap, pdp_pindex);
2087                         if (pvp)
2088                                 gotpvp = 1;
2089                 }
2090                 if (pvp) {
2091                         pd = pv_pte_lookup(pvp, pd_index &
2092                                                 ((1ul << NPDPEPGSHIFT) - 1));
2093                         KKASSERT((*pd & PG_V) != 0);
2094                         p = PHYS_TO_VM_PAGE(*pd & PG_FRAME);
2095                         *pd = 0;
2096                 } else {
2097                         KKASSERT(pmap->pm_flags & PMAP_FLAG_SIMPLE);
2098                         p = pv->pv_m;           /* degenerate test later */
2099                 }
2100                 KKASSERT(info == NULL);
2101         } else if (ptepindex >= pmap_pt_pindex(0)) {
2102                 /*
2103                  *  Remove a PT page from the pd
2104                  */
2105                 vm_pindex_t pd_pindex;
2106                 vm_pindex_t pt_index;
2107                 pd_entry_t *pt;
2108
2109                 pt_index = ptepindex - pmap_pt_pindex(0);
2110
2111                 if (pvp == NULL) {
2112                         pd_pindex = NUPTE_TOTAL + NUPT_TOTAL +
2113                                     (pt_index >> NPDPEPGSHIFT);
2114                         pvp = pv_get(pv->pv_pmap, pd_pindex);
2115                         KKASSERT(pvp);
2116                         gotpvp = 1;
2117                 }
2118                 pt = pv_pte_lookup(pvp, pt_index & ((1ul << NPDPEPGSHIFT) - 1));
2119                 KKASSERT((*pt & PG_V) != 0);
2120                 p = PHYS_TO_VM_PAGE(*pt & PG_FRAME);
2121                 *pt = 0;
2122                 KKASSERT(info == NULL);
2123         } else {
2124                 /*
2125                  * Remove a PTE from the PT page
2126                  *
2127                  * NOTE: pv's must be locked bottom-up to avoid deadlocking.
2128                  *       pv is a pte_pv so we can safely lock pt_pv.
2129                  */
2130                 vm_pindex_t pt_pindex;
2131                 pt_entry_t *ptep;
2132                 pt_entry_t pte;
2133                 vm_offset_t va;
2134
2135                 pt_pindex = ptepindex >> NPTEPGSHIFT;
2136                 va = (vm_offset_t)ptepindex << PAGE_SHIFT;
2137
2138                 if (ptepindex >= NUPTE_USER) {
2139                         ptep = vtopte(ptepindex << PAGE_SHIFT);
2140                         KKASSERT(pvp == NULL);
2141                 } else {
2142                         if (pvp == NULL) {
2143                                 pt_pindex = NUPTE_TOTAL +
2144                                             (ptepindex >> NPDPEPGSHIFT);
2145                                 pvp = pv_get(pv->pv_pmap, pt_pindex);
2146                                 KKASSERT(pvp);
2147                                 gotpvp = 1;
2148                         }
2149                         ptep = pv_pte_lookup(pvp, ptepindex &
2150                                                   ((1ul << NPDPEPGSHIFT) - 1));
2151                 }
2152
2153                 if (info)
2154                         pmap_inval_interlock(info, pmap, va);
2155                 pte = pte_load_clear(ptep);
2156                 if (info)
2157                         pmap_inval_deinterlock(info, pmap);
2158                 else
2159                         cpu_invlpg((void *)va);
2160
2161                 /*
2162                  * Now update the vm_page_t
2163                  */
2164                 if ((pte & (PG_MANAGED|PG_V)) != (PG_MANAGED|PG_V)) {
2165                         kprintf("remove_pte badpte %016lx %016lx %d\n",
2166                                 pte, pv->pv_pindex,
2167                                 pv->pv_pindex < pmap_pt_pindex(0));
2168                 }
2169                 /*KKASSERT((pte & (PG_MANAGED|PG_V)) == (PG_MANAGED|PG_V));*/
2170                 p = PHYS_TO_VM_PAGE(pte & PG_FRAME);
2171
2172                 if (pte & PG_M) {
2173                         if (pmap_track_modified(ptepindex))
2174                                 vm_page_dirty(p);
2175                 }
2176                 if (pte & PG_A) {
2177                         vm_page_flag_set(p, PG_REFERENCED);
2178                 }
2179                 if (pte & PG_W)
2180                         atomic_add_long(&pmap->pm_stats.wired_count, -1);
2181                 if (pte & PG_G)
2182                         cpu_invlpg((void *)va);
2183         }
2184
2185         /*
2186          * Unwire the parent page table page.  The wire_count cannot go below
2187          * 1 here because the parent page table page is itself still mapped.
2188          *
2189          * XXX remove the assertions later.
2190          */
2191         KKASSERT(pv->pv_m == p);
2192         if (pvp && vm_page_unwire_quick(pvp->pv_m))
2193                 panic("pmap_remove_pv_pte: Insufficient wire_count");
2194
2195         if (gotpvp)
2196                 pv_put(pvp);
2197 }
2198
2199 static
2200 vm_page_t
2201 pmap_remove_pv_page(pv_entry_t pv)
2202 {
2203         vm_page_t m;
2204
2205         m = pv->pv_m;
2206         KKASSERT(m);
2207         vm_page_spin_lock(m);
2208         pv->pv_m = NULL;
2209         TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
2210         /*
2211         if (m->object)
2212                 atomic_add_int(&m->object->agg_pv_list_count, -1);
2213         */
2214         if (TAILQ_EMPTY(&m->md.pv_list))
2215                 vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
2216         vm_page_spin_unlock(m);
2217         return(m);
2218 }
2219
2220 /*
2221  * Grow the number of kernel page table entries, if needed.
2222  *
2223  * This routine is always called to validate any address space
2224  * beyond KERNBASE (for kldloads).  kernel_vm_end only governs the address
2225  * space below KERNBASE.
2226  */
2227 void
2228 pmap_growkernel(vm_offset_t kstart, vm_offset_t kend)
2229 {
2230         vm_paddr_t paddr;
2231         vm_offset_t ptppaddr;
2232         vm_page_t nkpg;
2233         pd_entry_t *pt, newpt;
2234         pdp_entry_t newpd;
2235         int update_kernel_vm_end;
2236
2237         /*
2238          * bootstrap kernel_vm_end on first real VM use
2239          */
2240         if (kernel_vm_end == 0) {
2241                 kernel_vm_end = VM_MIN_KERNEL_ADDRESS;
2242                 nkpt = 0;
2243                 while ((*pmap_pt(&kernel_pmap, kernel_vm_end) & PG_V) != 0) {
2244                         kernel_vm_end = (kernel_vm_end + PAGE_SIZE * NPTEPG) &
2245                                         ~(PAGE_SIZE * NPTEPG - 1);
2246                         nkpt++;
2247                         if (kernel_vm_end - 1 >= kernel_map.max_offset) {
2248                                 kernel_vm_end = kernel_map.max_offset;
2249                                 break;                       
2250                         }
2251                 }
2252         }
2253
2254         /*
2255          * Fill in the gaps.  kernel_vm_end is only adjusted for ranges
2256          * below KERNBASE.  Ranges above KERNBASE are kldloaded and we
2257          * do not want to force-fill 128G worth of page tables.
2258          */
2259         if (kstart < KERNBASE) {
2260                 if (kstart > kernel_vm_end)
2261                         kstart = kernel_vm_end;
2262                 KKASSERT(kend <= KERNBASE);
2263                 update_kernel_vm_end = 1;
2264         } else {
2265                 update_kernel_vm_end = 0;
2266         }
2267
2268         kstart = rounddown2(kstart, PAGE_SIZE * NPTEPG);
2269         kend = roundup2(kend, PAGE_SIZE * NPTEPG);
2270
2271         if (kend - 1 >= kernel_map.max_offset)
2272                 kend = kernel_map.max_offset;
2273
2274         while (kstart < kend) {
2275                 pt = pmap_pt(&kernel_pmap, kstart);
2276                 if (pt == NULL) {
2277                         /* We need a new PDP entry */
2278                         nkpg = vm_page_alloc(NULL, nkpt,
2279                                              VM_ALLOC_NORMAL |
2280                                              VM_ALLOC_SYSTEM |
2281                                              VM_ALLOC_INTERRUPT);
2282                         if (nkpg == NULL) {
2283                                 panic("pmap_growkernel: no memory to grow "
2284                                       "kernel");
2285                         }
2286                         paddr = VM_PAGE_TO_PHYS(nkpg);
2287                         if ((nkpg->flags & PG_ZERO) == 0)
2288                                 pmap_zero_page(paddr);
2289                         vm_page_flag_clear(nkpg, PG_ZERO);
2290                         newpd = (pdp_entry_t)
2291                                 (paddr | PG_V | PG_RW | PG_A | PG_M);
2292                         *pmap_pd(&kernel_pmap, kstart) = newpd;
2293                         nkpt++;
2294                         continue; /* try again */
2295                 }
2296                 if ((*pt & PG_V) != 0) {
2297                         kstart = (kstart + PAGE_SIZE * NPTEPG) &
2298                                  ~(PAGE_SIZE * NPTEPG - 1);
2299                         if (kstart - 1 >= kernel_map.max_offset) {
2300                                 kstart = kernel_map.max_offset;
2301                                 break;                       
2302                         }
2303                         continue;
2304                 }
2305
2306                 /*
2307                  * This index is bogus, but out of the way
2308                  */
2309                 nkpg = vm_page_alloc(NULL, nkpt,
2310                                      VM_ALLOC_NORMAL |
2311                                      VM_ALLOC_SYSTEM |
2312                                      VM_ALLOC_INTERRUPT);
2313                 if (nkpg == NULL)
2314                         panic("pmap_growkernel: no memory to grow kernel");
2315
2316                 vm_page_wire(nkpg);
2317                 ptppaddr = VM_PAGE_TO_PHYS(nkpg);
2318                 pmap_zero_page(ptppaddr);
2319                 vm_page_flag_clear(nkpg, PG_ZERO);
2320                 newpt = (pd_entry_t) (ptppaddr | PG_V | PG_RW | PG_A | PG_M);
2321                 *pmap_pt(&kernel_pmap, kstart) = newpt;
2322                 nkpt++;
2323
2324                 kstart = (kstart + PAGE_SIZE * NPTEPG) &
2325                           ~(PAGE_SIZE * NPTEPG - 1);
2326
2327                 if (kstart - 1 >= kernel_map.max_offset) {
2328                         kstart = kernel_map.max_offset;
2329                         break;                       
2330                 }
2331         }
2332
2333         /*
2334          * Only update kernel_vm_end for areas below KERNBASE.
2335          */
2336         if (update_kernel_vm_end && kernel_vm_end < kstart)
2337                 kernel_vm_end = kstart;
2338 }
2339
2340 /*
2341  *      Add a reference to the specified pmap.
2342  */
2343 void
2344 pmap_reference(pmap_t pmap)
2345 {
2346         if (pmap != NULL) {
2347                 lwkt_gettoken(&pmap->pm_token);
2348                 ++pmap->pm_count;
2349                 lwkt_reltoken(&pmap->pm_token);
2350         }
2351 }
2352
2353 void
2354 pmap_drop(pmap_t pmap)
2355 {
2356         if (pmap != NULL) {
2357                 lwkt_gettoken(&pmap->pm_token);
2358                 --pmap->pm_count;
2359                 lwkt_reltoken(&pmap->pm_token);
2360         }
2361 }
2362
2363 /***************************************************
2364  * page management routines.
2365  ***************************************************/
2366
2367 /*
2368  * Hold a pv without locking it
2369  */
2370 static void
2371 pv_hold(pv_entry_t pv)
2372 {
2373         u_int count;
2374
2375         if (atomic_cmpset_int(&pv->pv_hold, 0, 1))
2376                 return;
2377
2378         for (;;) {
2379                 count = pv->pv_hold;
2380                 cpu_ccfence();
2381                 if (atomic_cmpset_int(&pv->pv_hold, count, count + 1))
2382                         return;
2383                 /* retry */
2384         }
2385 }
2386
2387 /*
2388  * Hold a pv_entry, preventing its destruction.  TRUE is returned if the pv
2389  * was successfully locked, FALSE if it wasn't.  The caller must dispose of
2390  * the pv properly.
2391  *
2392  * Either the pmap->pm_spin or the related vm_page_spin (if traversing a
2393  * pv list via its page) must be held by the caller.
2394  */
2395 static int
2396 _pv_hold_try(pv_entry_t pv PMAP_DEBUG_DECL)
2397 {
2398         u_int count;
2399
2400         if (atomic_cmpset_int(&pv->pv_hold, 0, PV_HOLD_LOCKED | 1)) {
2401 #ifdef PMAP_DEBUG
2402                 pv->pv_func = func;
2403                 pv->pv_line = lineno;
2404 #endif
2405                 return TRUE;
2406         }
2407
2408         for (;;) {
2409                 count = pv->pv_hold;
2410                 cpu_ccfence();
2411                 if ((count & PV_HOLD_LOCKED) == 0) {
2412                         if (atomic_cmpset_int(&pv->pv_hold, count,
2413                                               (count + 1) | PV_HOLD_LOCKED)) {
2414 #ifdef PMAP_DEBUG
2415                                 pv->pv_func = func;
2416                                 pv->pv_line = lineno;
2417 #endif
2418                                 return TRUE;
2419                         }
2420                 } else {
2421                         if (atomic_cmpset_int(&pv->pv_hold, count, count + 1))
2422                                 return FALSE;
2423                 }
2424                 /* retry */
2425         }
2426 }
2427
2428 /*
2429  * Drop a previously held pv_entry which could not be locked, allowing its
2430  * destruction.
2431  *
2432  * Must not be called with a spinlock held as we might zfree() the pv if it
2433  * is no longer associated with a pmap and this was the last hold count.
2434  */
2435 static void
2436 pv_drop(pv_entry_t pv)
2437 {
2438         u_int count;
2439
2440         if (atomic_cmpset_int(&pv->pv_hold, 1, 0)) {
2441                 if (pv->pv_pmap == NULL)
2442                         zfree(pvzone, pv);
2443                 return;
2444         }
2445
2446         for (;;) {
2447                 count = pv->pv_hold;
2448                 cpu_ccfence();
2449                 KKASSERT((count & PV_HOLD_MASK) > 0);
2450                 KKASSERT((count & (PV_HOLD_LOCKED | PV_HOLD_MASK)) !=
2451                          (PV_HOLD_LOCKED | 1));
2452                 if (atomic_cmpset_int(&pv->pv_hold, count, count - 1)) {
2453                         if (count == 1 && pv->pv_pmap == NULL)
2454                                 zfree(pvzone, pv);
2455                         return;
2456                 }
2457                 /* retry */
2458         }
2459 }
2460
2461 /*
2462  * Find or allocate the requested PV entry, returning a locked pv
2463  */
2464 static
2465 pv_entry_t
2466 _pv_alloc(pmap_t pmap, vm_pindex_t pindex, int *isnew PMAP_DEBUG_DECL)
2467 {
2468         pv_entry_t pv;
2469         pv_entry_t pnew = NULL;
2470
2471         spin_lock(&pmap->pm_spin);
2472         for (;;) {
2473                 if ((pv = pmap->pm_pvhint) == NULL || pv->pv_pindex != pindex) {
2474                         pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot,
2475                                                         pindex);
2476                 }
2477                 if (pv == NULL) {
2478                         if (pnew == NULL) {
2479                                 spin_unlock(&pmap->pm_spin);
2480                                 pnew = zalloc(pvzone);
2481                                 spin_lock(&pmap->pm_spin);
2482                                 continue;
2483                         }
2484                         pnew->pv_pmap = pmap;
2485                         pnew->pv_pindex = pindex;
2486                         pnew->pv_hold = PV_HOLD_LOCKED | 1;
2487 #ifdef PMAP_DEBUG
2488                         pnew->pv_func = func;
2489                         pnew->pv_line = lineno;
2490 #endif
2491                         pv_entry_rb_tree_RB_INSERT(&pmap->pm_pvroot, pnew);
2492                         atomic_add_long(&pmap->pm_stats.resident_count, 1);
2493                         spin_unlock(&pmap->pm_spin);
2494                         *isnew = 1;
2495                         return(pnew);
2496                 }
2497                 if (pnew) {
2498                         spin_unlock(&pmap->pm_spin);
2499                         zfree(pvzone, pnew);
2500                         pnew = NULL;
2501                         spin_lock(&pmap->pm_spin);
2502                         continue;
2503                 }
2504                 if (_pv_hold_try(pv PMAP_DEBUG_COPY)) {
2505                         spin_unlock(&pmap->pm_spin);
2506                         *isnew = 0;
2507                         return(pv);
2508                 }
2509                 spin_unlock(&pmap->pm_spin);
2510                 _pv_lock(pv PMAP_DEBUG_COPY);
2511                 if (pv->pv_pmap == pmap && pv->pv_pindex == pindex) {
2512                         *isnew = 0;
2513                         return(pv);
2514                 }
2515                 pv_put(pv);
2516                 spin_lock(&pmap->pm_spin);
2517         }
2518
2519
2520 }
2521
2522 /*
2523  * Find the requested PV entry, returning a locked+held pv or NULL
2524  */
2525 static
2526 pv_entry_t
2527 _pv_get(pmap_t pmap, vm_pindex_t pindex PMAP_DEBUG_DECL)
2528 {
2529         pv_entry_t pv;
2530
2531         spin_lock(&pmap->pm_spin);
2532         for (;;) {
2533                 /*
2534                  * Shortcut cache
2535                  */
2536                 if ((pv = pmap->pm_pvhint) == NULL || pv->pv_pindex != pindex) {
2537                         pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot,
2538                                                         pindex);
2539                 }
2540                 if (pv == NULL) {
2541                         spin_unlock(&pmap->pm_spin);
2542                         return NULL;
2543                 }
2544                 if (_pv_hold_try(pv PMAP_DEBUG_COPY)) {
2545                         pv_cache(pv, pindex);
2546                         spin_unlock(&pmap->pm_spin);
2547                         return(pv);
2548                 }
2549                 spin_unlock(&pmap->pm_spin);
2550                 _pv_lock(pv PMAP_DEBUG_COPY);
2551                 if (pv->pv_pmap == pmap && pv->pv_pindex == pindex)
2552                         return(pv);
2553                 pv_put(pv);
2554                 spin_lock(&pmap->pm_spin);
2555         }
2556 }
2557
2558 /*
2559  * Lookup, hold, and attempt to lock (pmap,pindex).
2560  *
2561  * If the entry does not exist NULL is returned and *errorp is set to 0
2562  *
2563  * If the entry exists and could be successfully locked it is returned and
2564  * errorp is set to 0.
2565  *
2566  * If the entry exists but could NOT be successfully locked it is returned
2567  * held and *errorp is set to 1.
2568  */
2569 static
2570 pv_entry_t
2571 pv_get_try(pmap_t pmap, vm_pindex_t pindex, int *errorp)
2572 {
2573         pv_entry_t pv;
2574
2575         spin_lock(&pmap->pm_spin);
2576         if ((pv = pmap->pm_pvhint) == NULL || pv->pv_pindex != pindex)
2577                 pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot, pindex);
2578         if (pv == NULL) {
2579                 spin_unlock(&pmap->pm_spin);
2580                 *errorp = 0;
2581                 return NULL;
2582         }
2583         if (pv_hold_try(pv)) {
2584                 pv_cache(pv, pindex);
2585                 spin_unlock(&pmap->pm_spin);
2586                 *errorp = 0;
2587                 return(pv);     /* lock succeeded */
2588         }
2589         spin_unlock(&pmap->pm_spin);
2590         *errorp = 1;
2591         return (pv);            /* lock failed */
2592 }
2593
2594 /*
2595  * Find the requested PV entry, returning a held pv or NULL
2596  */
2597 static
2598 pv_entry_t
2599 pv_find(pmap_t pmap, vm_pindex_t pindex)
2600 {
2601         pv_entry_t pv;
2602
2603         spin_lock(&pmap->pm_spin);
2604
2605         if ((pv = pmap->pm_pvhint) == NULL || pv->pv_pindex != pindex)
2606                 pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot, pindex);
2607         if (pv == NULL) {
2608                 spin_unlock(&pmap->pm_spin);
2609                 return NULL;
2610         }
2611         pv_hold(pv);
2612         pv_cache(pv, pindex);
2613         spin_unlock(&pmap->pm_spin);
2614         return(pv);
2615 }
2616
2617 /*
2618  * Lock a held pv, keeping the hold count
2619  */
2620 static
2621 void
2622 _pv_lock(pv_entry_t pv PMAP_DEBUG_DECL)
2623 {
2624         u_int count;
2625
2626         for (;;) {
2627                 count = pv->pv_hold;
2628                 cpu_ccfence();
2629                 if ((count & PV_HOLD_LOCKED) == 0) {
2630                         if (atomic_cmpset_int(&pv->pv_hold, count,
2631                                               count | PV_HOLD_LOCKED)) {
2632 #ifdef PMAP_DEBUG
2633                                 pv->pv_func = func;
2634                                 pv->pv_line = lineno;
2635 #endif
2636                                 return;
2637                         }
2638                         continue;
2639                 }
2640                 tsleep_interlock(pv, 0);
2641                 if (atomic_cmpset_int(&pv->pv_hold, count,
2642                                       count | PV_HOLD_WAITING)) {
2643 #ifdef PMAP_DEBUG
2644                         kprintf("pv waiting on %s:%d\n",
2645                                         pv->pv_func, pv->pv_line);
2646 #endif
2647                         tsleep(pv, PINTERLOCKED, "pvwait", hz);
2648                 }
2649                 /* retry */
2650         }
2651 }
2652
2653 /*
2654  * Unlock a held and locked pv, keeping the hold count.
2655  */
2656 static
2657 void
2658 pv_unlock(pv_entry_t pv)
2659 {
2660         u_int count;
2661
2662         if (atomic_cmpset_int(&pv->pv_hold, PV_HOLD_LOCKED | 1, 1))
2663                 return;
2664
2665         for (;;) {
2666                 count = pv->pv_hold;
2667                 cpu_ccfence();
2668                 KKASSERT((count & (PV_HOLD_LOCKED|PV_HOLD_MASK)) >=
2669                          (PV_HOLD_LOCKED | 1));
2670                 if (atomic_cmpset_int(&pv->pv_hold, count,
2671                                       count &
2672                                       ~(PV_HOLD_LOCKED | PV_HOLD_WAITING))) {
2673                         if (count & PV_HOLD_WAITING)
2674                                 wakeup(pv);
2675                         break;
2676                 }
2677         }
2678 }
2679
2680 /*
2681  * Unlock and drop a pv.  If the pv is no longer associated with a pmap
2682  * and the hold count drops to zero we will free it.
2683  *
2684  * Caller should not hold any spin locks.  We are protected from hold races
2685  * by virtue of holds only occuring only with a pmap_spin or vm_page_spin
2686  * lock held.  A pv cannot be located otherwise.
2687  */
2688 static
2689 void
2690 pv_put(pv_entry_t pv)
2691 {
2692         if (atomic_cmpset_int(&pv->pv_hold, PV_HOLD_LOCKED | 1, 0)) {
2693                 if (pv->pv_pmap == NULL)
2694                         zfree(pvzone, pv);
2695                 return;
2696         }
2697         pv_unlock(pv);
2698         pv_drop(pv);
2699 }
2700
2701 /*
2702  * Unlock, drop, and free a pv, destroying it.  The pv is removed from its
2703  * pmap.  Any pte operations must have already been completed.
2704  */
2705 static
2706 void
2707 pv_free(pv_entry_t pv)
2708 {
2709         pmap_t pmap;
2710
2711         KKASSERT(pv->pv_m == NULL);
2712         if ((pmap = pv->pv_pmap) != NULL) {
2713                 spin_lock(&pmap->pm_spin);
2714                 pv_entry_rb_tree_RB_REMOVE(&pmap->pm_pvroot, pv);
2715                 if (pmap->pm_pvhint == pv)
2716                         pmap->pm_pvhint = NULL;
2717                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
2718                 pv->pv_pmap = NULL;
2719                 pv->pv_pindex = 0;
2720                 spin_unlock(&pmap->pm_spin);
2721         }
2722         pv_put(pv);
2723 }
2724
2725 /*
2726  * This routine is very drastic, but can save the system
2727  * in a pinch.
2728  */
2729 void
2730 pmap_collect(void)
2731 {
2732         int i;
2733         vm_page_t m;
2734         static int warningdone=0;
2735
2736         if (pmap_pagedaemon_waken == 0)
2737                 return;
2738         pmap_pagedaemon_waken = 0;
2739         if (warningdone < 5) {
2740                 kprintf("pmap_collect: collecting pv entries -- "
2741                         "suggest increasing PMAP_SHPGPERPROC\n");
2742                 warningdone++;
2743         }
2744
2745         for (i = 0; i < vm_page_array_size; i++) {
2746                 m = &vm_page_array[i];
2747                 if (m->wire_count || m->hold_count)
2748                         continue;
2749                 if (vm_page_busy_try(m, TRUE) == 0) {
2750                         if (m->wire_count == 0 && m->hold_count == 0) {
2751                                 pmap_remove_all(m);
2752                         }
2753                         vm_page_wakeup(m);
2754                 }
2755         }
2756 }
2757
2758 /*
2759  * Scan the pmap for active page table entries and issue a callback.
2760  * The callback must dispose of pte_pv, whos PTE entry is at *ptep in
2761  * its parent page table.
2762  *
2763  * pte_pv will be NULL if the page or page table is unmanaged.
2764  * pt_pv will point to the page table page containing the pte for the page.
2765  *
2766  * NOTE! If we come across an unmanaged page TABLE (verses an unmanaged page),
2767  *       we pass a NULL pte_pv and we pass a pt_pv pointing to the passed
2768  *       process pmap's PD and page to the callback function.  This can be
2769  *       confusing because the pt_pv is really a pd_pv, and the target page
2770  *       table page is simply aliased by the pmap and not owned by it.
2771  *
2772  * It is assumed that the start and end are properly rounded to the page size.
2773  *
2774  * It is assumed that PD pages and above are managed and thus in the RB tree,
2775  * allowing us to use RB_SCAN from the PD pages down for ranged scans.
2776  */
2777 struct pmap_scan_info {
2778         struct pmap *pmap;
2779         vm_offset_t sva;
2780         vm_offset_t eva;
2781         vm_pindex_t sva_pd_pindex;
2782         vm_pindex_t eva_pd_pindex;
2783         void (*func)(pmap_t, struct pmap_inval_info *,
2784                      pv_entry_t, pv_entry_t, int, vm_offset_t,
2785                      pt_entry_t *, void *);
2786         void *arg;
2787         struct pmap_inval_info inval;
2788 };
2789
2790 static int pmap_scan_cmp(pv_entry_t pv, void *data);
2791 static int pmap_scan_callback(pv_entry_t pv, void *data);
2792
2793 static void
2794 pmap_scan(struct pmap_scan_info *info)
2795 {
2796         struct pmap *pmap = info->pmap;
2797         pv_entry_t pd_pv;       /* A page directory PV */
2798         pv_entry_t pt_pv;       /* A page table PV */
2799         pv_entry_t pte_pv;      /* A page table entry PV */
2800         pt_entry_t *ptep;
2801         struct pv_entry dummy_pv;
2802
2803         if (pmap == NULL)
2804                 return;
2805
2806         /*
2807          * Hold the token for stability; if the pmap is empty we have nothing
2808          * to do.
2809          */
2810         lwkt_gettoken(&pmap->pm_token);
2811 #if 0
2812         if (pmap->pm_stats.resident_count == 0) {
2813                 lwkt_reltoken(&pmap->pm_token);
2814                 return;
2815         }
2816 #endif
2817
2818         pmap_inval_init(&info->inval);
2819
2820         /*
2821          * Special handling for scanning one page, which is a very common
2822          * operation (it is?).
2823          *
2824          * NOTE: Locks must be ordered bottom-up. pte,pt,pd,pdp,pml4
2825          */
2826         if (info->sva + PAGE_SIZE == info->eva) {
2827                 if (info->sva >= VM_MAX_USER_ADDRESS) {
2828                         /*
2829                          * Kernel mappings do not track wire counts on
2830                          * page table pages and only maintain pd_pv and
2831                          * pte_pv levels so pmap_scan() works.
2832                          */
2833                         pt_pv = NULL;
2834                         pte_pv = pv_get(pmap, pmap_pte_pindex(info->sva));
2835                         ptep = vtopte(info->sva);
2836                 } else {
2837                         /*
2838                          * User pages which are unmanaged will not have a
2839                          * pte_pv.  User page table pages which are unmanaged
2840                          * (shared from elsewhere) will also not have a pt_pv.
2841                          * The func() callback will pass both pte_pv and pt_pv
2842                          * as NULL in that case.
2843                          */
2844                         pte_pv = pv_get(pmap, pmap_pte_pindex(info->sva));
2845                         pt_pv = pv_get(pmap, pmap_pt_pindex(info->sva));
2846                         if (pt_pv == NULL) {
2847                                 KKASSERT(pte_pv == NULL);
2848                                 pd_pv = pv_get(pmap, pmap_pd_pindex(info->sva));
2849                                 if (pd_pv) {
2850                                         ptep = pv_pte_lookup(pd_pv,
2851                                                     pmap_pt_index(info->sva));
2852                                         if (*ptep) {
2853                                                 info->func(pmap, &info->inval,
2854                                                      NULL, pd_pv, 1,
2855                                                      info->sva, ptep,
2856                                                      info->arg);
2857                                         }
2858                                         pv_put(pd_pv);
2859                                 }
2860                                 goto fast_skip;
2861                         }
2862                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(info->sva));
2863                 }
2864                 if (*ptep == 0) {
2865                         /*
2866                          * Unlike the pv_find() case below we actually
2867                          * acquired a locked pv in this case so any
2868                          * race should have been resolved.  It is expected
2869                          * to not exist.
2870                          */
2871                         KKASSERT(pte_pv == NULL);
2872                 } else if (pte_pv) {
2873                         KASSERT((*ptep & (PG_MANAGED|PG_V)) == (PG_MANAGED|
2874                                                                 PG_V),
2875                                 ("bad *ptep %016lx sva %016lx pte_pv %p",
2876                                 *ptep, info->sva, pte_pv));
2877                         info->func(pmap, &info->inval, pte_pv, pt_pv, 0,
2878                                    info->sva, ptep, info->arg);
2879                 } else {
2880                         KASSERT((*ptep & (PG_MANAGED|PG_V)) == PG_V,
2881                                 ("bad *ptep %016lx sva %016lx pte_pv NULL",
2882                                 *ptep, info->sva));
2883                         info->func(pmap, &info->inval, NULL, pt_pv, 0,
2884                                    info->sva, ptep, info->arg);
2885                 }
2886                 if (pt_pv)
2887                         pv_put(pt_pv);
2888 fast_skip:
2889                 pmap_inval_done(&info->inval);
2890                 lwkt_reltoken(&pmap->pm_token);
2891                 return;
2892         }
2893
2894         /*
2895          * Nominal scan case, RB_SCAN() for PD pages and iterate from
2896          * there.
2897          */
2898         info->sva_pd_pindex = pmap_pd_pindex(info->sva);
2899         info->eva_pd_pindex = pmap_pd_pindex(info->eva + NBPDP - 1);
2900
2901         if (info->sva >= VM_MAX_USER_ADDRESS) {
2902                 /*
2903                  * The kernel does not currently maintain any pv_entry's for
2904                  * higher-level page tables.
2905                  */
2906                 bzero(&dummy_pv, sizeof(dummy_pv));
2907                 dummy_pv.pv_pindex = info->sva_pd_pindex;
2908                 spin_lock(&pmap->pm_spin);
2909                 while (dummy_pv.pv_pindex < info->eva_pd_pindex) {
2910                         pmap_scan_callback(&dummy_pv, info);
2911                         ++dummy_pv.pv_pindex;
2912                 }
2913                 spin_unlock(&pmap->pm_spin);
2914         } else {
2915                 /*
2916                  * User page tables maintain local PML4, PDP, and PD
2917                  * pv_entry's at the very least.  PT pv's might be
2918                  * unmanaged and thus not exist.  PTE pv's might be
2919                  * unmanaged and thus not exist.
2920                  */
2921                 spin_lock(&pmap->pm_spin);
2922                 pv_entry_rb_tree_RB_SCAN(&pmap->pm_pvroot,
2923                         pmap_scan_cmp, pmap_scan_callback, info);
2924                 spin_unlock(&pmap->pm_spin);
2925         }
2926         pmap_inval_done(&info->inval);
2927         lwkt_reltoken(&pmap->pm_token);
2928 }
2929
2930 /*
2931  * WARNING! pmap->pm_spin held
2932  */
2933 static int
2934 pmap_scan_cmp(pv_entry_t pv, void *data)
2935 {
2936         struct pmap_scan_info *info = data;
2937         if (pv->pv_pindex < info->sva_pd_pindex)
2938                 return(-1);
2939         if (pv->pv_pindex >= info->eva_pd_pindex)
2940                 return(1);
2941         return(0);
2942 }
2943
2944 /*
2945  * WARNING! pmap->pm_spin held
2946  */
2947 static int
2948 pmap_scan_callback(pv_entry_t pv, void *data)
2949 {
2950         struct pmap_scan_info *info = data;
2951         struct pmap *pmap = info->pmap;
2952         pv_entry_t pd_pv;       /* A page directory PV */
2953         pv_entry_t pt_pv;       /* A page table PV */
2954         pv_entry_t pte_pv;      /* A page table entry PV */
2955         pt_entry_t *ptep;
2956         vm_offset_t sva;
2957         vm_offset_t eva;
2958         vm_offset_t va_next;
2959         vm_pindex_t pd_pindex;
2960         int error;
2961
2962         /*
2963          * Pull the PD pindex from the pv before releasing the spinlock.
2964          *
2965          * WARNING: pv is faked for kernel pmap scans.
2966          */
2967         pd_pindex = pv->pv_pindex;
2968         spin_unlock(&pmap->pm_spin);
2969         pv = NULL;      /* invalid after spinlock unlocked */
2970
2971         /*
2972          * Calculate the page range within the PD.  SIMPLE pmaps are
2973          * direct-mapped for the entire 2^64 address space.  Normal pmaps
2974          * reflect the user and kernel address space which requires
2975          * cannonicalization w/regards to converting pd_pindex's back
2976          * into addresses.
2977          */
2978         sva = (pd_pindex - NUPTE_TOTAL - NUPT_TOTAL) << PDPSHIFT;
2979         if ((pmap->pm_flags & PMAP_FLAG_SIMPLE) == 0 &&
2980             (sva & PML4_SIGNMASK)) {
2981                 sva |= PML4_SIGNMASK;
2982         }
2983         eva = sva + NBPDP;      /* can overflow */
2984         if (sva < info->sva)
2985                 sva = info->sva;
2986         if (eva < info->sva || eva > info->eva)
2987                 eva = info->eva;
2988
2989         /*
2990          * NOTE: kernel mappings do not track page table pages, only
2991          *       terminal pages.
2992          *
2993          * NOTE: Locks must be ordered bottom-up. pte,pt,pd,pdp,pml4.
2994          *       However, for the scan to be efficient we try to
2995          *       cache items top-down.
2996          */
2997         pd_pv = NULL;
2998         pt_pv = NULL;
2999
3000         for (; sva < eva; sva = va_next) {
3001                 lwkt_yield();
3002                 if (sva >= VM_MAX_USER_ADDRESS) {
3003                         if (pt_pv) {
3004                                 pv_put(pt_pv);
3005                                 pt_pv = NULL;
3006                         }
3007                         goto kernel_skip;
3008                 }
3009
3010                 /*
3011                  * PD cache (degenerate case if we skip).  It is possible
3012                  * for the PD to not exist due to races.  This is ok.
3013                  */
3014                 if (pd_pv == NULL) {
3015                         pd_pv = pv_get(pmap, pmap_pd_pindex(sva));
3016                 } else if (pd_pv->pv_pindex != pmap_pd_pindex(sva)) {
3017                         pv_put(pd_pv);
3018                         pd_pv = pv_get(pmap, pmap_pd_pindex(sva));
3019                 }
3020                 if (pd_pv == NULL) {
3021                         va_next = (sva + NBPDP) & ~PDPMASK;
3022                         if (va_next < sva)
3023                                 va_next = eva;
3024                         continue;
3025                 }
3026
3027                 /*
3028                  * PT cache
3029                  */
3030                 if (pt_pv == NULL) {
3031                         if (pd_pv) {
3032                                 pv_put(pd_pv);
3033                                 pd_pv = NULL;
3034                         }
3035                         pt_pv = pv_get(pmap, pmap_pt_pindex(sva));
3036                 } else if (pt_pv->pv_pindex != pmap_pt_pindex(sva)) {
3037                         if (pd_pv) {
3038                                 pv_put(pd_pv);
3039                                 pd_pv = NULL;
3040                         }
3041                         pv_put(pt_pv);
3042                         pt_pv = pv_get(pmap, pmap_pt_pindex(sva));
3043                 }
3044
3045                 /*
3046                  * If pt_pv is NULL we either have an shared page table
3047                  * page and must issue a callback specific to that case,
3048                  * or there is no page table page.
3049                  *
3050                  * Either way we can skip the page table page.
3051                  */
3052                 if (pt_pv == NULL) {
3053                         /*
3054                          * Possible unmanaged (shared from another pmap)
3055                          * page table page.
3056                          */
3057                         if (pd_pv == NULL)
3058                                 pd_pv = pv_get(pmap, pmap_pd_pindex(sva));
3059                         KKASSERT(pd_pv != NULL);
3060                         ptep = pv_pte_lookup(pd_pv, pmap_pt_index(sva));
3061                         if (*ptep & PG_V) {
3062                                 info->func(pmap, &info->inval, NULL, pd_pv, 1,
3063                                            sva, ptep, info->arg);
3064                         }
3065
3066                         /*
3067                          * Done, move to next page table page.
3068                          */
3069                         va_next = (sva + NBPDR) & ~PDRMASK;
3070                         if (va_next < sva)
3071                                 va_next = eva;
3072                         continue;
3073                 }
3074
3075                 /*
3076                  * From this point in the loop testing pt_pv for non-NULL
3077                  * means we are in UVM, else if it is NULL we are in KVM.
3078                  *
3079                  * Limit our scan to either the end of the va represented
3080                  * by the current page table page, or to the end of the
3081                  * range being removed.
3082                  */
3083 kernel_skip:
3084                 va_next = (sva + NBPDR) & ~PDRMASK;
3085                 if (va_next < sva)
3086                         va_next = eva;
3087                 if (va_next > eva)
3088                         va_next = eva;
3089
3090                 /*
3091                  * Scan the page table for pages.  Some pages may not be
3092                  * managed (might not have a pv_entry).
3093                  *
3094                  * There is no page table management for kernel pages so
3095                  * pt_pv will be NULL in that case, but otherwise pt_pv
3096                  * is non-NULL, locked, and referenced.
3097                  */
3098
3099                 /*
3100                  * At this point a non-NULL pt_pv means a UVA, and a NULL
3101                  * pt_pv means a KVA.
3102                  */
3103                 if (pt_pv)
3104                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(sva));
3105                 else
3106                         ptep = vtopte(sva);
3107
3108                 while (sva < va_next) {
3109                         /*
3110                          * Acquire the related pte_pv, if any.  If *ptep == 0
3111                          * the related pte_pv should not exist, but if *ptep
3112                          * is not zero the pte_pv may or may not exist (e.g.
3113                          * will not exist for an unmanaged page).
3114                          *
3115                          * However a multitude of races are possible here.
3116                          *
3117                          * In addition, the (pt_pv, pte_pv) lock order is
3118                          * backwards, so we have to be careful in aquiring
3119                          * a properly locked pte_pv.
3120                          */
3121                         lwkt_yield();
3122                         if (pt_pv) {
3123                                 pte_pv = pv_get_try(pmap, pmap_pte_pindex(sva),
3124                                                     &error);
3125                                 if (error) {
3126                                         if (pd_pv) {
3127                                                 pv_put(pd_pv);
3128                                                 pd_pv = NULL;
3129                                         }
3130                                         pv_put(pt_pv);   /* must be non-NULL */
3131                                         pt_pv = NULL;
3132                                         pv_lock(pte_pv); /* safe to block now */
3133                                         pv_put(pte_pv);
3134                                         pte_pv = NULL;
3135                                         pt_pv = pv_get(pmap,
3136                                                        pmap_pt_pindex(sva));
3137                                         /*
3138                                          * pt_pv reloaded, need new ptep
3139                                          */
3140                                         KKASSERT(pt_pv != NULL);
3141                                         ptep = pv_pte_lookup(pt_pv,
3142                                                         pmap_pte_index(sva));
3143                                         continue;
3144                                 }
3145                         } else {
3146                                 pte_pv = pv_get(pmap, pmap_pte_pindex(sva));
3147                         }
3148
3149                         /*
3150                          * Ok, if *ptep == 0 we had better NOT have a pte_pv.
3151                          */
3152                         if (*ptep == 0) {
3153                                 if (pte_pv) {
3154                                         kprintf("Unexpected non-NULL pte_pv "
3155                                                 "%p pt_pv %p *ptep = %016lx\n",
3156                                                 pte_pv, pt_pv, *ptep);
3157                                         panic("Unexpected non-NULL pte_pv");
3158                                 }
3159                                 sva += PAGE_SIZE;
3160                                 ++ptep;
3161                                 continue;
3162                         }
3163
3164                         /*
3165                          * Ready for the callback.  The locked pte_pv (if any)
3166                          * is consumed by the callback.  pte_pv will exist if
3167                          *  the page is managed, and will not exist if it
3168                          * isn't.
3169                          */
3170                         if (pte_pv) {
3171                                 KASSERT((*ptep & (PG_MANAGED|PG_V)) ==
3172                                          (PG_MANAGED|PG_V),
3173                                         ("bad *ptep %016lx sva %016lx "
3174                                          "pte_pv %p",
3175                                          *ptep, sva, pte_pv));
3176                                 info->func(pmap, &info->inval, pte_pv, pt_pv, 0,
3177                                            sva, ptep, info->arg);
3178                         } else {
3179                                 KASSERT((*ptep & (PG_MANAGED|PG_V)) ==
3180                                          PG_V,
3181                                         ("bad *ptep %016lx sva %016lx "
3182                                          "pte_pv NULL",
3183                                          *ptep, sva));
3184                                 info->func(pmap, &info->inval, NULL, pt_pv, 0,
3185                                            sva, ptep, info->arg);
3186                         }
3187                         pte_pv = NULL;
3188                         sva += PAGE_SIZE;
3189                         ++ptep;
3190                 }
3191         }
3192         if (pd_pv) {
3193                 pv_put(pd_pv);
3194                 pd_pv = NULL;
3195         }
3196         if (pt_pv) {
3197                 pv_put(pt_pv);
3198                 pt_pv = NULL;
3199         }
3200
3201         /*
3202          * Relock before returning.
3203          */
3204         spin_lock(&pmap->pm_spin);
3205         return (0);
3206 }
3207
3208 void
3209 pmap_remove(struct pmap *pmap, vm_offset_t sva, vm_offset_t eva)
3210 {
3211         struct pmap_scan_info info;
3212
3213         info.pmap = pmap;
3214         info.sva = sva;
3215         info.eva = eva;
3216         info.func = pmap_remove_callback;
3217         info.arg = NULL;
3218         pmap_scan(&info);
3219 }
3220
3221 static void
3222 pmap_remove_callback(pmap_t pmap, struct pmap_inval_info *info,
3223                      pv_entry_t pte_pv, pv_entry_t pt_pv, int sharept,
3224                      vm_offset_t va, pt_entry_t *ptep, void *arg __unused)
3225 {
3226         pt_entry_t pte;
3227
3228         if (pte_pv) {
3229                 /*
3230                  * This will also drop pt_pv's wire_count. Note that
3231                  * terminal pages are not wired based on mmu presence.
3232                  */
3233                 pmap_remove_pv_pte(pte_pv, pt_pv, info);
3234                 pmap_remove_pv_page(pte_pv);
3235                 pv_free(pte_pv);
3236         } else if (sharept == 0) {
3237                 /*
3238                  * Unmanaged page
3239                  *
3240                  * pt_pv's wire_count is still bumped by unmanaged pages
3241                  * so we must decrement it manually.
3242                  */
3243                 pmap_inval_interlock(info, pmap, va);
3244                 pte = pte_load_clear(ptep);
3245                 pmap_inval_deinterlock(info, pmap);
3246                 if (pte & PG_W)
3247                         atomic_add_long(&pmap->pm_stats.wired_count, -1);
3248                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
3249                 if (vm_page_unwire_quick(pt_pv->pv_m))
3250                         panic("pmap_remove: insufficient wirecount");
3251         } else {
3252                 /*
3253                  * Unmanaged page table, pt_pv is actually the pd_pv
3254                  * for our pmap (not the share object pmap).
3255                  *
3256                  * We have to unwire the target page table page and we
3257                  * have to unwire our page directory page.
3258                  */
3259                 pmap_inval_interlock(info, pmap, va);
3260                 pte = pte_load_clear(ptep);
3261                 pmap_inval_deinterlock(info, pmap);
3262                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
3263                 if (vm_page_unwire_quick(PHYS_TO_VM_PAGE(pte & PG_FRAME)))
3264                         panic("pmap_remove: shared pgtable1 bad wirecount");
3265                 if (vm_page_unwire_quick(pt_pv->pv_m))
3266                         panic("pmap_remove: shared pgtable2 bad wirecount");
3267         }
3268 }
3269
3270 /*
3271  * Removes this physical page from all physical maps in which it resides.
3272  * Reflects back modify bits to the pager.
3273  *
3274  * This routine may not be called from an interrupt.
3275  */
3276 static
3277 void
3278 pmap_remove_all(vm_page_t m)
3279 {
3280         struct pmap_inval_info info;
3281         pv_entry_t pv;
3282
3283         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
3284                 return;
3285
3286         pmap_inval_init(&info);
3287         vm_page_spin_lock(m);
3288         while ((pv = TAILQ_FIRST(&m->md.pv_list)) != NULL) {
3289                 KKASSERT(pv->pv_m == m);
3290                 if (pv_hold_try(pv)) {
3291                         vm_page_spin_unlock(m);
3292                 } else {
3293                         vm_page_spin_unlock(m);
3294                         pv_lock(pv);
3295                         if (pv->pv_m != m) {
3296                                 pv_put(pv);
3297                                 vm_page_spin_lock(m);
3298                                 continue;
3299                         }
3300                 }
3301                 /*
3302                  * Holding no spinlocks, pv is locked.
3303                  */
3304                 pmap_remove_pv_pte(pv, NULL, &info);
3305                 pmap_remove_pv_page(pv);
3306                 pv_free(pv);
3307                 vm_page_spin_lock(m);
3308         }
3309         KKASSERT((m->flags & (PG_MAPPED|PG_WRITEABLE)) == 0);
3310         vm_page_spin_unlock(m);
3311         pmap_inval_done(&info);
3312 }
3313
3314 /*
3315  * Set the physical protection on the specified range of this map
3316  * as requested.  This function is typically only used for debug watchpoints
3317  * and COW pages.
3318  *
3319  * This function may not be called from an interrupt if the map is
3320  * not the kernel_pmap.
3321  *
3322  * NOTE!  For shared page table pages we just unmap the page.
3323  */
3324 void
3325 pmap_protect(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, vm_prot_t prot)
3326 {
3327         struct pmap_scan_info info;
3328         /* JG review for NX */
3329
3330         if (pmap == NULL)
3331                 return;
3332         if ((prot & VM_PROT_READ) == VM_PROT_NONE) {
3333                 pmap_remove(pmap, sva, eva);
3334                 return;
3335         }
3336         if (prot & VM_PROT_WRITE)
3337                 return;
3338         info.pmap = pmap;
3339         info.sva = sva;
3340         info.eva = eva;
3341         info.func = pmap_protect_callback;
3342         info.arg = &prot;
3343         pmap_scan(&info);
3344 }
3345
3346 static
3347 void
3348 pmap_protect_callback(pmap_t pmap, struct pmap_inval_info *info,
3349                       pv_entry_t pte_pv, pv_entry_t pt_pv, int sharept,
3350                       vm_offset_t va, pt_entry_t *ptep, void *arg __unused)
3351 {
3352         pt_entry_t pbits;
3353         pt_entry_t cbits;
3354         pt_entry_t pte;
3355         vm_page_t m;
3356
3357         /*
3358          * XXX non-optimal.
3359          */
3360         pmap_inval_interlock(info, pmap, va);
3361 again:
3362         pbits = *ptep;
3363         cbits = pbits;
3364         if (pte_pv) {
3365                 m = NULL;
3366                 if (pbits & PG_A) {
3367                         m = PHYS_TO_VM_PAGE(pbits & PG_FRAME);
3368                         KKASSERT(m == pte_pv->pv_m);
3369                         vm_page_flag_set(m, PG_REFERENCED);
3370                         cbits &= ~PG_A;
3371                 }
3372                 if (pbits & PG_M) {
3373                         if (pmap_track_modified(pte_pv->pv_pindex)) {
3374                                 if (m == NULL)
3375                                         m = PHYS_TO_VM_PAGE(pbits & PG_FRAME);
3376                                 vm_page_dirty(m);
3377                                 cbits &= ~PG_M;
3378                         }
3379                 }
3380         } else if (sharept) {
3381                 /*
3382                  * Unmanaged page table, pt_pv is actually the pd_pv
3383                  * for our pmap (not the share object pmap).
3384                  *
3385                  * When asked to protect something in a shared page table
3386                  * page we just unmap the page table page.  We have to
3387                  * invalidate the tlb in this situation.
3388                  */
3389                 pte = pte_load_clear(ptep);
3390                 pmap_inval_invltlb(info);
3391                 if (vm_page_unwire_quick(PHYS_TO_VM_PAGE(pte & PG_FRAME)))
3392                         panic("pmap_protect: pgtable1 pg bad wirecount");
3393                 if (vm_page_unwire_quick(pt_pv->pv_m))
3394                         panic("pmap_protect: pgtable2 pg bad wirecount");
3395                 ptep = NULL;
3396         }
3397         /* else unmanaged page, adjust bits, no wire changes */
3398
3399         if (ptep) {
3400                 cbits &= ~PG_RW;
3401                 if (pbits != cbits && !atomic_cmpset_long(ptep, pbits, cbits)) {
3402                         goto again;
3403                 }
3404         }
3405         pmap_inval_deinterlock(info, pmap);
3406         if (pte_pv)
3407                 pv_put(pte_pv);
3408 }
3409
3410 /*
3411  * Insert the vm_page (m) at the virtual address (va), replacing any prior
3412  * mapping at that address.  Set protection and wiring as requested.
3413  *
3414  * If entry is non-NULL we check to see if the SEG_SIZE optimization is
3415  * possible.  If it is we enter the page into the appropriate shared pmap
3416  * hanging off the related VM object instead of the passed pmap, then we
3417  * share the page table page from the VM object's pmap into the current pmap.
3418  *
3419  * NOTE: This routine MUST insert the page into the pmap now, it cannot
3420  *       lazy-evaluate.
3421  */
3422 void
3423 pmap_enter(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot,
3424            boolean_t wired, vm_map_entry_t entry __unused)
3425 {
3426         pmap_inval_info info;
3427         pv_entry_t pt_pv;       /* page table */
3428         pv_entry_t pte_pv;      /* page table entry */
3429         pt_entry_t *ptep;
3430         vm_paddr_t opa;
3431         pt_entry_t origpte, newpte;
3432         vm_paddr_t pa;
3433
3434         if (pmap == NULL)
3435                 return;
3436         va = trunc_page(va);
3437 #ifdef PMAP_DIAGNOSTIC
3438         if (va >= KvaEnd)
3439                 panic("pmap_enter: toobig");
3440         if ((va >= UPT_MIN_ADDRESS) && (va < UPT_MAX_ADDRESS))
3441                 panic("pmap_enter: invalid to pmap_enter page table "
3442                       "pages (va: 0x%lx)", va);
3443 #endif
3444         if (va < UPT_MAX_ADDRESS && pmap == &kernel_pmap) {
3445                 kprintf("Warning: pmap_enter called on UVA with "
3446                         "kernel_pmap\n");
3447 #ifdef DDB
3448                 db_print_backtrace();
3449 #endif
3450         }
3451         if (va >= UPT_MAX_ADDRESS && pmap != &kernel_pmap) {
3452                 kprintf("Warning: pmap_enter called on KVA without"
3453                         "kernel_pmap\n");
3454 #ifdef DDB
3455                 db_print_backtrace();
3456 #endif
3457         }
3458
3459         /*
3460          * Get locked PV entries for our new page table entry (pte_pv)
3461          * and for its parent page table (pt_pv).  We need the parent
3462          * so we can resolve the location of the ptep.
3463          *
3464          * Only hardware MMU actions can modify the ptep out from
3465          * under us.
3466          *
3467          * if (m) is fictitious or unmanaged we do not create a managing
3468          * pte_pv for it.  Any pre-existing page's management state must
3469          * match (avoiding code complexity).
3470          *
3471          * If the pmap is still being initialized we assume existing
3472          * page tables.
3473          *
3474          * Kernel mapppings do not track page table pages (i.e. pt_pv).
3475          * pmap_allocpte() checks the
3476          */
3477         if (pmap_initialized == FALSE) {
3478                 pte_pv = NULL;
3479                 pt_pv = NULL;
3480                 ptep = vtopte(va);
3481         } else if (m->flags & (PG_FICTITIOUS | PG_UNMANAGED)) { /* XXX */
3482                 pte_pv = NULL;
3483                 if (va >= VM_MAX_USER_ADDRESS) {
3484                         pt_pv = NULL;
3485                         ptep = vtopte(va);
3486                 } else {
3487                         pt_pv = pmap_allocpte_seg(pmap, pmap_pt_pindex(va),
3488                                                   NULL, entry, va);
3489                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(va));
3490                 }
3491                 KKASSERT(*ptep == 0 || (*ptep & PG_MANAGED) == 0);
3492         } else {
3493                 if (va >= VM_MAX_USER_ADDRESS) {
3494                         /*
3495                          * Kernel map, pv_entry-tracked.
3496                          */
3497                         pt_pv = NULL;
3498                         pte_pv = pmap_allocpte(pmap, pmap_pte_pindex(va), NULL);
3499                         ptep = vtopte(va);
3500                 } else {
3501                         /*
3502                          * User map
3503                          */
3504                         pte_pv = pmap_allocpte_seg(pmap, pmap_pte_pindex(va),
3505                                                    &pt_pv, entry, va);
3506                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(va));
3507                 }
3508                 KKASSERT(*ptep == 0 || (*ptep & PG_MANAGED));
3509         }
3510
3511         pa = VM_PAGE_TO_PHYS(m);
3512         origpte = *ptep;
3513         opa = origpte & PG_FRAME;
3514
3515         newpte = (pt_entry_t)(pa | pte_prot(pmap, prot) | PG_V | PG_A);
3516         if (wired)
3517                 newpte |= PG_W;
3518         if (va < VM_MAX_USER_ADDRESS)
3519                 newpte |= PG_U;
3520         if (pte_pv)
3521                 newpte |= PG_MANAGED;
3522         if (pmap == &kernel_pmap)
3523                 newpte |= pgeflag;
3524
3525         /*
3526          * It is possible for multiple faults to occur in threaded
3527          * environments, the existing pte might be correct.
3528          */
3529         if (((origpte ^ newpte) & ~(pt_entry_t)(PG_M|PG_A)) == 0)
3530                 goto done;
3531
3532         if ((prot & VM_PROT_NOSYNC) == 0)
3533                 pmap_inval_init(&info);
3534
3535         /*
3536          * Ok, either the address changed or the protection or wiring
3537          * changed.
3538          *
3539          * Clear the current entry, interlocking the removal.  For managed
3540          * pte's this will also flush the modified state to the vm_page.
3541          * Atomic ops are mandatory in order to ensure that PG_M events are
3542          * not lost during any transition.
3543          */
3544         if (opa) {
3545                 if (pte_pv) {
3546                         /*
3547                          * pmap_remove_pv_pte() unwires pt_pv and assumes
3548                          * we will free pte_pv, but since we are reusing
3549                          * pte_pv we want to retain the wire count.
3550                          *
3551                          * pt_pv won't exist for a kernel page (managed or
3552                          * otherwise).
3553                          */
3554                         if (pt_pv)
3555                                 vm_page_wire_quick(pt_pv->pv_m);
3556                         if (prot & VM_PROT_NOSYNC)
3557                                 pmap_remove_pv_pte(pte_pv, pt_pv, NULL);
3558                         else
3559                                 pmap_remove_pv_pte(pte_pv, pt_pv, &info);
3560                         if (pte_pv->pv_m)
3561                                 pmap_remove_pv_page(pte_pv);
3562                 } else if (prot & VM_PROT_NOSYNC) {
3563                         /*
3564                          * Unmanaged page, NOSYNC (no mmu sync) requested.
3565                          *
3566                          * Leave wire count on PT page intact.
3567                          */
3568                         (void)pte_load_clear(ptep);
3569                         cpu_invlpg((void *)va);
3570                         atomic_add_long(&pmap->pm_stats.resident_count, -1);
3571                 } else {
3572                         /*
3573                          * Unmanaged page, normal enter.
3574                          *
3575                          * Leave wire count on PT page intact.
3576                          */
3577                         pmap_inval_interlock(&info, pmap, va);
3578                         (void)pte_load_clear(ptep);
3579                         pmap_inval_deinterlock(&info, pmap);
3580                         atomic_add_long(&pmap->pm_stats.resident_count, -1);
3581                 }
3582                 KKASSERT(*ptep == 0);
3583         }
3584
3585         if (pte_pv) {
3586                 /*
3587                  * Enter on the PV list if part of our managed memory.
3588                  * Wiring of the PT page is already handled.
3589                  */
3590                 KKASSERT(pte_pv->pv_m == NULL);
3591                 vm_page_spin_lock(m);
3592                 pte_pv->pv_m = m;
3593                 TAILQ_INSERT_TAIL(&m->md.pv_list, pte_pv, pv_list);
3594                 /*
3595                 if (m->object)
3596                         atomic_add_int(&m->object->agg_pv_list_count, 1);
3597                 */
3598                 vm_page_flag_set(m, PG_MAPPED);
3599                 vm_page_spin_unlock(m);
3600         } else if (pt_pv && opa == 0) {
3601                 /*
3602                  * We have to adjust the wire count on the PT page ourselves
3603                  * for unmanaged entries.  If opa was non-zero we retained
3604                  * the existing wire count from the removal.
3605                  */
3606                 vm_page_wire_quick(pt_pv->pv_m);
3607         }
3608
3609         /*
3610          * Kernel VMAs (pt_pv == NULL) require pmap invalidation interlocks.
3611          *
3612          * User VMAs do not because those will be zero->non-zero, so no
3613          * stale entries to worry about at this point.
3614          *
3615          * For KVM there appear to still be issues.  Theoretically we
3616          * should be able to scrap the interlocks entirely but we
3617          * get crashes.
3618          */
3619         if ((prot & VM_PROT_NOSYNC) == 0 && pt_pv == NULL)
3620                 pmap_inval_interlock(&info, pmap, va);
3621
3622         /*
3623          * Set the pte
3624          */
3625         *(volatile pt_entry_t *)ptep = newpte;
3626
3627         if ((prot & VM_PROT_NOSYNC) == 0 && pt_pv == NULL)
3628                 pmap_inval_deinterlock(&info, pmap);
3629         else if (pt_pv == NULL)
3630                 cpu_invlpg((void *)va);
3631
3632         if (wired) {
3633                 if (pte_pv) {
3634                         atomic_add_long(&pte_pv->pv_pmap->pm_stats.wired_count,
3635                                         1);
3636                 } else {
3637                         atomic_add_long(&pmap->pm_stats.wired_count, 1);
3638                 }
3639         }
3640         if (newpte & PG_RW)
3641                 vm_page_flag_set(m, PG_WRITEABLE);
3642
3643         /*
3644          * Unmanaged pages need manual resident_count tracking.
3645          */
3646         if (pte_pv == NULL && pt_pv)
3647                 atomic_add_long(&pt_pv->pv_pmap->pm_stats.resident_count, 1);
3648
3649         /*
3650          * Cleanup
3651          */
3652         if ((prot & VM_PROT_NOSYNC) == 0 || pte_pv == NULL)
3653                 pmap_inval_done(&info);
3654 done:
3655         KKASSERT((newpte & PG_MANAGED) == 0 || (m->flags & PG_MAPPED));
3656
3657         /*
3658          * Cleanup the pv entry, allowing other accessors.
3659          */
3660         if (pte_pv)
3661                 pv_put(pte_pv);
3662         if (pt_pv)
3663                 pv_put(pt_pv);
3664 }
3665
3666 /*
3667  * This code works like pmap_enter() but assumes VM_PROT_READ and not-wired.
3668  * This code also assumes that the pmap has no pre-existing entry for this
3669  * VA.
3670  *
3671  * This code currently may only be used on user pmaps, not kernel_pmap.
3672  */
3673 void
3674 pmap_enter_quick(pmap_t pmap, vm_offset_t va, vm_page_t m)
3675 {
3676         pmap_enter(pmap, va, m, VM_PROT_READ, FALSE, NULL);
3677 }
3678
3679 /*
3680  * Make a temporary mapping for a physical address.  This is only intended
3681  * to be used for panic dumps.
3682  *
3683  * The caller is responsible for calling smp_invltlb().
3684  */
3685 void *
3686 pmap_kenter_temporary(vm_paddr_t pa, long i)
3687 {
3688         pmap_kenter_quick((vm_offset_t)crashdumpmap + (i * PAGE_SIZE), pa);
3689         return ((void *)crashdumpmap);
3690 }
3691
3692 #define MAX_INIT_PT (96)
3693
3694 /*
3695  * This routine preloads the ptes for a given object into the specified pmap.
3696  * This eliminates the blast of soft faults on process startup and
3697  * immediately after an mmap.
3698  */
3699 static int pmap_object_init_pt_callback(vm_page_t p, void *data);
3700
3701 void
3702 pmap_object_init_pt(pmap_t pmap, vm_offset_t addr, vm_prot_t prot,
3703                     vm_object_t object, vm_pindex_t pindex, 
3704                     vm_size_t size, int limit)
3705 {
3706         struct rb_vm_page_scan_info info;
3707         struct lwp *lp;
3708         vm_size_t psize;
3709
3710         /*
3711          * We can't preinit if read access isn't set or there is no pmap
3712          * or object.
3713          */
3714         if ((prot & VM_PROT_READ) == 0 || pmap == NULL || object == NULL)
3715                 return;
3716
3717         /*
3718          * We can't preinit if the pmap is not the current pmap
3719          */
3720         lp = curthread->td_lwp;
3721         if (lp == NULL || pmap != vmspace_pmap(lp->lwp_vmspace))
3722                 return;
3723
3724         /*
3725          * Misc additional checks
3726          */
3727         psize = x86_64_btop(size);
3728
3729         if ((object->type != OBJT_VNODE) ||
3730                 ((limit & MAP_PREFAULT_PARTIAL) && (psize > MAX_INIT_PT) &&
3731                         (object->resident_page_count > MAX_INIT_PT))) {
3732                 return;
3733         }
3734
3735         if (pindex + psize > object->size) {
3736                 if (object->size < pindex)
3737                         return;           
3738                 psize = object->size - pindex;
3739         }
3740
3741         if (psize == 0)
3742                 return;
3743
3744         /*
3745          * If everything is segment-aligned do not pre-init here.  Instead
3746          * allow the normal vm_fault path to pass a segment hint to
3747          * pmap_enter() which will then use an object-referenced shared
3748          * page table page.
3749          */
3750         if ((addr & SEG_MASK) == 0 &&
3751             (ctob(psize) & SEG_MASK) == 0 &&
3752             (ctob(pindex) & SEG_MASK) == 0) {
3753                 return;
3754         }
3755
3756         /*
3757          * Use a red-black scan to traverse the requested range and load
3758          * any valid pages found into the pmap.
3759          *
3760          * We cannot safely scan the object's memq without holding the
3761          * object token.
3762          */
3763         info.start_pindex = pindex;
3764         info.end_pindex = pindex + psize - 1;
3765         info.limit = limit;
3766         info.mpte = NULL;
3767         info.addr = addr;
3768         info.pmap = pmap;
3769
3770         vm_object_hold_shared(object);
3771         vm_page_rb_tree_RB_SCAN(&object->rb_memq, rb_vm_page_scancmp,
3772                                 pmap_object_init_pt_callback, &info);
3773         vm_object_drop(object);
3774 }
3775
3776 static
3777 int
3778 pmap_object_init_pt_callback(vm_page_t p, void *data)
3779 {
3780         struct rb_vm_page_scan_info *info = data;
3781         vm_pindex_t rel_index;
3782
3783         /*
3784          * don't allow an madvise to blow away our really
3785          * free pages allocating pv entries.
3786          */
3787         if ((info->limit & MAP_PREFAULT_MADVISE) &&
3788                 vmstats.v_free_count < vmstats.v_free_reserved) {
3789                     return(-1);
3790         }
3791
3792         /*
3793          * Ignore list markers and ignore pages we cannot instantly
3794          * busy (while holding the object token).
3795          */
3796         if (p->flags & PG_MARKER)
3797                 return 0;
3798         if (vm_page_busy_try(p, TRUE))
3799                 return 0;
3800         if (((p->valid & VM_PAGE_BITS_ALL) == VM_PAGE_BITS_ALL) &&
3801             (p->flags & PG_FICTITIOUS) == 0) {
3802                 if ((p->queue - p->pc) == PQ_CACHE)
3803                         vm_page_deactivate(p);
3804                 rel_index = p->pindex - info->start_pindex;
3805                 pmap_enter_quick(info->pmap,
3806                                  info->addr + x86_64_ptob(rel_index), p);
3807         }
3808         vm_page_wakeup(p);
3809         lwkt_yield();
3810         return(0);
3811 }
3812
3813 /*
3814  * Return TRUE if the pmap is in shape to trivially pre-fault the specified
3815  * address.
3816  *
3817  * Returns FALSE if it would be non-trivial or if a pte is already loaded
3818  * into the slot.
3819  *
3820  * XXX This is safe only because page table pages are not freed.
3821  */
3822 int
3823 pmap_prefault_ok(pmap_t pmap, vm_offset_t addr)
3824 {
3825         pt_entry_t *pte;
3826
3827         /*spin_lock(&pmap->pm_spin);*/
3828         if ((pte = pmap_pte(pmap, addr)) != NULL) {
3829                 if (*pte & PG_V) {
3830                         /*spin_unlock(&pmap->pm_spin);*/
3831                         return FALSE;
3832                 }
3833         }
3834         /*spin_unlock(&pmap->pm_spin);*/
3835         return TRUE;
3836 }
3837
3838 /*
3839  * Change the wiring attribute for a pmap/va pair.  The mapping must already
3840  * exist in the pmap.  The mapping may or may not be managed.
3841  */
3842 void
3843 pmap_change_wiring(pmap_t pmap, vm_offset_t va, boolean_t wired,
3844                    vm_map_entry_t entry)
3845 {
3846         pt_entry_t *ptep;
3847         pv_entry_t pv;
3848
3849         if (pmap == NULL)
3850                 return;
3851         lwkt_gettoken(&pmap->pm_token);
3852         pv = pmap_allocpte_seg(pmap, pmap_pt_pindex(va), NULL, entry, va);
3853         ptep = pv_pte_lookup(pv, pmap_pte_index(va));
3854
3855         if (wired && !pmap_pte_w(ptep))
3856                 atomic_add_long(&pv->pv_pmap->pm_stats.wired_count, 1);
3857         else if (!wired && pmap_pte_w(ptep))
3858                 atomic_add_long(&pv->pv_pmap->pm_stats.wired_count, -1);
3859
3860         /*
3861          * Wiring is not a hardware characteristic so there is no need to
3862          * invalidate TLB.  However, in an SMP environment we must use
3863          * a locked bus cycle to update the pte (if we are not using 
3864          * the pmap_inval_*() API that is)... it's ok to do this for simple
3865          * wiring changes.
3866          */
3867 #ifdef SMP
3868         if (wired)
3869                 atomic_set_long(ptep, PG_W);
3870         else
3871                 atomic_clear_long(ptep, PG_W);
3872 #else
3873         if (wired)
3874                 atomic_set_long_nonlocked(ptep, PG_W);
3875         else
3876                 atomic_clear_long_nonlocked(ptep, PG_W);
3877 #endif
3878         pv_put(pv);
3879         lwkt_reltoken(&pmap->pm_token);
3880 }
3881
3882
3883
3884 /*
3885  * Copy the range specified by src_addr/len from the source map to
3886  * the range dst_addr/len in the destination map.
3887  *
3888  * This routine is only advisory and need not do anything.
3889  */
3890 void
3891 pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr, 
3892           vm_size_t len, vm_offset_t src_addr)
3893 {
3894 }       
3895
3896 /*
3897  * pmap_zero_page:
3898  *
3899  *      Zero the specified physical page.
3900  *
3901  *      This function may be called from an interrupt and no locking is
3902  *      required.
3903  */
3904 void
3905 pmap_zero_page(vm_paddr_t phys)
3906 {
3907         vm_offset_t va = PHYS_TO_DMAP(phys);
3908
3909         pagezero((void *)va);
3910 }
3911
3912 /*
3913  * pmap_page_assertzero:
3914  *
3915  *      Assert that a page is empty, panic if it isn't.
3916  */
3917 void
3918 pmap_page_assertzero(vm_paddr_t phys)
3919 {
3920         vm_offset_t va = PHYS_TO_DMAP(phys);
3921         size_t i;
3922
3923         for (i = 0; i < PAGE_SIZE; i += sizeof(long)) {
3924                 if (*(long *)((char *)va + i) != 0) {