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