initial commit
[freebsd-arm:freebsd-arm.git] / arm / arm / pmap.c
1 /* From: $NetBSD: pmap.c,v 1.148 2004/04/03 04:35:48 bsh Exp $ */
2 /*-
3  * Copyright 2004 Olivier Houchard.
4  * Copyright 2003 Wasabi Systems, Inc.
5  * All rights reserved.
6  *
7  * Written by Steve C. Woodford for Wasabi Systems, Inc.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *      This product includes software developed for the NetBSD Project by
20  *      Wasabi Systems, Inc.
21  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
22  *    or promote products derived from this software without specific prior
23  *    written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
27  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35  * POSSIBILITY OF SUCH DAMAGE.
36  */
37
38 /*-
39  * Copyright (c) 2002-2003 Wasabi Systems, Inc.
40  * Copyright (c) 2001 Richard Earnshaw
41  * Copyright (c) 2001-2002 Christopher Gilbert
42  * All rights reserved.
43  *
44  * 1. Redistributions of source code must retain the above copyright
45  *    notice, this list of conditions and the following disclaimer.
46  * 2. Redistributions in binary form must reproduce the above copyright
47  *    notice, this list of conditions and the following disclaimer in the
48  *    documentation and/or other materials provided with the distribution.
49  * 3. The name of the company nor the name of the author may be used to
50  *    endorse or promote products derived from this software without specific
51  *    prior written permission.
52  *
53  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
54  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
55  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
56  * IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
57  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
58  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
59  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
61  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
62  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
63  * SUCH DAMAGE.
64  */
65 /*-
66  * Copyright (c) 1999 The NetBSD Foundation, Inc.
67  * All rights reserved.
68  *
69  * This code is derived from software contributed to The NetBSD Foundation
70  * by Charles M. Hannum.
71  *
72  * Redistribution and use in source and binary forms, with or without
73  * modification, are permitted provided that the following conditions
74  * are met:
75  * 1. Redistributions of source code must retain the above copyright
76  *    notice, this list of conditions and the following disclaimer.
77  * 2. Redistributions in binary form must reproduce the above copyright
78  *    notice, this list of conditions and the following disclaimer in the
79  *    documentation and/or other materials provided with the distribution.
80  * 3. All advertising materials mentioning features or use of this software
81  *    must display the following acknowledgement:
82  *        This product includes software developed by the NetBSD
83  *        Foundation, Inc. and its contributors.
84  * 4. Neither the name of The NetBSD Foundation nor the names of its
85  *    contributors may be used to endorse or promote products derived
86  *    from this software without specific prior written permission.
87  *
88  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
89  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
90  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
91  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
92  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
93  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
94  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
95  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
96  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
97  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
98  * POSSIBILITY OF SUCH DAMAGE.
99  */
100
101 /*-
102  * Copyright (c) 1994-1998 Mark Brinicombe.
103  * Copyright (c) 1994 Brini.
104  * All rights reserved.
105  *
106  * This code is derived from software written for Brini by Mark Brinicombe
107  *
108  * Redistribution and use in source and binary forms, with or without
109  * modification, are permitted provided that the following conditions
110  * are met:
111  * 1. Redistributions of source code must retain the above copyright
112  *    notice, this list of conditions and the following disclaimer.
113  * 2. Redistributions in binary form must reproduce the above copyright
114  *    notice, this list of conditions and the following disclaimer in the
115  *    documentation and/or other materials provided with the distribution.
116  * 3. All advertising materials mentioning features or use of this software
117  *    must display the following acknowledgement:
118  *      This product includes software developed by Mark Brinicombe.
119  * 4. The name of the author may not be used to endorse or promote products
120  *    derived from this software without specific prior written permission.
121  *
122  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
123  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
124  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
125  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
126  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
127  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
128  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
129  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
130  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
131  *
132  * RiscBSD kernel project
133  *
134  * pmap.c
135  *
136  * Machine dependant vm stuff
137  *
138  * Created      : 20/09/94
139  */
140
141 /*
142  * Special compilation symbols
143  * PMAP_DEBUG           - Build in pmap_debug_level code
144  */
145 /* Include header files */
146
147 #include "opt_vm.h"
148
149 #include <sys/cdefs.h>
150 __FBSDID("$FreeBSD$");
151 #include <sys/param.h>
152 #include <sys/systm.h>
153 #include <sys/kernel.h>
154 #include <sys/ktr.h>
155 #include <sys/proc.h>
156 #include <sys/malloc.h>
157 #include <sys/msgbuf.h>
158 #include <sys/vmmeter.h>
159 #include <sys/mman.h>
160 #include <sys/smp.h>
161 #include <sys/sched.h>
162
163 #include <vm/vm.h>
164 #include <vm/uma.h>
165 #include <vm/pmap.h>
166 #include <vm/vm_kern.h>
167 #include <vm/vm_object.h>
168 #include <vm/vm_map.h>
169 #include <vm/vm_page.h>
170 #include <vm/vm_pageout.h>
171 #include <vm/vm_extern.h>
172 #include <sys/lock.h>
173 #include <sys/mutex.h>
174 #include <machine/md_var.h>
175 #include <machine/vmparam.h>
176 #include <machine/cpu.h>
177 #include <machine/cpufunc.h>
178 #include <machine/pcb.h>
179
180 #define PMAP_DEBUG
181
182 #ifdef PMAP_DEBUG
183 #define PDEBUG(_lev_,_stat_) \
184         if (pmap_debug_level >= (_lev_)) \
185                 ((_stat_))
186 #define dprintf printf
187
188 int pmap_debug_level = 0;
189 #define PMAP_INLINE 
190 #else   /* PMAP_DEBUG */
191 #define PDEBUG(_lev_,_stat_) /* Nothing */
192 #define dprintf(x, arg...)
193 #define PMAP_INLINE __inline
194 #endif  /* PMAP_DEBUG */
195
196 extern struct pv_addr systempage;
197 /*
198  * Internal function prototypes
199  */
200 static void pmap_free_pv_entry (pv_entry_t);
201 static pv_entry_t pmap_get_pv_entry(void);
202
203 static void             pmap_enter_locked(pmap_t, vm_offset_t, vm_page_t,
204     vm_prot_t, boolean_t, int);
205 static void             pmap_fix_cache(struct vm_page *, pmap_t, vm_offset_t);
206 static void             pmap_alloc_l1(pmap_t);
207 static void             pmap_free_l1(pmap_t);
208
209 static int              pmap_clearbit(struct vm_page *, u_int);
210
211 static struct l2_bucket *pmap_get_l2_bucket(pmap_t, vm_offset_t);
212 static struct l2_bucket *pmap_alloc_l2_bucket(pmap_t, vm_offset_t);
213 static void             pmap_free_l2_bucket(pmap_t, struct l2_bucket *, u_int);
214 static vm_offset_t      kernel_pt_lookup(vm_paddr_t);
215
216 static MALLOC_DEFINE(M_VMPMAP, "pmap", "PMAP L1");
217
218 vm_offset_t virtual_avail;      /* VA of first avail page (after kernel bss) */
219 vm_offset_t virtual_end;        /* VA of last avail page (end of kernel AS) */
220 vm_offset_t pmap_curmaxkvaddr;
221 vm_paddr_t kernel_l1pa;
222
223 extern void *end;
224 vm_offset_t kernel_vm_end = 0;
225
226 struct pmap kernel_pmap_store;
227
228 static pt_entry_t *csrc_pte, *cdst_pte;
229 static vm_offset_t csrcp, cdstp;
230 static struct mtx cmtx;
231
232 static void             pmap_init_l1(struct l1_ttable *, pd_entry_t *);
233 /*
234  * These routines are called when the CPU type is identified to set up
235  * the PTE prototypes, cache modes, etc.
236  *
237  * The variables are always here, just in case LKMs need to reference
238  * them (though, they shouldn't).
239  */
240
241 pt_entry_t      pte_l1_s_cache_mode;
242 pt_entry_t      pte_l1_s_cache_mode_pt;
243 pt_entry_t      pte_l1_s_cache_mask;
244
245 pt_entry_t      pte_l2_l_cache_mode;
246 pt_entry_t      pte_l2_l_cache_mode_pt;
247 pt_entry_t      pte_l2_l_cache_mask;
248
249 pt_entry_t      pte_l2_s_cache_mode;
250 pt_entry_t      pte_l2_s_cache_mode_pt;
251 pt_entry_t      pte_l2_s_cache_mask;
252
253 pt_entry_t      pte_l2_s_prot_u;
254 pt_entry_t      pte_l2_s_prot_w;
255 pt_entry_t      pte_l2_s_prot_mask;
256
257 pt_entry_t      pte_l1_s_proto;
258 pt_entry_t      pte_l1_c_proto;
259 pt_entry_t      pte_l2_s_proto;
260
261 void            (*pmap_copy_page_func)(vm_paddr_t, vm_paddr_t);
262 void            (*pmap_zero_page_func)(vm_paddr_t, int, int);
263 /*
264  * Which pmap is currently 'live' in the cache
265  *
266  * XXXSCW: Fix for SMP ...
267  */
268 union pmap_cache_state *pmap_cache_state;
269
270 struct msgbuf *msgbufp = 0;
271
272 /*
273  * Crashdump maps.
274  */
275 static caddr_t crashdumpmap;
276
277 extern void bcopy_page(vm_offset_t, vm_offset_t);
278 extern void bzero_page(vm_offset_t);
279
280 extern vm_offset_t alloc_firstaddr;
281
282 char *_tmppt;
283
284 /*
285  * Metadata for L1 translation tables.
286  */
287 struct l1_ttable {
288         /* Entry on the L1 Table list */
289         SLIST_ENTRY(l1_ttable) l1_link;
290
291         /* Entry on the L1 Least Recently Used list */
292         TAILQ_ENTRY(l1_ttable) l1_lru;
293
294         /* Track how many domains are allocated from this L1 */
295         volatile u_int l1_domain_use_count;
296
297         /*
298          * A free-list of domain numbers for this L1.
299          * We avoid using ffs() and a bitmap to track domains since ffs()
300          * is slow on ARM.
301          */
302         u_int8_t l1_domain_first;
303         u_int8_t l1_domain_free[PMAP_DOMAINS];
304
305         /* Physical address of this L1 page table */
306         vm_paddr_t l1_physaddr;
307
308         /* KVA of this L1 page table */
309         pd_entry_t *l1_kva;
310 };
311
312 /*
313  * Convert a virtual address into its L1 table index. That is, the
314  * index used to locate the L2 descriptor table pointer in an L1 table.
315  * This is basically used to index l1->l1_kva[].
316  *
317  * Each L2 descriptor table represents 1MB of VA space.
318  */
319 #define L1_IDX(va)              (((vm_offset_t)(va)) >> L1_S_SHIFT)
320
321 /*
322  * L1 Page Tables are tracked using a Least Recently Used list.
323  *  - New L1s are allocated from the HEAD.
324  *  - Freed L1s are added to the TAIl.
325  *  - Recently accessed L1s (where an 'access' is some change to one of
326  *    the userland pmaps which owns this L1) are moved to the TAIL.
327  */
328 static TAILQ_HEAD(, l1_ttable) l1_lru_list;
329 /*
330  * A list of all L1 tables
331  */
332 static SLIST_HEAD(, l1_ttable) l1_list;
333 static struct mtx l1_lru_lock;
334
335 /*
336  * The l2_dtable tracks L2_BUCKET_SIZE worth of L1 slots.
337  *
338  * This is normally 16MB worth L2 page descriptors for any given pmap.
339  * Reference counts are maintained for L2 descriptors so they can be
340  * freed when empty.
341  */
342 struct l2_dtable {
343         /* The number of L2 page descriptors allocated to this l2_dtable */
344         u_int l2_occupancy;
345
346         /* List of L2 page descriptors */
347         struct l2_bucket {
348                 pt_entry_t *l2b_kva;    /* KVA of L2 Descriptor Table */
349                 vm_paddr_t l2b_phys;    /* Physical address of same */
350                 u_short l2b_l1idx;      /* This L2 table's L1 index */
351                 u_short l2b_occupancy;  /* How many active descriptors */
352         } l2_bucket[L2_BUCKET_SIZE];
353 };
354
355 /* pmap_kenter_internal flags */
356 #define KENTER_CACHE    0x1
357 #define KENTER_USER     0x2
358
359 /*
360  * Given an L1 table index, calculate the corresponding l2_dtable index
361  * and bucket index within the l2_dtable.
362  */
363 #define L2_IDX(l1idx)           (((l1idx) >> L2_BUCKET_LOG2) & \
364                                  (L2_SIZE - 1))
365 #define L2_BUCKET(l1idx)        ((l1idx) & (L2_BUCKET_SIZE - 1))
366
367 /*
368  * Given a virtual address, this macro returns the
369  * virtual address required to drop into the next L2 bucket.
370  */
371 #define L2_NEXT_BUCKET(va)      (((va) & L1_S_FRAME) + L1_S_SIZE)
372
373 /*
374  * L2 allocation.
375  */
376 #define pmap_alloc_l2_dtable()          \
377                 (void*)uma_zalloc(l2table_zone, M_NOWAIT|M_USE_RESERVE)
378 #define pmap_free_l2_dtable(l2)         \
379                 uma_zfree(l2table_zone, l2)
380
381 /*
382  * We try to map the page tables write-through, if possible.  However, not
383  * all CPUs have a write-through cache mode, so on those we have to sync
384  * the cache when we frob page tables.
385  *
386  * We try to evaluate this at compile time, if possible.  However, it's
387  * not always possible to do that, hence this run-time var.
388  */
389 int     pmap_needs_pte_sync;
390
391 /*
392  * Macro to determine if a mapping might be resident in the
393  * instruction cache and/or TLB
394  */
395 #define PV_BEEN_EXECD(f)  (((f) & (PVF_REF | PVF_EXEC)) == (PVF_REF | PVF_EXEC))
396
397 /*
398  * Macro to determine if a mapping might be resident in the
399  * data cache and/or TLB
400  */
401 #define PV_BEEN_REFD(f)   (((f) & PVF_REF) != 0)
402
403 #ifndef PMAP_SHPGPERPROC
404 #define PMAP_SHPGPERPROC 200
405 #endif
406
407 #define pmap_is_current(pm)     ((pm) == pmap_kernel() || \
408             curproc->p_vmspace->vm_map.pmap == (pm))
409 static uma_zone_t pvzone = NULL;
410 uma_zone_t l2zone;
411 static uma_zone_t l2table_zone;
412 static vm_offset_t pmap_kernel_l2dtable_kva;
413 static vm_offset_t pmap_kernel_l2ptp_kva;
414 static vm_paddr_t pmap_kernel_l2ptp_phys;
415 static struct vm_object pvzone_obj;
416 static int pv_entry_count=0, pv_entry_max=0, pv_entry_high_water=0;
417
418 /*
419  * This list exists for the benefit of pmap_map_chunk().  It keeps track
420  * of the kernel L2 tables during bootstrap, so that pmap_map_chunk() can
421  * find them as necessary.
422  *
423  * Note that the data on this list MUST remain valid after initarm() returns,
424  * as pmap_bootstrap() uses it to contruct L2 table metadata.
425  */
426 SLIST_HEAD(, pv_addr) kernel_pt_list = SLIST_HEAD_INITIALIZER(kernel_pt_list);
427
428 static void
429 pmap_init_l1(struct l1_ttable *l1, pd_entry_t *l1pt)
430 {
431         int i;
432
433         l1->l1_kva = l1pt;
434         l1->l1_domain_use_count = 0;
435         l1->l1_domain_first = 0;
436
437         for (i = 0; i < PMAP_DOMAINS; i++)
438                 l1->l1_domain_free[i] = i + 1;
439
440         /*
441          * Copy the kernel's L1 entries to each new L1.
442          */
443         if (l1pt != pmap_kernel()->pm_l1->l1_kva)
444                 memcpy(l1pt, pmap_kernel()->pm_l1->l1_kva, L1_TABLE_SIZE);
445
446         if ((l1->l1_physaddr = pmap_extract(pmap_kernel(), (vm_offset_t)l1pt)) == 0)
447                 panic("pmap_init_l1: can't get PA of L1 at %p", l1pt);
448         SLIST_INSERT_HEAD(&l1_list, l1, l1_link);
449         TAILQ_INSERT_TAIL(&l1_lru_list, l1, l1_lru);
450 }
451
452 static vm_offset_t
453 kernel_pt_lookup(vm_paddr_t pa)
454 {
455         struct pv_addr *pv;
456
457         SLIST_FOREACH(pv, &kernel_pt_list, pv_list) {
458                 if (pv->pv_pa == pa)
459                         return (pv->pv_va);
460         }
461         return (0);
462 }
463
464 #if (ARM_MMU_GENERIC + ARM_MMU_SA1) != 0
465 void
466 pmap_pte_init_generic(void)
467 {
468
469         pte_l1_s_cache_mode = L1_S_B|L1_S_C;
470         pte_l1_s_cache_mask = L1_S_CACHE_MASK_generic;
471
472         pte_l2_l_cache_mode = L2_B|L2_C;
473         pte_l2_l_cache_mask = L2_L_CACHE_MASK_generic;
474
475         pte_l2_s_cache_mode = L2_B|L2_C;
476         pte_l2_s_cache_mask = L2_S_CACHE_MASK_generic;
477
478         /*
479          * If we have a write-through cache, set B and C.  If
480          * we have a write-back cache, then we assume setting
481          * only C will make those pages write-through.
482          */
483         if (cpufuncs.cf_dcache_wb_range == (void *) cpufunc_nullop) {
484                 pte_l1_s_cache_mode_pt = L1_S_B|L1_S_C;
485                 pte_l2_l_cache_mode_pt = L2_B|L2_C;
486                 pte_l2_s_cache_mode_pt = L2_B|L2_C;
487         } else {
488                 pte_l1_s_cache_mode_pt = L1_S_C;
489                 pte_l2_l_cache_mode_pt = L2_C;
490                 pte_l2_s_cache_mode_pt = L2_C;
491         }
492
493         pte_l2_s_prot_u = L2_S_PROT_U_generic;
494         pte_l2_s_prot_w = L2_S_PROT_W_generic;
495         pte_l2_s_prot_mask = L2_S_PROT_MASK_generic;
496
497         pte_l1_s_proto = L1_S_PROTO_generic;
498         pte_l1_c_proto = L1_C_PROTO_generic;
499         pte_l2_s_proto = L2_S_PROTO_generic;
500
501         pmap_copy_page_func = pmap_copy_page_generic;
502         pmap_zero_page_func = pmap_zero_page_generic;
503 }
504
505 #if defined(CPU_ARM8)
506 void
507 pmap_pte_init_arm8(void)
508 {
509
510         /*
511          * ARM8 is compatible with generic, but we need to use
512          * the page tables uncached.
513          */
514         pmap_pte_init_generic();
515
516         pte_l1_s_cache_mode_pt = 0;
517         pte_l2_l_cache_mode_pt = 0;
518         pte_l2_s_cache_mode_pt = 0;
519 }
520 #endif /* CPU_ARM8 */
521
522 #if defined(CPU_ARM9) && defined(ARM9_CACHE_WRITE_THROUGH)
523 void
524 pmap_pte_init_arm9(void)
525 {
526
527         /*
528          * ARM9 is compatible with generic, but we want to use
529          * write-through caching for now.
530          */
531         pmap_pte_init_generic();
532
533         pte_l1_s_cache_mode = L1_S_C;
534         pte_l2_l_cache_mode = L2_C;
535         pte_l2_s_cache_mode = L2_C;
536
537         pte_l1_s_cache_mode_pt = L1_S_C;
538         pte_l2_l_cache_mode_pt = L2_C;
539         pte_l2_s_cache_mode_pt = L2_C;
540 }
541 #endif /* CPU_ARM9 */
542 #endif /* (ARM_MMU_GENERIC + ARM_MMU_SA1) != 0 */
543
544 #if defined(CPU_ARM10)
545 void
546 pmap_pte_init_arm10(void)
547 {
548
549         /*
550          * ARM10 is compatible with generic, but we want to use
551          * write-through caching for now.
552          */
553         pmap_pte_init_generic();
554
555         pte_l1_s_cache_mode = L1_S_B | L1_S_C;
556         pte_l2_l_cache_mode = L2_B | L2_C;
557         pte_l2_s_cache_mode = L2_B | L2_C;
558
559         pte_l1_s_cache_mode_pt = L1_S_C;
560         pte_l2_l_cache_mode_pt = L2_C;
561         pte_l2_s_cache_mode_pt = L2_C;
562
563 }
564 #endif /* CPU_ARM10 */
565
566 #if  ARM_MMU_SA1 == 1
567 void
568 pmap_pte_init_sa1(void)
569 {
570
571         /*
572          * The StrongARM SA-1 cache does not have a write-through
573          * mode.  So, do the generic initialization, then reset
574          * the page table cache mode to B=1,C=1, and note that
575          * the PTEs need to be sync'd.
576          */
577         pmap_pte_init_generic();
578
579         pte_l1_s_cache_mode_pt = L1_S_B|L1_S_C;
580         pte_l2_l_cache_mode_pt = L2_B|L2_C;
581         pte_l2_s_cache_mode_pt = L2_B|L2_C;
582
583         pmap_needs_pte_sync = 1;
584 }
585 #endif /* ARM_MMU_SA1 == 1*/
586
587 #if ARM_MMU_XSCALE == 1
588 #if (ARM_NMMUS > 1) || defined (CPU_XSCALE_CORE3)
589 static u_int xscale_use_minidata;
590 #endif
591
592 void
593 pmap_pte_init_xscale(void)
594 {
595         uint32_t auxctl;
596         int write_through = 0;
597
598         pte_l1_s_cache_mode = L1_S_B|L1_S_C|L1_S_XSCALE_P;
599         pte_l1_s_cache_mask = L1_S_CACHE_MASK_xscale;
600
601         pte_l2_l_cache_mode = L2_B|L2_C;
602         pte_l2_l_cache_mask = L2_L_CACHE_MASK_xscale;
603
604         pte_l2_s_cache_mode = L2_B|L2_C;
605         pte_l2_s_cache_mask = L2_S_CACHE_MASK_xscale;
606
607         pte_l1_s_cache_mode_pt = L1_S_C;
608         pte_l2_l_cache_mode_pt = L2_C;
609         pte_l2_s_cache_mode_pt = L2_C;
610 #ifdef XSCALE_CACHE_READ_WRITE_ALLOCATE
611         /*
612          * The XScale core has an enhanced mode where writes that
613          * miss the cache cause a cache line to be allocated.  This
614          * is significantly faster than the traditional, write-through
615          * behavior of this case.
616          */
617         pte_l1_s_cache_mode |= L1_S_XSCALE_TEX(TEX_XSCALE_X);
618         pte_l2_l_cache_mode |= L2_XSCALE_L_TEX(TEX_XSCALE_X);
619         pte_l2_s_cache_mode |= L2_XSCALE_T_TEX(TEX_XSCALE_X);
620 #endif /* XSCALE_CACHE_READ_WRITE_ALLOCATE */
621 #ifdef XSCALE_CACHE_WRITE_THROUGH
622         /*
623          * Some versions of the XScale core have various bugs in
624          * their cache units, the work-around for which is to run
625          * the cache in write-through mode.  Unfortunately, this
626          * has a major (negative) impact on performance.  So, we
627          * go ahead and run fast-and-loose, in the hopes that we
628          * don't line up the planets in a way that will trip the
629          * bugs.
630          *
631          * However, we give you the option to be slow-but-correct.
632          */
633         write_through = 1;
634 #elif defined(XSCALE_CACHE_WRITE_BACK)
635         /* force write back cache mode */
636         write_through = 0;
637 #elif defined(CPU_XSCALE_PXA2X0)
638         /*
639          * Intel PXA2[15]0 processors are known to have a bug in
640          * write-back cache on revision 4 and earlier (stepping
641          * A[01] and B[012]).  Fixed for C0 and later.
642          */
643         {
644                 uint32_t id, type;
645
646                 id = cpufunc_id();
647                 type = id & ~(CPU_ID_XSCALE_COREREV_MASK|CPU_ID_REVISION_MASK);
648
649                 if (type == CPU_ID_PXA250 || type == CPU_ID_PXA210) {
650                         if ((id & CPU_ID_REVISION_MASK) < 5) {
651                                 /* write through for stepping A0-1 and B0-2 */
652                                 write_through = 1;
653                         }
654                 }
655         }
656 #endif /* XSCALE_CACHE_WRITE_THROUGH */
657
658         if (write_through) {
659                 pte_l1_s_cache_mode = L1_S_C;
660                 pte_l2_l_cache_mode = L2_C;
661                 pte_l2_s_cache_mode = L2_C;
662         }
663
664 #if (ARM_NMMUS > 1)
665         xscale_use_minidata = 1;
666 #endif
667
668         pte_l2_s_prot_u = L2_S_PROT_U_xscale;
669         pte_l2_s_prot_w = L2_S_PROT_W_xscale;
670         pte_l2_s_prot_mask = L2_S_PROT_MASK_xscale;
671
672         pte_l1_s_proto = L1_S_PROTO_xscale;
673         pte_l1_c_proto = L1_C_PROTO_xscale;
674         pte_l2_s_proto = L2_S_PROTO_xscale;
675
676 #ifdef CPU_XSCALE_CORE3
677         pmap_copy_page_func = pmap_copy_page_generic;
678         pmap_zero_page_func = pmap_zero_page_generic;
679         xscale_use_minidata = 0;
680         /* Make sure it is L2-cachable */
681         pte_l1_s_cache_mode |= L1_S_XSCALE_TEX(TEX_XSCALE_T);
682         pte_l1_s_cache_mode_pt = pte_l1_s_cache_mode &~ L1_S_XSCALE_P;
683         pte_l2_l_cache_mode |= L2_XSCALE_L_TEX(TEX_XSCALE_T) ;
684         pte_l2_l_cache_mode_pt = pte_l1_s_cache_mode;
685         pte_l2_s_cache_mode |= L2_XSCALE_T_TEX(TEX_XSCALE_T);
686         pte_l2_s_cache_mode_pt = pte_l2_s_cache_mode;
687
688 #else
689         pmap_copy_page_func = pmap_copy_page_xscale;
690         pmap_zero_page_func = pmap_zero_page_xscale;
691 #endif
692
693         /*
694          * Disable ECC protection of page table access, for now.
695          */
696         __asm __volatile("mrc p15, 0, %0, c1, c0, 1" : "=r" (auxctl));
697         auxctl &= ~XSCALE_AUXCTL_P;
698         __asm __volatile("mcr p15, 0, %0, c1, c0, 1" : : "r" (auxctl));
699 }
700
701 /*
702  * xscale_setup_minidata:
703  *
704  *      Set up the mini-data cache clean area.  We require the
705  *      caller to allocate the right amount of physically and
706  *      virtually contiguous space.
707  */
708 extern vm_offset_t xscale_minidata_clean_addr;
709 extern vm_size_t xscale_minidata_clean_size; /* already initialized */
710 void
711 xscale_setup_minidata(vm_offset_t l1pt, vm_offset_t va, vm_paddr_t pa)
712 {
713         pd_entry_t *pde = (pd_entry_t *) l1pt;
714         pt_entry_t *pte;
715         vm_size_t size;
716         uint32_t auxctl;
717
718         xscale_minidata_clean_addr = va;
719
720         /* Round it to page size. */
721         size = (xscale_minidata_clean_size + L2_S_OFFSET) & L2_S_FRAME;
722
723         for (; size != 0;
724              va += L2_S_SIZE, pa += L2_S_SIZE, size -= L2_S_SIZE) {
725                 pte = (pt_entry_t *) kernel_pt_lookup(
726                     pde[L1_IDX(va)] & L1_C_ADDR_MASK);
727                 if (pte == NULL)
728                         panic("xscale_setup_minidata: can't find L2 table for "
729                             "VA 0x%08x", (u_int32_t) va);
730                 pte[l2pte_index(va)] =
731                     L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, VM_PROT_READ) |
732                     L2_C | L2_XSCALE_T_TEX(TEX_XSCALE_X);
733         }
734
735         /*
736          * Configure the mini-data cache for write-back with
737          * read/write-allocate.
738          *
739          * NOTE: In order to reconfigure the mini-data cache, we must
740          * make sure it contains no valid data!  In order to do that,
741          * we must issue a global data cache invalidate command!
742          *
743          * WE ASSUME WE ARE RUNNING UN-CACHED WHEN THIS ROUTINE IS CALLED!
744          * THIS IS VERY IMPORTANT!
745          */
746
747         /* Invalidate data and mini-data. */
748         __asm __volatile("mcr p15, 0, %0, c7, c6, 0" : : "r" (0));
749         __asm __volatile("mrc p15, 0, %0, c1, c0, 1" : "=r" (auxctl));
750         auxctl = (auxctl & ~XSCALE_AUXCTL_MD_MASK) | XSCALE_AUXCTL_MD_WB_RWA;
751         __asm __volatile("mcr p15, 0, %0, c1, c0, 1" : : "r" (auxctl));
752 }
753 #endif
754
755 /*
756  * Allocate an L1 translation table for the specified pmap.
757  * This is called at pmap creation time.
758  */
759 static void
760 pmap_alloc_l1(pmap_t pm)
761 {
762         struct l1_ttable *l1;
763         u_int8_t domain;
764
765         /*
766          * Remove the L1 at the head of the LRU list
767          */
768         mtx_lock(&l1_lru_lock);
769         l1 = TAILQ_FIRST(&l1_lru_list);
770         TAILQ_REMOVE(&l1_lru_list, l1, l1_lru);
771
772         /*
773          * Pick the first available domain number, and update
774          * the link to the next number.
775          */
776         domain = l1->l1_domain_first;
777         l1->l1_domain_first = l1->l1_domain_free[domain];
778
779         /*
780          * If there are still free domain numbers in this L1,
781          * put it back on the TAIL of the LRU list.
782          */
783         if (++l1->l1_domain_use_count < PMAP_DOMAINS)
784                 TAILQ_INSERT_TAIL(&l1_lru_list, l1, l1_lru);
785
786         mtx_unlock(&l1_lru_lock);
787
788         /*
789          * Fix up the relevant bits in the pmap structure
790          */
791         pm->pm_l1 = l1;
792         pm->pm_domain = domain + 1;
793 }
794
795 /*
796  * Free an L1 translation table.
797  * This is called at pmap destruction time.
798  */
799 static void
800 pmap_free_l1(pmap_t pm)
801 {
802         struct l1_ttable *l1 = pm->pm_l1;
803
804         mtx_lock(&l1_lru_lock);
805
806         /*
807          * If this L1 is currently on the LRU list, remove it.
808          */
809         if (l1->l1_domain_use_count < PMAP_DOMAINS)
810                 TAILQ_REMOVE(&l1_lru_list, l1, l1_lru);
811
812         /*
813          * Free up the domain number which was allocated to the pmap
814          */
815         l1->l1_domain_free[pm->pm_domain - 1] = l1->l1_domain_first;
816         l1->l1_domain_first = pm->pm_domain - 1;
817         l1->l1_domain_use_count--;
818
819         /*
820          * The L1 now must have at least 1 free domain, so add
821          * it back to the LRU list. If the use count is zero,
822          * put it at the head of the list, otherwise it goes
823          * to the tail.
824          */
825         if (l1->l1_domain_use_count == 0) {
826                 TAILQ_INSERT_HEAD(&l1_lru_list, l1, l1_lru);
827         }       else
828                 TAILQ_INSERT_TAIL(&l1_lru_list, l1, l1_lru);
829
830         mtx_unlock(&l1_lru_lock);
831 }
832
833 /*
834  * Returns a pointer to the L2 bucket associated with the specified pmap
835  * and VA, or NULL if no L2 bucket exists for the address.
836  */
837 static PMAP_INLINE struct l2_bucket *
838 pmap_get_l2_bucket(pmap_t pm, vm_offset_t va)
839 {
840         struct l2_dtable *l2;
841         struct l2_bucket *l2b;
842         u_short l1idx;
843
844         l1idx = L1_IDX(va);
845
846         if ((l2 = pm->pm_l2[L2_IDX(l1idx)]) == NULL ||
847             (l2b = &l2->l2_bucket[L2_BUCKET(l1idx)])->l2b_kva == NULL)
848                 return (NULL);
849
850         return (l2b);
851 }
852
853 /*
854  * Returns a pointer to the L2 bucket associated with the specified pmap
855  * and VA.
856  *
857  * If no L2 bucket exists, perform the necessary allocations to put an L2
858  * bucket/page table in place.
859  *
860  * Note that if a new L2 bucket/page was allocated, the caller *must*
861  * increment the bucket occupancy counter appropriately *before* 
862  * releasing the pmap's lock to ensure no other thread or cpu deallocates
863  * the bucket/page in the meantime.
864  */
865 static struct l2_bucket *
866 pmap_alloc_l2_bucket(pmap_t pm, vm_offset_t va)
867 {
868         struct l2_dtable *l2;
869         struct l2_bucket *l2b;
870         u_short l1idx;
871
872         l1idx = L1_IDX(va);
873
874         PMAP_ASSERT_LOCKED(pm);
875         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
876         if ((l2 = pm->pm_l2[L2_IDX(l1idx)]) == NULL) {
877                 /*
878                  * No mapping at this address, as there is
879                  * no entry in the L1 table.
880                  * Need to allocate a new l2_dtable.
881                  */
882 again_l2table:
883                 PMAP_UNLOCK(pm);
884                 vm_page_unlock_queues();
885                 if ((l2 = pmap_alloc_l2_dtable()) == NULL) {
886                         vm_page_lock_queues();
887                         PMAP_LOCK(pm);
888                         return (NULL);
889                 }
890                 vm_page_lock_queues();
891                 PMAP_LOCK(pm);
892                 if (pm->pm_l2[L2_IDX(l1idx)] != NULL) {
893                         PMAP_UNLOCK(pm);
894                         vm_page_unlock_queues();
895                         uma_zfree(l2table_zone, l2);
896                         vm_page_lock_queues();
897                         PMAP_LOCK(pm);
898                         l2 = pm->pm_l2[L2_IDX(l1idx)];
899                         if (l2 == NULL)
900                                 goto again_l2table;
901                         /*
902                          * Someone already allocated the l2_dtable while
903                          * we were doing the same.
904                          */
905                 } else {
906                         bzero(l2, sizeof(*l2));
907                         /*
908                          * Link it into the parent pmap
909                          */
910                         pm->pm_l2[L2_IDX(l1idx)] = l2;
911                 }
912         } 
913
914         l2b = &l2->l2_bucket[L2_BUCKET(l1idx)];
915
916         /*
917          * Fetch pointer to the L2 page table associated with the address.
918          */
919         if (l2b->l2b_kva == NULL) {
920                 pt_entry_t *ptep;
921
922                 /*
923                  * No L2 page table has been allocated. Chances are, this
924                  * is because we just allocated the l2_dtable, above.
925                  */
926 again_ptep:
927                 PMAP_UNLOCK(pm);
928                 vm_page_unlock_queues();
929                 ptep = (void*)uma_zalloc(l2zone, M_NOWAIT|M_USE_RESERVE);
930                 vm_page_lock_queues();
931                 PMAP_LOCK(pm);
932                 if (l2b->l2b_kva != 0) {
933                         /* We lost the race. */
934                         PMAP_UNLOCK(pm);
935                         vm_page_unlock_queues();
936                         uma_zfree(l2zone, ptep);
937                         vm_page_lock_queues();
938                         PMAP_LOCK(pm);
939                         if (l2b->l2b_kva == 0)
940                                 goto again_ptep;
941                         return (l2b);
942                 }
943                 l2b->l2b_phys = vtophys(ptep);
944                 if (ptep == NULL) {
945                         /*
946                          * Oops, no more L2 page tables available at this
947                          * time. We may need to deallocate the l2_dtable
948                          * if we allocated a new one above.
949                          */
950                         if (l2->l2_occupancy == 0) {
951                                 pm->pm_l2[L2_IDX(l1idx)] = NULL;
952                                 pmap_free_l2_dtable(l2);
953                         }
954                         return (NULL);
955                 }
956
957                 l2->l2_occupancy++;
958                 l2b->l2b_kva = ptep;
959                 l2b->l2b_l1idx = l1idx;
960         }
961
962         return (l2b);
963 }
964
965 static PMAP_INLINE void
966 #ifndef PMAP_INCLUDE_PTE_SYNC
967 pmap_free_l2_ptp(pt_entry_t *l2)
968 #else
969 pmap_free_l2_ptp(boolean_t need_sync, pt_entry_t *l2)
970 #endif
971 {
972 #ifdef PMAP_INCLUDE_PTE_SYNC
973         /*
974          * Note: With a write-back cache, we may need to sync this
975          * L2 table before re-using it.
976          * This is because it may have belonged to a non-current
977          * pmap, in which case the cache syncs would have been
978          * skipped when the pages were being unmapped. If the
979          * L2 table were then to be immediately re-allocated to
980          * the *current* pmap, it may well contain stale mappings
981          * which have not yet been cleared by a cache write-back
982          * and so would still be visible to the mmu.
983          */
984         if (need_sync)
985                 PTE_SYNC_RANGE(l2, L2_TABLE_SIZE_REAL / sizeof(pt_entry_t));
986 #endif
987         uma_zfree(l2zone, l2);
988 }
989 /*
990  * One or more mappings in the specified L2 descriptor table have just been
991  * invalidated.
992  *
993  * Garbage collect the metadata and descriptor table itself if necessary.
994  *
995  * The pmap lock must be acquired when this is called (not necessary
996  * for the kernel pmap).
997  */
998 static void
999 pmap_free_l2_bucket(pmap_t pm, struct l2_bucket *l2b, u_int count)
1000 {
1001         struct l2_dtable *l2;
1002         pd_entry_t *pl1pd, l1pd;
1003         pt_entry_t *ptep;
1004         u_short l1idx;
1005
1006
1007         /*
1008          * Update the bucket's reference count according to how many
1009          * PTEs the caller has just invalidated.
1010          */
1011         l2b->l2b_occupancy -= count;
1012
1013         /*
1014          * Note:
1015          *
1016          * Level 2 page tables allocated to the kernel pmap are never freed
1017          * as that would require checking all Level 1 page tables and
1018          * removing any references to the Level 2 page table. See also the
1019          * comment elsewhere about never freeing bootstrap L2 descriptors.
1020          *
1021          * We make do with just invalidating the mapping in the L2 table.
1022          *
1023          * This isn't really a big deal in practice and, in fact, leads
1024          * to a performance win over time as we don't need to continually
1025          * alloc/free.
1026          */
1027         if (l2b->l2b_occupancy > 0 || pm == pmap_kernel())
1028                 return;
1029
1030         /*
1031          * There are no more valid mappings in this level 2 page table.
1032          * Go ahead and NULL-out the pointer in the bucket, then
1033          * free the page table.
1034          */
1035         l1idx = l2b->l2b_l1idx;
1036         ptep = l2b->l2b_kva;
1037         l2b->l2b_kva = NULL;
1038
1039         pl1pd = &pm->pm_l1->l1_kva[l1idx];
1040
1041         /*
1042          * If the L1 slot matches the pmap's domain
1043          * number, then invalidate it.
1044          */
1045         l1pd = *pl1pd & (L1_TYPE_MASK | L1_C_DOM_MASK);
1046         if (l1pd == (L1_C_DOM(pm->pm_domain) | L1_TYPE_C)) {
1047                 *pl1pd = 0;
1048                 PTE_SYNC(pl1pd);
1049         }
1050
1051         /*
1052          * Release the L2 descriptor table back to the pool cache.
1053          */
1054 #ifndef PMAP_INCLUDE_PTE_SYNC
1055         pmap_free_l2_ptp(ptep);
1056 #else
1057         pmap_free_l2_ptp(!pmap_is_current(pm), ptep);
1058 #endif
1059
1060         /*
1061          * Update the reference count in the associated l2_dtable
1062          */
1063         l2 = pm->pm_l2[L2_IDX(l1idx)];
1064         if (--l2->l2_occupancy > 0)
1065                 return;
1066
1067         /*
1068          * There are no more valid mappings in any of the Level 1
1069          * slots managed by this l2_dtable. Go ahead and NULL-out
1070          * the pointer in the parent pmap and free the l2_dtable.
1071          */
1072         pm->pm_l2[L2_IDX(l1idx)] = NULL;
1073         pmap_free_l2_dtable(l2);
1074 }
1075
1076 /*
1077  * Pool cache constructors for L2 descriptor tables, metadata and pmap
1078  * structures.
1079  */
1080 static int
1081 pmap_l2ptp_ctor(void *mem, int size, void *arg, int flags)
1082 {
1083 #ifndef PMAP_INCLUDE_PTE_SYNC
1084         struct l2_bucket *l2b;
1085         pt_entry_t *ptep, pte;
1086 #ifdef ARM_USE_SMALL_ALLOC
1087         pd_entry_t *pde;
1088 #endif
1089         vm_offset_t va = (vm_offset_t)mem & ~PAGE_MASK;
1090
1091         /*
1092          * The mappings for these page tables were initially made using
1093          * pmap_kenter() by the pool subsystem. Therefore, the cache-
1094          * mode will not be right for page table mappings. To avoid
1095          * polluting the pmap_kenter() code with a special case for
1096          * page tables, we simply fix up the cache-mode here if it's not
1097          * correct.
1098          */
1099 #ifdef ARM_USE_SMALL_ALLOC
1100         pde = &kernel_pmap->pm_l1->l1_kva[L1_IDX(va)];
1101         if (!l1pte_section_p(*pde)) {
1102 #endif
1103                 l2b = pmap_get_l2_bucket(pmap_kernel(), va);
1104                 ptep = &l2b->l2b_kva[l2pte_index(va)];
1105                 pte = *ptep;
1106                 
1107                 if ((pte & L2_S_CACHE_MASK) != pte_l2_s_cache_mode_pt) {
1108                         /*
1109                          * Page tables must have the cache-mode set to 
1110                          * Write-Thru.
1111                          */
1112                         *ptep = (pte & ~L2_S_CACHE_MASK) | pte_l2_s_cache_mode_pt;
1113                         PTE_SYNC(ptep);
1114                         cpu_tlb_flushD_SE(va);
1115                         cpu_cpwait();
1116                 }
1117 #ifdef ARM_USE_SMALL_ALLOC
1118         }
1119 #endif
1120 #endif
1121         memset(mem, 0, L2_TABLE_SIZE_REAL);
1122         PTE_SYNC_RANGE(mem, L2_TABLE_SIZE_REAL / sizeof(pt_entry_t));
1123         return (0);
1124 }
1125
1126 /*
1127  * A bunch of routines to conditionally flush the caches/TLB depending
1128  * on whether the specified pmap actually needs to be flushed at any
1129  * given time.
1130  */
1131 static PMAP_INLINE void
1132 pmap_tlb_flushID_SE(pmap_t pm, vm_offset_t va)
1133 {
1134
1135         if (pmap_is_current(pm))
1136                 cpu_tlb_flushID_SE(va);
1137 }
1138
1139 static PMAP_INLINE void
1140 pmap_tlb_flushD_SE(pmap_t pm, vm_offset_t va)
1141 {
1142
1143         if (pmap_is_current(pm))
1144                 cpu_tlb_flushD_SE(va);
1145 }
1146
1147 static PMAP_INLINE void
1148 pmap_tlb_flushID(pmap_t pm)
1149 {
1150
1151         if (pmap_is_current(pm))
1152                 cpu_tlb_flushID();
1153 }
1154 static PMAP_INLINE void
1155 pmap_tlb_flushD(pmap_t pm)
1156 {
1157
1158         if (pmap_is_current(pm))
1159                 cpu_tlb_flushD();
1160 }
1161
1162 static PMAP_INLINE void
1163 pmap_l2cache_wbinv_range(pmap_t pm, vm_offset_t va, vm_size_t len)
1164 {
1165         vm_size_t rest;
1166         pd_entry_t *pde;
1167         pt_entry_t *ptep;
1168
1169         rest = MIN(PAGE_SIZE - (va & PAGE_MASK), len);
1170
1171         while (len > 0) {
1172                 CTR4(KTR_PMAP, "pmap_l2cache_wbinv_range: pmap %p is_kernel %d "
1173                     "va 0x%08x len 0x%x ", pm, pm == pmap_kernel(), va, rest);
1174                 if (pmap_get_pde_pte(pm, va, &pde, &ptep) && l2pte_valid(*ptep))
1175                         cpu_l2cache_wbinv_range(va, rest);
1176
1177                 len -= rest;
1178                 va += rest;
1179
1180                 rest = MIN(PAGE_SIZE, len);
1181         }
1182 }
1183
1184 static PMAP_INLINE void
1185 pmap_idcache_wbinv_range(pmap_t pm, vm_offset_t va, vm_size_t len)
1186 {
1187
1188         if (pmap_is_current(pm)) {
1189                 cpu_idcache_wbinv_range(va, len);
1190                 pmap_l2cache_wbinv_range(pm, va, len);
1191         }
1192 }
1193
1194 static PMAP_INLINE void
1195 pmap_l2cache_wb_range(pmap_t pm, vm_offset_t va, vm_size_t len)
1196 {
1197         vm_size_t rest;
1198         pd_entry_t *pde;
1199         pt_entry_t *ptep;
1200
1201         rest = MIN(PAGE_SIZE - (va & PAGE_MASK), len);
1202
1203         while (len > 0) {
1204                 CTR4(KTR_PMAP, "pmap_l2cache_wb_range: pmap %p is_kernel %d "
1205                     "va 0x%08x len 0x%x ", pm, pm == pmap_kernel(), va, rest);
1206                 if (pmap_get_pde_pte(pm, va, &pde, &ptep) && l2pte_valid(*ptep))
1207                         cpu_l2cache_wb_range(va, rest);
1208
1209                 len -= rest;
1210                 va += rest;
1211
1212                 rest = MIN(PAGE_SIZE, len);
1213         }
1214 }
1215
1216 static PMAP_INLINE void
1217 pmap_l2cache_inv_range(pmap_t pm, vm_offset_t va, vm_size_t len)
1218 {
1219         vm_size_t rest;
1220         pd_entry_t *pde;
1221         pt_entry_t *ptep;
1222
1223         rest = MIN(PAGE_SIZE - (va & PAGE_MASK), len);
1224
1225         while (len > 0) {
1226                 CTR4(KTR_PMAP, "pmap_l2cache_wb_range: pmap %p is_kernel %d "
1227                     "va 0x%08x len 0x%x ", pm, pm == pmap_kernel(), va, rest);
1228                 if (pmap_get_pde_pte(pm, va, &pde, &ptep) && l2pte_valid(*ptep)) 
1229                     cpu_l2cache_inv_range(va, rest);
1230
1231                 len -= rest;
1232                 va += rest;
1233
1234                 rest = MIN(PAGE_SIZE, len);
1235         }
1236 }
1237
1238 static PMAP_INLINE void
1239 pmap_dcache_wb_range(pmap_t pm, vm_offset_t va, vm_size_t len, boolean_t do_inv,
1240     boolean_t rd_only)
1241 {
1242
1243         CTR4(KTR_PMAP, "pmap_dcache_wb_range: pmap %p is_kernel %d va 0x%08x "
1244             "len 0x%x ", pm, pm == pmap_kernel(), va, len);
1245         CTR2(KTR_PMAP, " do_inv %d rd_only %d", do_inv, rd_only);
1246
1247         if (pmap_is_current(pm)) {
1248                 if (do_inv) {
1249                         if (rd_only) {
1250                                 cpu_dcache_inv_range(va, len);
1251                                 pmap_l2cache_inv_range(pm, va, len);
1252                         }
1253                         else {
1254                                 cpu_dcache_wbinv_range(va, len);
1255                                 pmap_l2cache_wbinv_range(pm, va, len);
1256                         }
1257                 } else if (!rd_only) {
1258                         cpu_dcache_wb_range(va, len);
1259                         pmap_l2cache_wb_range(pm, va, len);
1260                 }
1261         }
1262 }
1263
1264 static PMAP_INLINE void
1265 pmap_idcache_wbinv_all(pmap_t pm)
1266 {
1267
1268         if (pmap_is_current(pm)) {
1269                 cpu_idcache_wbinv_all();
1270                 cpu_l2cache_wbinv_all();
1271         }
1272 }
1273
1274 #ifdef notyet
1275 static PMAP_INLINE void
1276 pmap_dcache_wbinv_all(pmap_t pm)
1277 {
1278
1279         if (pmap_is_current(pm)) {
1280                 cpu_dcache_wbinv_all();
1281                 cpu_l2cache_wbinv_all();
1282         }
1283 }
1284 #endif
1285
1286 /*
1287  * PTE_SYNC_CURRENT:
1288  *
1289  *     Make sure the pte is written out to RAM.
1290  *     We need to do this for one of two cases:
1291  *       - We're dealing with the kernel pmap
1292  *       - There is no pmap active in the cache/tlb.
1293  *       - The specified pmap is 'active' in the cache/tlb.
1294  */
1295 #ifdef PMAP_INCLUDE_PTE_SYNC
1296 #define PTE_SYNC_CURRENT(pm, ptep)      \
1297 do {                                    \
1298         if (PMAP_NEEDS_PTE_SYNC &&      \
1299             pmap_is_current(pm))        \
1300                 PTE_SYNC(ptep);         \
1301 } while (/*CONSTCOND*/0)
1302 #else
1303 #define PTE_SYNC_CURRENT(pm, ptep)      /* nothing */
1304 #endif
1305
1306 /*
1307  * cacheable == -1 means we must make the entry uncacheable, 1 means
1308  * cacheable;
1309  */
1310 static __inline void
1311 pmap_set_cache_entry(pv_entry_t pv, pmap_t pm, vm_offset_t va, int cacheable)
1312 {
1313         struct l2_bucket *l2b;
1314         pt_entry_t *ptep, pte;
1315
1316         l2b = pmap_get_l2_bucket(pv->pv_pmap, pv->pv_va);
1317         ptep = &l2b->l2b_kva[l2pte_index(pv->pv_va)];
1318
1319         if (cacheable == 1) {
1320                 pte = (*ptep & ~L2_S_CACHE_MASK) | pte_l2_s_cache_mode;
1321                 if (l2pte_valid(pte)) {
1322                         if (PV_BEEN_EXECD(pv->pv_flags)) {
1323                                 pmap_tlb_flushID_SE(pv->pv_pmap, pv->pv_va);
1324                         } else if (PV_BEEN_REFD(pv->pv_flags)) {
1325                                 pmap_tlb_flushD_SE(pv->pv_pmap, pv->pv_va);
1326                         }
1327                 }
1328         } else {
1329                 pte = *ptep &~ L2_S_CACHE_MASK;
1330                 if ((va != pv->pv_va || pm != pv->pv_pmap) &&
1331                             l2pte_valid(pte)) {
1332                         if (PV_BEEN_EXECD(pv->pv_flags)) {
1333                                 pmap_idcache_wbinv_range(pv->pv_pmap,
1334                                             pv->pv_va, PAGE_SIZE);
1335                                 pmap_tlb_flushID_SE(pv->pv_pmap, pv->pv_va);
1336                         } else if (PV_BEEN_REFD(pv->pv_flags)) {
1337                                 pmap_dcache_wb_range(pv->pv_pmap,
1338                                             pv->pv_va, PAGE_SIZE, TRUE,
1339                                             (pv->pv_flags & PVF_WRITE) == 0);
1340                                 pmap_tlb_flushD_SE(pv->pv_pmap,
1341                                             pv->pv_va);
1342                         }
1343                 }
1344         }
1345         *ptep = pte;
1346         PTE_SYNC_CURRENT(pv->pv_pmap, ptep);
1347 }
1348
1349 static void
1350 pmap_fix_cache(struct vm_page *pg, pmap_t pm, vm_offset_t va)
1351 {
1352         int pmwc = 0;
1353         int writable = 0, kwritable = 0, uwritable = 0;
1354         int entries = 0, kentries = 0, uentries = 0;
1355         struct pv_entry *pv;
1356
1357         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
1358
1359         /* the cache gets written back/invalidated on context switch.
1360          * therefore, if a user page shares an entry in the same page or
1361          * with the kernel map and at least one is writable, then the
1362          * cache entry must be set write-through.
1363          */
1364
1365         TAILQ_FOREACH(pv, &pg->md.pv_list, pv_list) {
1366                         /* generate a count of the pv_entry uses */
1367                 if (pv->pv_flags & PVF_WRITE) {
1368                         if (pv->pv_pmap == pmap_kernel())
1369                                 kwritable++;
1370                         else if (pv->pv_pmap == pm)
1371                                 uwritable++;
1372                         writable++;
1373                 }
1374                 if (pv->pv_pmap == pmap_kernel())
1375                         kentries++;
1376                 else {
1377                         if (pv->pv_pmap == pm)
1378                                 uentries++;
1379                         entries++;
1380                 }
1381         }
1382                 /*
1383                  * check if the user duplicate mapping has
1384                  * been removed.
1385                  */
1386         if ((pm != pmap_kernel()) && (((uentries > 1) && uwritable) ||
1387             (uwritable > 1)))
1388                         pmwc = 1;
1389
1390         TAILQ_FOREACH(pv, &pg->md.pv_list, pv_list) {
1391                 /* check for user uncachable conditions - order is important */
1392                 if (pm != pmap_kernel() &&
1393                     (pv->pv_pmap == pm || pv->pv_pmap == pmap_kernel())) {
1394
1395                         if ((uentries > 1 && uwritable) || uwritable > 1) {
1396
1397                                 /* user duplicate mapping */
1398                                 if (pv->pv_pmap != pmap_kernel())
1399                                         pv->pv_flags |= PVF_MWC;
1400
1401                                 if (!(pv->pv_flags & PVF_NC)) {
1402                                         pv->pv_flags |= PVF_NC;
1403                                         pmap_set_cache_entry(pv, pm, va, -1);
1404                                 }
1405                                 continue;
1406                         } else  /* no longer a duplicate user */
1407                                 pv->pv_flags &= ~PVF_MWC;
1408                 }
1409
1410                 /*
1411                  * check for kernel uncachable conditions
1412                  * kernel writable or kernel readable with writable user entry
1413                  */
1414                 if ((kwritable && entries) ||
1415                     (kwritable > 1) ||
1416                     ((kwritable != writable) && kentries &&
1417                      (pv->pv_pmap == pmap_kernel() ||
1418                       (pv->pv_flags & PVF_WRITE) ||
1419                       (pv->pv_flags & PVF_MWC)))) {
1420
1421                         if (!(pv->pv_flags & PVF_NC)) {
1422                                 pv->pv_flags |= PVF_NC;
1423                                 pmap_set_cache_entry(pv, pm, va, -1);
1424                         }
1425                         continue;
1426                 }
1427
1428                         /* kernel and user are cachable */
1429                 if ((pm == pmap_kernel()) && !(pv->pv_flags & PVF_MWC) &&
1430                     (pv->pv_flags & PVF_NC)) {
1431
1432                         pv->pv_flags &= ~PVF_NC;
1433                         pmap_set_cache_entry(pv, pm, va, 1);
1434                         continue;
1435                 }
1436                         /* user is no longer sharable and writable */
1437                 if (pm != pmap_kernel() &&
1438                     (pv->pv_pmap == pm || pv->pv_pmap == pmap_kernel()) &&
1439                     !pmwc && (pv->pv_flags & PVF_NC)) {
1440
1441                         pv->pv_flags &= ~(PVF_NC | PVF_MWC);
1442                         pmap_set_cache_entry(pv, pm, va, 1);
1443                 }
1444         }
1445
1446         if ((kwritable == 0) && (writable == 0)) {
1447                 pg->md.pvh_attrs &= ~PVF_MOD;
1448                 vm_page_flag_clear(pg, PG_WRITEABLE);
1449                 return;
1450         }
1451 }
1452
1453 /*
1454  * Modify pte bits for all ptes corresponding to the given physical address.
1455  * We use `maskbits' rather than `clearbits' because we're always passing
1456  * constants and the latter would require an extra inversion at run-time.
1457  */
1458 static int 
1459 pmap_clearbit(struct vm_page *pg, u_int maskbits)
1460 {
1461         struct l2_bucket *l2b;
1462         struct pv_entry *pv;
1463         pt_entry_t *ptep, npte, opte;
1464         pmap_t pm;
1465         vm_offset_t va;
1466         u_int oflags;
1467         int count = 0;
1468
1469         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
1470
1471         if (maskbits & PVF_WRITE)
1472                 maskbits |= PVF_MOD;
1473         /*
1474          * Clear saved attributes (modify, reference)
1475          */
1476         pg->md.pvh_attrs &= ~(maskbits & (PVF_MOD | PVF_REF));
1477
1478         if (TAILQ_EMPTY(&pg->md.pv_list)) {
1479                 return (0);
1480         }
1481
1482         /*
1483          * Loop over all current mappings setting/clearing as appropos
1484          */
1485         TAILQ_FOREACH(pv, &pg->md.pv_list, pv_list) {
1486                 va = pv->pv_va;
1487                 pm = pv->pv_pmap;
1488                 oflags = pv->pv_flags;
1489
1490                 if (!(oflags & maskbits)) {
1491                         if ((maskbits & PVF_WRITE) && (pv->pv_flags & PVF_NC)) {
1492                                 /* It is safe to re-enable cacheing here. */
1493                                 PMAP_LOCK(pm);
1494                                 l2b = pmap_get_l2_bucket(pm, va);
1495                                 ptep = &l2b->l2b_kva[l2pte_index(va)];
1496                                 *ptep |= pte_l2_s_cache_mode;
1497                                 PTE_SYNC(ptep);
1498                                 PMAP_UNLOCK(pm);
1499                                 pv->pv_flags &= ~(PVF_NC | PVF_MWC);
1500                                 
1501                         }
1502                         continue;
1503                 }
1504                 pv->pv_flags &= ~maskbits;
1505
1506                 PMAP_LOCK(pm);
1507
1508                 l2b = pmap_get_l2_bucket(pm, va);
1509
1510                 ptep = &l2b->l2b_kva[l2pte_index(va)];
1511                 npte = opte = *ptep;
1512
1513                 if (maskbits & (PVF_WRITE|PVF_MOD)) {
1514                         if ((pv->pv_flags & PVF_NC)) {
1515                                 /* 
1516                                  * Entry is not cacheable:
1517                                  *
1518                                  * Don't turn caching on again if this is a 
1519                                  * modified emulation. This would be
1520                                  * inconsitent with the settings created by
1521                                  * pmap_fix_cache(). Otherwise, it's safe
1522                                  * to re-enable cacheing.
1523                                  *
1524                                  * There's no need to call pmap_fix_cache()
1525                                  * here: all pages are losing their write
1526                                  * permission.
1527                                  */
1528                                 if (maskbits & PVF_WRITE) {
1529                                         npte |= pte_l2_s_cache_mode;
1530                                         pv->pv_flags &= ~(PVF_NC | PVF_MWC);
1531                                 }
1532                         } else
1533                         if (opte & L2_S_PROT_W) {
1534                                 vm_page_dirty(pg);
1535                                 /* 
1536                                  * Entry is writable/cacheable: check if pmap
1537                                  * is current if it is flush it, otherwise it
1538                                  * won't be in the cache
1539                                  */
1540                                 if (PV_BEEN_EXECD(oflags))
1541                                         pmap_idcache_wbinv_range(pm, pv->pv_va,
1542                                             PAGE_SIZE);
1543                                 else
1544                                 if (PV_BEEN_REFD(oflags))
1545                                         pmap_dcache_wb_range(pm, pv->pv_va,
1546                                             PAGE_SIZE,
1547                                             (maskbits & PVF_REF) ? TRUE : FALSE,
1548                                             FALSE);
1549                         }
1550
1551                         /* make the pte read only */
1552                         npte &= ~L2_S_PROT_W;
1553                 }
1554
1555                 if (maskbits & PVF_REF) {
1556                         if ((pv->pv_flags & PVF_NC) == 0 &&
1557                             (maskbits & (PVF_WRITE|PVF_MOD)) == 0) {
1558                                 /*
1559                                  * Check npte here; we may have already
1560                                  * done the wbinv above, and the validity
1561                                  * of the PTE is the same for opte and
1562                                  * npte.
1563                                  */
1564                                 if (npte & L2_S_PROT_W) {
1565                                         if (PV_BEEN_EXECD(oflags))
1566                                                 pmap_idcache_wbinv_range(pm,
1567                                                     pv->pv_va, PAGE_SIZE);
1568                                         else
1569                                         if (PV_BEEN_REFD(oflags))
1570                                                 pmap_dcache_wb_range(pm,
1571                                                     pv->pv_va, PAGE_SIZE,
1572                                                     TRUE, FALSE);
1573                                 } else
1574                                 if ((npte & L2_TYPE_MASK) != L2_TYPE_INV) {
1575                                         /* XXXJRT need idcache_inv_range */
1576                                         if (PV_BEEN_EXECD(oflags))
1577                                                 pmap_idcache_wbinv_range(pm,
1578                                                     pv->pv_va, PAGE_SIZE);
1579                                         else
1580                                         if (PV_BEEN_REFD(oflags))
1581                                                 pmap_dcache_wb_range(pm,
1582                                                     pv->pv_va, PAGE_SIZE,
1583                                                     TRUE, TRUE);
1584                                 }
1585                         }
1586
1587                         /*
1588                          * Make the PTE invalid so that we will take a
1589                          * page fault the next time the mapping is
1590                          * referenced.
1591                          */
1592                         npte &= ~L2_TYPE_MASK;
1593                         npte |= L2_TYPE_INV;
1594                 }
1595
1596                 if (npte != opte) {
1597                         count++;
1598                         *ptep = npte;
1599                         PTE_SYNC(ptep);
1600                         /* Flush the TLB entry if a current pmap. */
1601                         if (PV_BEEN_EXECD(oflags))
1602                                 pmap_tlb_flushID_SE(pm, pv->pv_va);
1603                         else
1604                         if (PV_BEEN_REFD(oflags))
1605                                 pmap_tlb_flushD_SE(pm, pv->pv_va);
1606                 }
1607
1608                 PMAP_UNLOCK(pm);
1609
1610         }
1611
1612         if (maskbits & PVF_WRITE)
1613                 vm_page_flag_clear(pg, PG_WRITEABLE);
1614         return (count);
1615 }
1616
1617 /*
1618  * main pv_entry manipulation functions:
1619  *   pmap_enter_pv: enter a mapping onto a vm_page list
1620  *   pmap_remove_pv: remove a mappiing from a vm_page list
1621  *
1622  * NOTE: pmap_enter_pv expects to lock the pvh itself
1623  *       pmap_remove_pv expects te caller to lock the pvh before calling
1624  */
1625
1626 /*
1627  * pmap_enter_pv: enter a mapping onto a vm_page lst
1628  *
1629  * => caller should hold the proper lock on pmap_main_lock
1630  * => caller should have pmap locked
1631  * => we will gain the lock on the vm_page and allocate the new pv_entry
1632  * => caller should adjust ptp's wire_count before calling
1633  * => caller should not adjust pmap's wire_count
1634  */
1635 static void
1636 pmap_enter_pv(struct vm_page *pg, struct pv_entry *pve, pmap_t pm,
1637     vm_offset_t va, u_int flags)
1638 {
1639
1640         int km;
1641
1642         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
1643
1644         if (pg->md.pv_kva) {
1645                 /* PMAP_ASSERT_LOCKED(pmap_kernel()); */
1646                 pve->pv_pmap = pmap_kernel();
1647                 pve->pv_va = pg->md.pv_kva;
1648                 pve->pv_flags = PVF_WRITE | PVF_UNMAN;
1649                 pg->md.pv_kva = 0;
1650
1651                 TAILQ_INSERT_HEAD(&pg->md.pv_list, pve, pv_list);
1652                 TAILQ_INSERT_HEAD(&pm->pm_pvlist, pve, pv_plist);
1653                 if ((km = PMAP_OWNED(pmap_kernel())))
1654                         PMAP_UNLOCK(pmap_kernel());
1655                 vm_page_unlock_queues();
1656                 if ((pve = pmap_get_pv_entry()) == NULL)
1657                         panic("pmap_kenter_internal: no pv entries");
1658                 vm_page_lock_queues();
1659                 if (km)
1660                         PMAP_LOCK(pmap_kernel());
1661         }
1662
1663         PMAP_ASSERT_LOCKED(pm);
1664         pve->pv_pmap = pm;
1665         pve->pv_va = va;
1666         pve->pv_flags = flags;
1667
1668         TAILQ_INSERT_HEAD(&pg->md.pv_list, pve, pv_list);
1669         TAILQ_INSERT_HEAD(&pm->pm_pvlist, pve, pv_plist);
1670         pg->md.pvh_attrs |= flags & (PVF_REF | PVF_MOD);
1671         if (pve->pv_flags & PVF_WIRED)
1672                 ++pm->pm_stats.wired_count;
1673         vm_page_flag_set(pg, PG_REFERENCED);
1674 }
1675
1676 /*
1677  *
1678  * pmap_find_pv: Find a pv entry
1679  *
1680  * => caller should hold lock on vm_page
1681  */
1682 static PMAP_INLINE struct pv_entry *
1683 pmap_find_pv(struct vm_page *pg, pmap_t pm, vm_offset_t va)
1684 {
1685         struct pv_entry *pv;
1686
1687         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
1688         TAILQ_FOREACH(pv, &pg->md.pv_list, pv_list)
1689             if (pm == pv->pv_pmap && va == pv->pv_va)
1690                     break;
1691         return (pv);
1692 }
1693
1694 /*
1695  * vector_page_setprot:
1696  *
1697  *      Manipulate the protection of the vector page.
1698  */
1699 void
1700 vector_page_setprot(int prot)
1701 {
1702         struct l2_bucket *l2b;
1703         pt_entry_t *ptep;
1704
1705         l2b = pmap_get_l2_bucket(pmap_kernel(), vector_page);
1706
1707         ptep = &l2b->l2b_kva[l2pte_index(vector_page)];
1708
1709         *ptep = (*ptep & ~L1_S_PROT_MASK) | L2_S_PROT(PTE_KERNEL, prot);
1710         PTE_SYNC(ptep);
1711         cpu_tlb_flushD_SE(vector_page);
1712         cpu_cpwait();
1713 }
1714
1715 /*
1716  * pmap_remove_pv: try to remove a mapping from a pv_list
1717  *
1718  * => caller should hold proper lock on pmap_main_lock
1719  * => pmap should be locked
1720  * => caller should hold lock on vm_page [so that attrs can be adjusted]
1721  * => caller should adjust ptp's wire_count and free PTP if needed
1722  * => caller should NOT adjust pmap's wire_count
1723  * => we return the removed pve
1724  */
1725
1726 static void
1727 pmap_nuke_pv(struct vm_page *pg, pmap_t pm, struct pv_entry *pve)
1728 {
1729
1730         struct pv_entry *pv;
1731         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
1732         PMAP_ASSERT_LOCKED(pm);
1733         TAILQ_REMOVE(&pg->md.pv_list, pve, pv_list);
1734         TAILQ_REMOVE(&pm->pm_pvlist, pve, pv_plist);
1735         if (pve->pv_flags & PVF_WIRED)
1736                 --pm->pm_stats.wired_count;
1737         if (pg->md.pvh_attrs & PVF_MOD)
1738                 vm_page_dirty(pg);
1739         if (TAILQ_FIRST(&pg->md.pv_list) == NULL)
1740                 pg->md.pvh_attrs &= ~PVF_REF;
1741         else
1742                 vm_page_flag_set(pg, PG_REFERENCED);
1743         if ((pve->pv_flags & PVF_NC) && ((pm == pmap_kernel()) ||
1744              (pve->pv_flags & PVF_WRITE) || !(pve->pv_flags & PVF_MWC)))
1745                 pmap_fix_cache(pg, pm, 0);
1746         else if (pve->pv_flags & PVF_WRITE) {
1747                 TAILQ_FOREACH(pve, &pg->md.pv_list, pv_list)
1748                     if (pve->pv_flags & PVF_WRITE)
1749                             break;
1750                 if (!pve) {
1751                         pg->md.pvh_attrs &= ~PVF_MOD;
1752                         vm_page_flag_clear(pg, PG_WRITEABLE);
1753                 }
1754         }
1755         pv = TAILQ_FIRST(&pg->md.pv_list);
1756         if (pv != NULL && (pv->pv_flags & PVF_UNMAN) &&
1757             TAILQ_NEXT(pv, pv_list) == NULL) {
1758                 pg->md.pv_kva = pv->pv_va;
1759                         /* a recursive pmap_nuke_pv */
1760                 TAILQ_REMOVE(&pg->md.pv_list, pv, pv_list);
1761                 TAILQ_REMOVE(&pm->pm_pvlist, pv, pv_plist);
1762                 if (pv->pv_flags & PVF_WIRED)
1763                         --pm->pm_stats.wired_count;
1764                 pg->md.pvh_attrs &= ~PVF_REF;
1765                 pg->md.pvh_attrs &= ~PVF_MOD;
1766                 vm_page_flag_clear(pg, PG_WRITEABLE);
1767                 pmap_free_pv_entry(pv);
1768         }
1769 }
1770
1771 static struct pv_entry *
1772 pmap_remove_pv(struct vm_page *pg, pmap_t pm, vm_offset_t va)
1773 {
1774         struct pv_entry *pve;
1775
1776         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
1777         pve = TAILQ_FIRST(&pg->md.pv_list);
1778
1779         while (pve) {
1780                 if (pve->pv_pmap == pm && pve->pv_va == va) {   /* match? */
1781                         pmap_nuke_pv(pg, pm, pve);
1782                         break;
1783                 }
1784                 pve = TAILQ_NEXT(pve, pv_list);
1785         }
1786
1787         if (pve == NULL && pg->md.pv_kva == va)
1788                 pg->md.pv_kva = 0;
1789
1790         return(pve);                            /* return removed pve */
1791 }
1792 /*
1793  *
1794  * pmap_modify_pv: Update pv flags
1795  *
1796  * => caller should hold lock on vm_page [so that attrs can be adjusted]
1797  * => caller should NOT adjust pmap's wire_count
1798  * => we return the old flags
1799  * 
1800  * Modify a physical-virtual mapping in the pv table
1801  */
1802 static u_int
1803 pmap_modify_pv(struct vm_page *pg, pmap_t pm, vm_offset_t va,
1804     u_int clr_mask, u_int set_mask)
1805 {
1806         struct pv_entry *npv;
1807         u_int flags, oflags;
1808
1809         PMAP_ASSERT_LOCKED(pm);
1810         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
1811         if ((npv = pmap_find_pv(pg, pm, va)) == NULL)
1812                 return (0);
1813
1814         /*
1815          * There is at least one VA mapping this page.
1816          */
1817
1818         if (clr_mask & (PVF_REF | PVF_MOD))
1819                 pg->md.pvh_attrs |= set_mask & (PVF_REF | PVF_MOD);
1820
1821         oflags = npv->pv_flags;
1822         npv->pv_flags = flags = (oflags & ~clr_mask) | set_mask;
1823
1824         if ((flags ^ oflags) & PVF_WIRED) {
1825                 if (flags & PVF_WIRED)
1826                         ++pm->pm_stats.wired_count;
1827                 else
1828                         --pm->pm_stats.wired_count;
1829         }
1830
1831         if ((flags ^ oflags) & PVF_WRITE)
1832                 pmap_fix_cache(pg, pm, 0);
1833
1834         return (oflags);
1835 }
1836
1837 /* Function to set the debug level of the pmap code */
1838 #ifdef PMAP_DEBUG
1839 void
1840 pmap_debug(int level)
1841 {
1842         pmap_debug_level = level;
1843         dprintf("pmap_debug: level=%d\n", pmap_debug_level);
1844 }
1845 #endif  /* PMAP_DEBUG */
1846
1847 void
1848 pmap_pinit0(struct pmap *pmap)
1849 {
1850         PDEBUG(1, printf("pmap_pinit0: pmap = %08x\n", (u_int32_t) pmap));
1851
1852         dprintf("pmap_pinit0: pmap = %08x, pm_pdir = %08x\n",
1853                 (u_int32_t) pmap, (u_int32_t) pmap->pm_pdir);
1854         bcopy(kernel_pmap, pmap, sizeof(*pmap));
1855         bzero(&pmap->pm_mtx, sizeof(pmap->pm_mtx));
1856         PMAP_LOCK_INIT(pmap);
1857 }
1858
1859 /*
1860  *      Initialize a vm_page's machine-dependent fields.
1861  */
1862 void
1863 pmap_page_init(vm_page_t m)
1864 {
1865
1866         TAILQ_INIT(&m->md.pv_list);
1867 }
1868
1869 /*
1870  *      Initialize the pmap module.
1871  *      Called by vm_init, to initialize any structures that the pmap
1872  *      system needs to map virtual memory.
1873  */
1874 void
1875 pmap_init(void)
1876 {
1877         int shpgperproc = PMAP_SHPGPERPROC;
1878
1879         PDEBUG(1, printf("pmap_init: phys_start = %08x\n", PHYSADDR));
1880
1881         /*
1882          * init the pv free list
1883          */
1884         pvzone = uma_zcreate("PV ENTRY", sizeof (struct pv_entry), NULL, NULL, 
1885             NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_VM | UMA_ZONE_NOFREE);
1886         /*
1887          * Now it is safe to enable pv_table recording.
1888          */
1889         PDEBUG(1, printf("pmap_init: done!\n"));
1890
1891         TUNABLE_INT_FETCH("vm.pmap.shpgperproc", &shpgperproc);
1892         
1893         pv_entry_max = shpgperproc * maxproc + cnt.v_page_count;
1894         pv_entry_high_water = 9 * (pv_entry_max / 10);
1895         l2zone = uma_zcreate("L2 Table", L2_TABLE_SIZE_REAL, pmap_l2ptp_ctor,
1896             NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_VM | UMA_ZONE_NOFREE);
1897         l2table_zone = uma_zcreate("L2 Table", sizeof(struct l2_dtable),
1898             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR,
1899             UMA_ZONE_VM | UMA_ZONE_NOFREE);
1900
1901         uma_zone_set_obj(pvzone, &pvzone_obj, pv_entry_max);
1902
1903 }
1904
1905 int
1906 pmap_fault_fixup(pmap_t pm, vm_offset_t va, vm_prot_t ftype, int user)
1907 {
1908         struct l2_dtable *l2;
1909         struct l2_bucket *l2b;
1910         pd_entry_t *pl1pd, l1pd;
1911         pt_entry_t *ptep, pte;
1912         vm_paddr_t pa;
1913         u_int l1idx;
1914         int rv = 0;
1915
1916         l1idx = L1_IDX(va);
1917         vm_page_lock_queues();
1918         PMAP_LOCK(pm);
1919
1920         /*
1921          * If there is no l2_dtable for this address, then the process
1922          * has no business accessing it.
1923          *
1924          * Note: This will catch userland processes trying to access
1925          * kernel addresses.
1926          */
1927         l2 = pm->pm_l2[L2_IDX(l1idx)];
1928         if (l2 == NULL)
1929                 goto out;
1930
1931         /*
1932          * Likewise if there is no L2 descriptor table
1933          */
1934         l2b = &l2->l2_bucket[L2_BUCKET(l1idx)];
1935         if (l2b->l2b_kva == NULL)
1936                 goto out;
1937
1938         /*
1939          * Check the PTE itself.
1940          */
1941         ptep = &l2b->l2b_kva[l2pte_index(va)];
1942         pte = *ptep;
1943         if (pte == 0)
1944                 goto out;
1945
1946         /*
1947          * Catch a userland access to the vector page mapped at 0x0
1948          */
1949         if (user && (pte & L2_S_PROT_U) == 0)
1950                 goto out;
1951         if (va == vector_page)
1952                 goto out;
1953
1954         pa = l2pte_pa(pte);
1955
1956         if ((ftype & VM_PROT_WRITE) && (pte & L2_S_PROT_W) == 0) {
1957                 /*
1958                  * This looks like a good candidate for "page modified"
1959                  * emulation...
1960                  */
1961                 struct pv_entry *pv;
1962                 struct vm_page *pg;
1963
1964                 /* Extract the physical address of the page */
1965                 if ((pg = PHYS_TO_VM_PAGE(pa)) == NULL) {
1966                         goto out;
1967                 }
1968                 /* Get the current flags for this page. */
1969
1970                 pv = pmap_find_pv(pg, pm, va);
1971                 if (pv == NULL) {
1972                         goto out;
1973                 }
1974
1975                 /*
1976                  * Do the flags say this page is writable? If not then it
1977                  * is a genuine write fault. If yes then the write fault is
1978                  * our fault as we did not reflect the write access in the
1979                  * PTE. Now we know a write has occurred we can correct this
1980                  * and also set the modified bit
1981                  */
1982                 if ((pv->pv_flags & PVF_WRITE) == 0) {
1983                         goto out;
1984                 }
1985
1986                 pg->md.pvh_attrs |= PVF_REF | PVF_MOD;
1987                 vm_page_dirty(pg);
1988                 pv->pv_flags |= PVF_REF | PVF_MOD;
1989
1990                 /* 
1991                  * Re-enable write permissions for the page.  No need to call
1992                  * pmap_fix_cache(), since this is just a
1993                  * modified-emulation fault, and the PVF_WRITE bit isn't
1994                  * changing. We've already set the cacheable bits based on
1995                  * the assumption that we can write to this page.
1996                  */
1997                 *ptep = (pte & ~L2_TYPE_MASK) | L2_S_PROTO | L2_S_PROT_W;
1998                 PTE_SYNC(ptep);
1999                 rv = 1;
2000         } else
2001         if ((pte & L2_TYPE_MASK) == L2_TYPE_INV) {
2002                 /*
2003                  * This looks like a good candidate for "page referenced"
2004                  * emulation.
2005                  */
2006                 struct pv_entry *pv;
2007                 struct vm_page *pg;
2008
2009                 /* Extract the physical address of the page */
2010                 if ((pg = PHYS_TO_VM_PAGE(pa)) == NULL)
2011                         goto out;
2012                 /* Get the current flags for this page. */
2013
2014                 pv = pmap_find_pv(pg, pm, va);
2015                 if (pv == NULL)
2016                         goto out;
2017
2018                 pg->md.pvh_attrs |= PVF_REF;
2019                 pv->pv_flags |= PVF_REF;
2020
2021
2022                 *ptep = (pte & ~L2_TYPE_MASK) | L2_S_PROTO;
2023                 PTE_SYNC(ptep);
2024                 rv = 1;
2025         }
2026
2027         /*
2028          * We know there is a valid mapping here, so simply
2029          * fix up the L1 if necessary.
2030          */
2031         pl1pd = &pm->pm_l1->l1_kva[l1idx];
2032         l1pd = l2b->l2b_phys | L1_C_DOM(pm->pm_domain) | L1_C_PROTO;
2033         if (*pl1pd != l1pd) {
2034                 *pl1pd = l1pd;
2035                 PTE_SYNC(pl1pd);
2036                 rv = 1;
2037         }
2038
2039 #ifdef CPU_SA110
2040         /*
2041          * There are bugs in the rev K SA110.  This is a check for one
2042          * of them.
2043          */
2044         if (rv == 0 && curcpu()->ci_arm_cputype == CPU_ID_SA110 &&
2045             curcpu()->ci_arm_cpurev < 3) {
2046                 /* Always current pmap */
2047                 if (l2pte_valid(pte)) {
2048                         extern int kernel_debug;
2049                         if (kernel_debug & 1) {
2050                                 struct proc *p = curlwp->l_proc;
2051                                 printf("prefetch_abort: page is already "
2052                                     "mapped - pte=%p *pte=%08x\n", ptep, pte);
2053                                 printf("prefetch_abort: pc=%08lx proc=%p "
2054                                     "process=%s\n", va, p, p->p_comm);
2055                                 printf("prefetch_abort: far=%08x fs=%x\n",
2056                                     cpu_faultaddress(), cpu_faultstatus());
2057                         }
2058 #ifdef DDB
2059                         if (kernel_debug & 2)
2060                                 Debugger();
2061 #endif
2062                         rv = 1;
2063                 }
2064         }
2065 #endif /* CPU_SA110 */
2066
2067 #ifdef DEBUG
2068         /*
2069          * If 'rv == 0' at this point, it generally indicates that there is a
2070          * stale TLB entry for the faulting address. This happens when two or
2071          * more processes are sharing an L1. Since we don't flush the TLB on
2072          * a context switch between such processes, we can take domain faults
2073          * for mappings which exist at the same VA in both processes. EVEN IF
2074          * WE'VE RECENTLY FIXED UP THE CORRESPONDING L1 in pmap_enter(), for
2075          * example.
2076          *
2077          * This is extremely likely to happen if pmap_enter() updated the L1
2078          * entry for a recently entered mapping. In this case, the TLB is
2079          * flushed for the new mapping, but there may still be TLB entries for
2080          * other mappings belonging to other processes in the 1MB range
2081          * covered by the L1 entry.
2082          *
2083          * Since 'rv == 0', we know that the L1 already contains the correct
2084          * value, so the fault must be due to a stale TLB entry.
2085          *
2086          * Since we always need to flush the TLB anyway in the case where we
2087          * fixed up the L1, or frobbed the L2 PTE, we effectively deal with
2088          * stale TLB entries dynamically.
2089          *
2090          * However, the above condition can ONLY happen if the current L1 is
2091          * being shared. If it happens when the L1 is unshared, it indicates
2092          * that other parts of the pmap are not doing their job WRT managing
2093          * the TLB.
2094          */
2095         if (rv == 0 && pm->pm_l1->l1_domain_use_count == 1) {
2096                 extern int last_fault_code;
2097                 printf("fixup: pm %p, va 0x%lx, ftype %d - nothing to do!\n",
2098                     pm, va, ftype);
2099                 printf("fixup: l2 %p, l2b %p, ptep %p, pl1pd %p\n",
2100                     l2, l2b, ptep, pl1pd);
2101                 printf("fixup: pte 0x%x, l1pd 0x%x, last code 0x%x\n",
2102                     pte, l1pd, last_fault_code);
2103 #ifdef DDB
2104                 Debugger();
2105 #endif
2106         }
2107 #endif
2108
2109         cpu_tlb_flushID_SE(va);
2110         cpu_cpwait();
2111
2112         rv = 1;
2113
2114 out:
2115         vm_page_unlock_queues();
2116         PMAP_UNLOCK(pm);
2117         return (rv);
2118 }
2119
2120 void
2121 pmap_postinit(void)
2122 {
2123         struct l2_bucket *l2b;
2124         struct l1_ttable *l1;
2125         pd_entry_t *pl1pt;
2126         pt_entry_t *ptep, pte;
2127         vm_offset_t va, eva;
2128         u_int loop, needed;
2129         
2130         needed = (maxproc / PMAP_DOMAINS) + ((maxproc % PMAP_DOMAINS) ? 1 : 0);
2131         needed -= 1;
2132         l1 = malloc(sizeof(*l1) * needed, M_VMPMAP, M_WAITOK);
2133
2134         for (loop = 0; loop < needed; loop++, l1++) {
2135                 /* Allocate a L1 page table */
2136                 va = (vm_offset_t)contigmalloc(L1_TABLE_SIZE, M_VMPMAP, 0, 0x0,
2137                     0xffffffff, L1_TABLE_SIZE, 0);
2138
2139                 if (va == 0)
2140                         panic("Cannot allocate L1 KVM");
2141
2142                 eva = va + L1_TABLE_SIZE;
2143                 pl1pt = (pd_entry_t *)va;
2144                 
2145                 while (va < eva) {
2146                                 l2b = pmap_get_l2_bucket(pmap_kernel(), va);
2147                                 ptep = &l2b->l2b_kva[l2pte_index(va)];
2148                                 pte = *ptep;
2149                                 pte = (pte & ~L2_S_CACHE_MASK) | pte_l2_s_cache_mode_pt;
2150                                 *ptep = pte;
2151                                 PTE_SYNC(ptep);
2152                                 cpu_tlb_flushD_SE(va);
2153                                 
2154                                 va += PAGE_SIZE;
2155                 }
2156                 pmap_init_l1(l1, pl1pt);
2157         }
2158
2159
2160 #ifdef DEBUG
2161         printf("pmap_postinit: Allocated %d static L1 descriptor tables\n",
2162             needed);
2163 #endif
2164 }
2165
2166 /*
2167  * This is used to stuff certain critical values into the PCB where they
2168  * can be accessed quickly from cpu_switch() et al.
2169  */
2170 void
2171 pmap_set_pcb_pagedir(pmap_t pm, struct pcb *pcb)
2172 {
2173         struct l2_bucket *l2b;
2174
2175         pcb->pcb_pagedir = pm->pm_l1->l1_physaddr;
2176         pcb->pcb_dacr = (DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL * 2)) |
2177             (DOMAIN_CLIENT << (pm->pm_domain * 2));
2178
2179         if (vector_page < KERNBASE) {
2180                 pcb->pcb_pl1vec = &pm->pm_l1->l1_kva[L1_IDX(vector_page)];
2181                 l2b = pmap_get_l2_bucket(pm, vector_page);
2182                 pcb->pcb_l1vec = l2b->l2b_phys | L1_C_PROTO |
2183                     L1_C_DOM(pm->pm_domain) | L1_C_DOM(PMAP_DOMAIN_KERNEL);
2184         } else
2185                 pcb->pcb_pl1vec = NULL;
2186 }
2187
2188 void
2189 pmap_activate(struct thread *td)
2190 {
2191         pmap_t pm;
2192         struct pcb *pcb;
2193
2194         pm = vmspace_pmap(td->td_proc->p_vmspace);
2195         pcb = td->td_pcb;
2196
2197         critical_enter();
2198         pmap_set_pcb_pagedir(pm, pcb);
2199
2200         if (td == curthread) {
2201                 u_int cur_dacr, cur_ttb;
2202
2203                 __asm __volatile("mrc p15, 0, %0, c2, c0, 0" : "=r"(cur_ttb));
2204                 __asm __volatile("mrc p15, 0, %0, c3, c0, 0" : "=r"(cur_dacr));
2205
2206                 cur_ttb &= ~(L1_TABLE_SIZE - 1);
2207
2208                 if (cur_ttb == (u_int)pcb->pcb_pagedir &&
2209                     cur_dacr == pcb->pcb_dacr) {
2210                         /*
2211                          * No need to switch address spaces.
2212                          */
2213                         critical_exit();
2214                         return;
2215                 }
2216
2217
2218                 /*
2219                  * We MUST, I repeat, MUST fix up the L1 entry corresponding
2220                  * to 'vector_page' in the incoming L1 table before switching
2221                  * to it otherwise subsequent interrupts/exceptions (including
2222                  * domain faults!) will jump into hyperspace.
2223                  */
2224                 if (pcb->pcb_pl1vec) {
2225
2226                         *pcb->pcb_pl1vec = pcb->pcb_l1vec;
2227                         /*
2228                          * Don't need to PTE_SYNC() at this point since
2229                          * cpu_setttb() is about to flush both the cache
2230                          * and the TLB.
2231                          */
2232                 }
2233
2234                 cpu_domains(pcb->pcb_dacr);
2235                 cpu_setttb(pcb->pcb_pagedir);
2236         }
2237         critical_exit();
2238 }
2239
2240 static int
2241 pmap_set_pt_cache_mode(pd_entry_t *kl1, vm_offset_t va)
2242 {
2243         pd_entry_t *pdep, pde;
2244         pt_entry_t *ptep, pte;
2245         vm_offset_t pa;
2246         int rv = 0;
2247
2248         /*
2249          * Make sure the descriptor itself has the correct cache mode
2250          */
2251         pdep = &kl1[L1_IDX(va)];
2252         pde = *pdep;
2253
2254         if (l1pte_section_p(pde)) {
2255                 if ((pde & L1_S_CACHE_MASK) != pte_l1_s_cache_mode_pt) {
2256                         *pdep = (pde & ~L1_S_CACHE_MASK) |
2257                             pte_l1_s_cache_mode_pt;
2258                         PTE_SYNC(pdep);
2259                         cpu_dcache_wbinv_range((vm_offset_t)pdep,
2260                             sizeof(*pdep));
2261                         cpu_l2cache_wbinv_range((vm_offset_t)pdep,
2262                             sizeof(*pdep));
2263                         rv = 1;
2264                 }
2265         } else {
2266                 pa = (vm_paddr_t)(pde & L1_C_ADDR_MASK);
2267                 ptep = (pt_entry_t *)kernel_pt_lookup(pa);
2268                 if (ptep == NULL)
2269                         panic("pmap_bootstrap: No L2 for L2 @ va %p\n", ptep);
2270
2271                 ptep = &ptep[l2pte_index(va)];
2272                 pte = *ptep;
2273                 if ((pte & L2_S_CACHE_MASK) != pte_l2_s_cache_mode_pt) {
2274                         *ptep = (pte & ~L2_S_CACHE_MASK) |
2275                             pte_l2_s_cache_mode_pt;
2276                         PTE_SYNC(ptep);
2277                         cpu_dcache_wbinv_range((vm_offset_t)ptep,
2278                             sizeof(*ptep));
2279                         cpu_l2cache_wbinv_range((vm_offset_t)ptep,
2280                             sizeof(*ptep));
2281                         rv = 1;
2282                 }
2283         }
2284
2285         return (rv);
2286 }
2287
2288 static void
2289 pmap_alloc_specials(vm_offset_t *availp, int pages, vm_offset_t *vap, 
2290     pt_entry_t **ptep)
2291 {
2292         vm_offset_t va = *availp;
2293         struct l2_bucket *l2b;
2294
2295         if (ptep) {
2296                 l2b = pmap_get_l2_bucket(pmap_kernel(), va);
2297                 if (l2b == NULL)
2298                         panic("pmap_alloc_specials: no l2b for 0x%x", va);
2299
2300                 *ptep = &l2b->l2b_kva[l2pte_index(va)];
2301         }
2302
2303         *vap = va;
2304         *availp = va + (PAGE_SIZE * pages);
2305 }
2306
2307 /*
2308  *      Bootstrap the system enough to run with virtual memory.
2309  *
2310  *      On the arm this is called after mapping has already been enabled
2311  *      and just syncs the pmap module with what has already been done.
2312  *      [We can't call it easily with mapping off since the kernel is not
2313  *      mapped with PA == VA, hence we would have to relocate every address
2314  *      from the linked base (virtual) address "KERNBASE" to the actual
2315  *      (physical) address starting relative to 0]
2316  */
2317 #define PMAP_STATIC_L2_SIZE 16
2318 #ifdef ARM_USE_SMALL_ALLOC
2319 extern struct mtx smallalloc_mtx;
2320 #endif
2321
2322 void
2323 pmap_bootstrap(vm_offset_t firstaddr, vm_offset_t lastaddr, struct pv_addr *l1pt)
2324 {
2325         static struct l1_ttable static_l1;
2326         static struct l2_dtable static_l2[PMAP_STATIC_L2_SIZE];
2327         struct l1_ttable *l1 = &static_l1;
2328         struct l2_dtable *l2;
2329         struct l2_bucket *l2b;
2330         pd_entry_t pde;
2331         pd_entry_t *kernel_l1pt = (pd_entry_t *)l1pt->pv_va;
2332         pt_entry_t *ptep;
2333         vm_paddr_t pa;
2334         vm_offset_t va;
2335         vm_size_t size;
2336         int l1idx, l2idx, l2next = 0;
2337
2338         PDEBUG(1, printf("firstaddr = %08x, lastaddr = %08x\n",
2339             firstaddr, lastaddr));
2340         
2341         virtual_avail = firstaddr;
2342         kernel_pmap->pm_l1 = l1;
2343         kernel_l1pa = l1pt->pv_pa;
2344         
2345         /*
2346          * Scan the L1 translation table created by initarm() and create
2347          * the required metadata for all valid mappings found in it.
2348          */
2349         for (l1idx = 0; l1idx < (L1_TABLE_SIZE / sizeof(pd_entry_t)); l1idx++) {
2350                 pde = kernel_l1pt[l1idx];
2351
2352                 /*
2353                  * We're only interested in Coarse mappings.
2354                  * pmap_extract() can deal with section mappings without
2355                  * recourse to checking L2 metadata.
2356                  */
2357                 if ((pde & L1_TYPE_MASK) != L1_TYPE_C)
2358                         continue;
2359
2360                 /*
2361                  * Lookup the KVA of this L2 descriptor table
2362                  */
2363                 pa = (vm_paddr_t)(pde & L1_C_ADDR_MASK);
2364                 ptep = (pt_entry_t *)kernel_pt_lookup(pa);
2365                 
2366                 if (ptep == NULL) {
2367                         panic("pmap_bootstrap: No L2 for va 0x%x, pa 0x%lx",
2368                             (u_int)l1idx << L1_S_SHIFT, (long unsigned int)pa);
2369                 }
2370
2371                 /*
2372                  * Fetch the associated L2 metadata structure.
2373                  * Allocate a new one if necessary.
2374                  */
2375                 if ((l2 = kernel_pmap->pm_l2[L2_IDX(l1idx)]) == NULL) {
2376                         if (l2next == PMAP_STATIC_L2_SIZE)
2377                                 panic("pmap_bootstrap: out of static L2s");
2378                         kernel_pmap->pm_l2[L2_IDX(l1idx)] = l2 = 
2379                             &static_l2[l2next++];
2380                 }
2381
2382                 /*
2383                  * One more L1 slot tracked...
2384                  */
2385                 l2->l2_occupancy++;
2386
2387                 /*
2388                  * Fill in the details of the L2 descriptor in the
2389                  * appropriate bucket.
2390                  */
2391                 l2b = &l2->l2_bucket[L2_BUCKET(l1idx)];
2392                 l2b->l2b_kva = ptep;
2393                 l2b->l2b_phys = pa;
2394                 l2b->l2b_l1idx = l1idx;
2395
2396                 /*
2397                  * Establish an initial occupancy count for this descriptor
2398                  */
2399                 for (l2idx = 0;
2400                     l2idx < (L2_TABLE_SIZE_REAL / sizeof(pt_entry_t));
2401                     l2idx++) {
2402                         if ((ptep[l2idx] & L2_TYPE_MASK) != L2_TYPE_INV) {
2403                                 l2b->l2b_occupancy++;
2404                         }
2405                 }
2406
2407                 /*
2408                  * Make sure the descriptor itself has the correct cache mode.
2409                  * If not, fix it, but whine about the problem. Port-meisters
2410                  * should consider this a clue to fix up their initarm()
2411                  * function. :)
2412                  */
2413                 if (pmap_set_pt_cache_mode(kernel_l1pt, (vm_offset_t)ptep)) {
2414                         printf("pmap_bootstrap: WARNING! wrong cache mode for "
2415                             "L2 pte @ %p\n", ptep);
2416                 }
2417         }
2418
2419         
2420         /*
2421          * Ensure the primary (kernel) L1 has the correct cache mode for
2422          * a page table. Bitch if it is not correctly set.
2423          */
2424         for (va = (vm_offset_t)kernel_l1pt;
2425             va < ((vm_offset_t)kernel_l1pt + L1_TABLE_SIZE); va += PAGE_SIZE) {
2426                 if (pmap_set_pt_cache_mode(kernel_l1pt, va))
2427                         printf("pmap_bootstrap: WARNING! wrong cache mode for "
2428                             "primary L1 @ 0x%x\n", va);
2429         }
2430
2431         cpu_dcache_wbinv_all();
2432         cpu_l2cache_wbinv_all();
2433         cpu_tlb_flushID();
2434         cpu_cpwait();
2435
2436         PMAP_LOCK_INIT(kernel_pmap);
2437         kernel_pmap->pm_active = -1;
2438         kernel_pmap->pm_domain = PMAP_DOMAIN_KERNEL;
2439         TAILQ_INIT(&kernel_pmap->pm_pvlist);
2440         
2441         /*
2442          * Reserve some special page table entries/VA space for temporary
2443          * mapping of pages.
2444          */
2445 #define SYSMAP(c, p, v, n)                                              \
2446     v = (c)va; va += ((n)*PAGE_SIZE); p = pte; pte += (n);
2447     
2448         pmap_alloc_specials(&virtual_avail, 1, &csrcp, &csrc_pte);
2449         pmap_set_pt_cache_mode(kernel_l1pt, (vm_offset_t)csrc_pte);
2450         pmap_alloc_specials(&virtual_avail, 1, &cdstp, &cdst_pte);
2451         pmap_set_pt_cache_mode(kernel_l1pt, (vm_offset_t)cdst_pte);
2452         size = ((lastaddr - pmap_curmaxkvaddr) + L1_S_OFFSET) / L1_S_SIZE;
2453         pmap_alloc_specials(&virtual_avail,
2454             round_page(size * L2_TABLE_SIZE_REAL) / PAGE_SIZE,
2455             &pmap_kernel_l2ptp_kva, NULL);
2456         
2457         size = (size + (L2_BUCKET_SIZE - 1)) / L2_BUCKET_SIZE;
2458         pmap_alloc_specials(&virtual_avail,
2459             round_page(size * sizeof(struct l2_dtable)) / PAGE_SIZE,
2460             &pmap_kernel_l2dtable_kva, NULL);
2461
2462         pmap_alloc_specials(&virtual_avail,
2463             1, (vm_offset_t*)&_tmppt, NULL);
2464         pmap_alloc_specials(&virtual_avail,
2465             MAXDUMPPGS, (vm_offset_t *)&crashdumpmap, NULL);
2466         SLIST_INIT(&l1_list);
2467         TAILQ_INIT(&l1_lru_list);
2468         mtx_init(&l1_lru_lock, "l1 list lock", NULL, MTX_DEF);
2469         pmap_init_l1(l1, kernel_l1pt);
2470         cpu_dcache_wbinv_all();
2471         cpu_l2cache_wbinv_all();
2472
2473         virtual_avail = round_page(virtual_avail);
2474         virtual_end = lastaddr;
2475         kernel_vm_end = pmap_curmaxkvaddr;
2476         arm_nocache_startaddr = lastaddr;
2477         mtx_init(&cmtx, "TMP mappings mtx", NULL, MTX_DEF);
2478
2479 #ifdef ARM_USE_SMALL_ALLOC
2480         mtx_init(&smallalloc_mtx, "Small alloc page list", NULL, MTX_DEF);
2481         arm_init_smallalloc();
2482 #endif
2483         pmap_set_pcb_pagedir(kernel_pmap, thread0.td_pcb);
2484 }
2485
2486 /***************************************************
2487  * Pmap allocation/deallocation routines.
2488  ***************************************************/
2489
2490 /*
2491  * Release any resources held by the given physical map.
2492  * Called when a pmap initialized by pmap_pinit is being released.
2493  * Should only be called if the map contains no valid mappings.
2494  */
2495 void
2496 pmap_release(pmap_t pmap)
2497 {
2498         struct pcb *pcb;
2499         
2500         pmap_idcache_wbinv_all(pmap);
2501         cpu_l2cache_wbinv_all();
2502         pmap_tlb_flushID(pmap);
2503         cpu_cpwait();
2504         if (vector_page < KERNBASE) {
2505                 struct pcb *curpcb = PCPU_GET(curpcb);
2506                 pcb = thread0.td_pcb;
2507                 if (pmap_is_current(pmap)) {
2508                         /*
2509                          * Frob the L1 entry corresponding to the vector
2510                          * page so that it contains the kernel pmap's domain
2511                          * number. This will ensure pmap_remove() does not
2512                          * pull the current vector page out from under us.
2513                          */
2514                         critical_enter();
2515                         *pcb->pcb_pl1vec = pcb->pcb_l1vec;
2516                         cpu_domains(pcb->pcb_dacr);
2517                         cpu_setttb(pcb->pcb_pagedir);
2518                         critical_exit();
2519                 }
2520                 pmap_remove(pmap, vector_page, vector_page + PAGE_SIZE);
2521                 /*
2522                  * Make sure cpu_switch(), et al, DTRT. This is safe to do
2523                  * since this process has no remaining mappings of its own.
2524                  */
2525                 curpcb->pcb_pl1vec = pcb->pcb_pl1vec;
2526                 curpcb->pcb_l1vec = pcb->pcb_l1vec;
2527                 curpcb->pcb_dacr = pcb->pcb_dacr;
2528                 curpcb->pcb_pagedir = pcb->pcb_pagedir;
2529
2530         }
2531         pmap_free_l1(pmap);
2532         PMAP_LOCK_DESTROY(pmap);
2533         
2534         dprintf("pmap_release()\n");
2535 }
2536
2537
2538
2539 /*
2540  * Helper function for pmap_grow_l2_bucket()
2541  */
2542 static __inline int
2543 pmap_grow_map(vm_offset_t va, pt_entry_t cache_mode, vm_paddr_t *pap)
2544 {
2545         struct l2_bucket *l2b;
2546         pt_entry_t *ptep;
2547         vm_paddr_t pa;
2548         struct vm_page *pg;
2549         
2550         pg = vm_page_alloc(NULL, 0, VM_ALLOC_NOOBJ | VM_ALLOC_WIRED);
2551         if (pg == NULL)
2552                 return (1);
2553         pa = VM_PAGE_TO_PHYS(pg);
2554
2555         if (pap)
2556                 *pap = pa;
2557
2558         l2b = pmap_get_l2_bucket(pmap_kernel(), va);
2559
2560         ptep = &l2b->l2b_kva[l2pte_index(va)];
2561         *ptep = L2_S_PROTO | pa | cache_mode |
2562             L2_S_PROT(PTE_KERNEL, VM_PROT_READ | VM_PROT_WRITE);
2563         PTE_SYNC(ptep);
2564         return (0);
2565 }
2566
2567 /*
2568  * This is the same as pmap_alloc_l2_bucket(), except that it is only
2569  * used by pmap_growkernel().
2570  */
2571 static __inline struct l2_bucket *
2572 pmap_grow_l2_bucket(pmap_t pm, vm_offset_t va)
2573 {
2574         struct l2_dtable *l2;
2575         struct l2_bucket *l2b;
2576         struct l1_ttable *l1;
2577         pd_entry_t *pl1pd;
2578         u_short l1idx;
2579         vm_offset_t nva;
2580
2581         l1idx = L1_IDX(va);
2582
2583         if ((l2 = pm->pm_l2[L2_IDX(l1idx)]) == NULL) {
2584                 /*
2585                  * No mapping at this address, as there is
2586                  * no entry in the L1 table.
2587                  * Need to allocate a new l2_dtable.
2588                  */
2589                 nva = pmap_kernel_l2dtable_kva;
2590                 if ((nva & PAGE_MASK) == 0) {
2591                         /*
2592                          * Need to allocate a backing page
2593                          */
2594                         if (pmap_grow_map(nva, pte_l2_s_cache_mode, NULL))
2595                                 return (NULL);
2596                 }
2597
2598                 l2 = (struct l2_dtable *)nva;
2599                 nva += sizeof(struct l2_dtable);
2600
2601                 if ((nva & PAGE_MASK) < (pmap_kernel_l2dtable_kva & 
2602                     PAGE_MASK)) {
2603                         /*
2604                          * The new l2_dtable straddles a page boundary.
2605                          * Map in another page to cover it.
2606                          */
2607                         if (pmap_grow_map(nva, pte_l2_s_cache_mode, NULL))
2608                                 return (NULL);
2609                 }
2610
2611                 pmap_kernel_l2dtable_kva = nva;
2612
2613                 /*
2614                  * Link it into the parent pmap
2615                  */
2616                 pm->pm_l2[L2_IDX(l1idx)] = l2;
2617                 memset(l2, 0, sizeof(*l2));
2618         }
2619
2620         l2b = &l2->l2_bucket[L2_BUCKET(l1idx)];
2621
2622         /*
2623          * Fetch pointer to the L2 page table associated with the address.
2624          */
2625         if (l2b->l2b_kva == NULL) {
2626                 pt_entry_t *ptep;
2627
2628                 /*
2629                  * No L2 page table has been allocated. Chances are, this
2630                  * is because we just allocated the l2_dtable, above.
2631                  */
2632                 nva = pmap_kernel_l2ptp_kva;
2633                 ptep = (pt_entry_t *)nva;
2634                 if ((nva & PAGE_MASK) == 0) {
2635                         /*
2636                          * Need to allocate a backing page
2637                          */
2638                         if (pmap_grow_map(nva, pte_l2_s_cache_mode_pt,
2639                             &pmap_kernel_l2ptp_phys))
2640                                 return (NULL);
2641                         PTE_SYNC_RANGE(ptep, PAGE_SIZE / sizeof(pt_entry_t));
2642                 }
2643                 memset(ptep, 0, L2_TABLE_SIZE_REAL);
2644                 l2->l2_occupancy++;
2645                 l2b->l2b_kva = ptep;
2646                 l2b->l2b_l1idx = l1idx;
2647                 l2b->l2b_phys = pmap_kernel_l2ptp_phys;
2648
2649                 pmap_kernel_l2ptp_kva += L2_TABLE_SIZE_REAL;
2650                 pmap_kernel_l2ptp_phys += L2_TABLE_SIZE_REAL;
2651         }
2652
2653         /* Distribute new L1 entry to all other L1s */
2654         SLIST_FOREACH(l1, &l1_list, l1_link) {
2655                         pl1pd = &l1->l1_kva[L1_IDX(va)];
2656                         *pl1pd = l2b->l2b_phys | L1_C_DOM(PMAP_DOMAIN_KERNEL) |
2657                             L1_C_PROTO;
2658                         PTE_SYNC(pl1pd);
2659         }
2660
2661         return (l2b);
2662 }
2663
2664
2665 /*
2666  * grow the number of kernel page table entries, if needed
2667  */
2668 void
2669 pmap_growkernel(vm_offset_t addr)
2670 {
2671         pmap_t kpm = pmap_kernel();
2672
2673         if (addr <= pmap_curmaxkvaddr)
2674                 return;         /* we are OK */
2675
2676         /*
2677          * whoops!   we need to add kernel PTPs
2678          */
2679
2680         /* Map 1MB at a time */
2681         for (; pmap_curmaxkvaddr < addr; pmap_curmaxkvaddr += L1_S_SIZE)
2682                 pmap_grow_l2_bucket(kpm, pmap_curmaxkvaddr);
2683
2684         /*
2685          * flush out the cache, expensive but growkernel will happen so
2686          * rarely
2687          */
2688         cpu_dcache_wbinv_all();
2689         cpu_l2cache_wbinv_all();
2690         cpu_tlb_flushD();
2691         cpu_cpwait();
2692         kernel_vm_end = pmap_curmaxkvaddr;
2693 }
2694
2695
2696 /*
2697  * Remove all pages from specified address space
2698  * this aids process exit speeds.  Also, this code
2699  * is special cased for current process only, but
2700  * can have the more generic (and slightly slower)
2701  * mode enabled.  This is much faster than pmap_remove
2702  * in the case of running down an entire address space.
2703  */
2704 void
2705 pmap_remove_pages(pmap_t pmap)
2706 {
2707         struct pv_entry *pv, *npv;
2708         struct l2_bucket *l2b = NULL;
2709         vm_page_t m;
2710         pt_entry_t *pt;
2711         
2712         vm_page_lock_queues();
2713         PMAP_LOCK(pmap);
2714         cpu_idcache_wbinv_all();
2715         cpu_l2cache_wbinv_all();
2716         for (pv = TAILQ_FIRST(&pmap->pm_pvlist); pv; pv = npv) {
2717                 if (pv->pv_flags & PVF_WIRED || pv->pv_flags & PVF_UNMAN) {
2718                         /* Cannot remove wired or unmanaged pages now. */
2719                         npv = TAILQ_NEXT(pv, pv_plist);
2720                         continue;
2721                 }
2722                 pmap->pm_stats.resident_count--;
2723       &n