Annotation of sys/arch/m88k/m88k/pmap.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: pmap.c,v 1.31 2007/05/27 20:59:25 miod Exp $ */
2: /*
3: * Copyright (c) 2001-2004, Miodrag Vallat
4: * Copyright (c) 1998-2001 Steve Murphree, Jr.
5: * Copyright (c) 1996 Nivas Madhur
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by Nivas Madhur.
19: * 4. The name of the author may not be used to endorse or promote products
20: * derived from this software without specific prior written permission
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32: *
33: */
34: /*
35: * Mach Operating System
36: * Copyright (c) 1991 Carnegie Mellon University
37: * Copyright (c) 1991 OMRON Corporation
38: * All Rights Reserved.
39: *
40: * Permission to use, copy, modify and distribute this software and its
41: * documentation is hereby granted, provided that both the copyright
42: * notice and this permission notice appear in all copies of the
43: * software, derivative works or modified versions, and any portions
44: * thereof, and that both notices appear in supporting documentation.
45: *
46: */
47:
48: #include <sys/param.h>
49: #include <sys/systm.h>
50: #include <sys/proc.h>
51: #include <sys/malloc.h>
52: #include <sys/pool.h>
53: #include <sys/msgbuf.h>
54: #include <sys/user.h>
55:
56: #include <machine/asm_macro.h>
57: #include <machine/cmmu.h>
58: #include <machine/cpu.h>
59: #include <machine/lock.h>
60: #include <machine/pmap_table.h>
61: #ifdef M88100
62: #include <machine/m8820x.h>
63: #endif
64:
65: #include <uvm/uvm.h>
66:
67: /*
68: * VM externals
69: */
70: extern vaddr_t avail_start;
71: extern vaddr_t virtual_avail, virtual_end;
72: extern vaddr_t last_addr;
73:
74: /*
75: * Macros to operate pm_cpus field
76: */
77: #define SETBIT_CPUSET(cpu_number, cpuset) (*(cpuset)) |= (1 << (cpu_number));
78: #define CLRBIT_CPUSET(cpu_number, cpuset) (*(cpuset)) &= ~(1 << (cpu_number));
79:
80: #ifdef DEBUG
81: /*
82: * Static variables, functions and variables for debugging
83: */
84:
85: /*
86: * conditional debugging
87: */
88: #define CD_FULL 0x02
89:
90: #define CD_ACTIVATE 0x0000004 /* pmap_activate */
91: #define CD_KMAP 0x0000008 /* pmap_expand_kmap */
92: #define CD_MAP 0x0000010 /* pmap_map */
93: #define CD_CACHE 0x0000020 /* pmap_cache_ctrl */
94: #define CD_INIT 0x0000080 /* pmap_init */
95: #define CD_CREAT 0x0000100 /* pmap_create */
96: #define CD_FREE 0x0000200 /* pmap_release */
97: #define CD_DESTR 0x0000400 /* pmap_destroy */
98: #define CD_RM 0x0000800 /* pmap_remove */
99: #define CD_RMAL 0x0001000 /* pmap_remove_all */
100: #define CD_PROT 0x0002000 /* pmap_protect */
101: #define CD_EXP 0x0004000 /* pmap_expand */
102: #define CD_ENT 0x0008000 /* pmap_enter */
103: #define CD_UPD 0x0010000 /* pmap_update */
104: #define CD_COL 0x0020000 /* pmap_collect */
105: #define CD_CBIT 0x0040000 /* pmap_changebit */
106: #define CD_TBIT 0x0080000 /* pmap_testbit */
107: #define CD_USBIT 0x0100000 /* pmap_unsetbit */
108: #define CD_ALL 0x0FFFFFC
109:
110: int pmap_con_dbg = 0;
111:
112: #endif /* DEBUG */
113:
114: struct pool pmappool, pvpool;
115:
116: caddr_t vmmap;
117: pt_entry_t *vmpte, *msgbufmap;
118:
119: struct pmap kernel_pmap_store;
120: pmap_t kernel_pmap = &kernel_pmap_store;
121:
122: typedef struct kpdt_entry *kpdt_entry_t;
123: struct kpdt_entry {
124: kpdt_entry_t next;
125: paddr_t phys;
126: };
127:
128: kpdt_entry_t kpdt_free;
129:
130: /*
131: * Two pages of scratch space per cpu.
132: * Used in pmap_copy_page() and pmap_zero_page().
133: */
134: vaddr_t phys_map_vaddr, phys_map_vaddr_end;
135:
136: static pv_entry_t pg_to_pvh(struct vm_page *);
137:
138: static __inline pv_entry_t
139: pg_to_pvh(struct vm_page *pg)
140: {
141: return &pg->mdpage.pvent;
142: }
143:
144: /*
145: * Locking primitives
146: */
147:
148: #ifdef MULTIPROCESSOR
149: #define PMAP_LOCK(pmap) __cpu_simple_lock(&(pmap)->pm_lock)
150: #define PMAP_UNLOCK(pmap) __cpu_simple_unlock(&(pmap)->pm_lock)
151: #else
152: #define PMAP_LOCK(pmap) do { /* nothing */ } while (0)
153: #define PMAP_UNLOCK(pmap) do { /* nothing */ } while (0)
154: #endif
155:
156: vaddr_t kmapva = 0;
157:
158: /*
159: * Internal routines
160: */
161: static void flush_atc_entry(pmap_t, vaddr_t);
162: pt_entry_t *pmap_expand_kmap(vaddr_t, vm_prot_t, int);
163: void pmap_remove_pte(pmap_t, vaddr_t, pt_entry_t *);
164: void pmap_remove_range(pmap_t, vaddr_t, vaddr_t);
165: void pmap_expand(pmap_t, vaddr_t);
166: void pmap_release(pmap_t);
167: vaddr_t pmap_map(vaddr_t, paddr_t, paddr_t, vm_prot_t, u_int);
168: pt_entry_t *pmap_pte(pmap_t, vaddr_t);
169: void pmap_remove_all(struct vm_page *);
170: void pmap_changebit(struct vm_page *, int, int);
171: boolean_t pmap_unsetbit(struct vm_page *, int);
172: boolean_t pmap_testbit(struct vm_page *, int);
173:
174: /*
175: * quick PTE field checking macros
176: */
177: #define pmap_pte_w(pte) (*(pte) & PG_W)
178: #define pmap_pte_prot(pte) (*(pte) & PG_PROT)
179:
180: #define pmap_pte_w_chg(pte, nw) ((nw) ^ pmap_pte_w(pte))
181: #define pmap_pte_prot_chg(pte, np) ((np) ^ pmap_pte_prot(pte))
182:
183: #define m88k_protection(prot) ((prot) & VM_PROT_WRITE ? PG_RW : PG_RO)
184:
185: #define SDTENT(map, va) ((sdt_entry_t *)((map)->pm_stab + SDTIDX(va)))
186:
187: /*
188: * Routine: FLUSH_ATC_ENTRY
189: *
190: * Function:
191: * Flush atc (TLB) which maps given pmap and virtual address.
192: *
193: * Parameters:
194: * pmap affected pmap
195: * va virtual address that should be flushed
196: */
197: static
198: #ifndef MULTIPROCESSOR
199: __inline__
200: #endif
201: void
202: flush_atc_entry(pmap_t pmap, vaddr_t va)
203: {
204: #ifdef MULTIPROCESSOR
205: u_int32_t users;
206: int cpu;
207: boolean_t kernel;
208:
209: if ((users = pmap->pm_cpus) == 0)
210: return;
211:
212: kernel = pmap == kernel_pmap;
213: while ((cpu = ff1(users)) != 32) {
214: #ifdef DIAGNOSTIC
215: if (m88k_cpus[cpu].ci_alive)
216: #endif
217: cmmu_flush_tlb(cpu, kernel, va, 1);
218: users ^= 1 << cpu;
219: }
220: #else /* MULTIPROCESSOR */
221: if (pmap->pm_cpus != 0)
222: cmmu_flush_tlb(cpu_number(), pmap == kernel_pmap, va, 1);
223: #endif /* MULTIPROCESSOR */
224: }
225:
226: /*
227: * Routine: PMAP_PTE
228: *
229: * Function:
230: * Given a map and a virtual address, compute a (virtual) pointer
231: * to the page table entry (PTE) which maps the address .
232: * If the page table associated with the address does not
233: * exist, NULL is returned (and the map may need to grow).
234: *
235: * Parameters:
236: * pmap pointer to pmap structure
237: * virt virtual address for which page table entry is desired
238: *
239: * Otherwise the page table address is extracted from the segment table,
240: * the page table index is added, and the result is returned.
241: */
242:
243: static __inline__
244: pt_entry_t *
245: sdt_pte(sdt_entry_t *sdt, vaddr_t va)
246: {
247: return ((pt_entry_t *)
248: (PG_PFNUM(*(sdt + SDT_ENTRIES)) << PDT_SHIFT) + PDTIDX(va));
249: }
250:
251: pt_entry_t *
252: pmap_pte(pmap_t pmap, vaddr_t virt)
253: {
254: sdt_entry_t *sdt;
255:
256: sdt = SDTENT(pmap, virt);
257: /*
258: * Check whether page table exists.
259: */
260: if (!SDT_VALID(sdt))
261: return (NULL);
262:
263: return (sdt_pte(sdt, virt));
264: }
265:
266: /*
267: * Routine: PMAP_EXPAND_KMAP (internal)
268: *
269: * Function:
270: * Allocate a page descriptor table (pte_table) and validate associated
271: * segment table entry, returning pointer to page table entry. This is
272: * much like 'pmap_expand', except that table space is acquired
273: * from an area set up by pmap_bootstrap, instead of through
274: * uvm_km_zalloc. (Obviously, because uvm_km_zalloc uses the kernel map
275: * for allocation - which we can't do when trying to expand the
276: * kernel map!) Note that segment tables for the kernel map were
277: * all allocated at pmap_bootstrap time, so we only need to worry
278: * about the page table here.
279: *
280: * Parameters:
281: * virt VA for which translation tables are needed
282: * prot protection attributes for segment entries
283: *
284: * Extern/Global:
285: * kpdt_free kernel page table free queue
286: *
287: * This routine simply dequeues a table from the kpdt_free list,
288: * initializes all its entries (invalidates them), and sets the
289: * corresponding segment table entry to point to it. If the kpdt_free
290: * list is empty - we panic (no other places to get memory, sorry). (Such
291: * a panic indicates that pmap_bootstrap is not allocating enough table
292: * space for the kernel virtual address space).
293: *
294: */
295: pt_entry_t *
296: pmap_expand_kmap(vaddr_t virt, vm_prot_t prot, int canfail)
297: {
298: sdt_entry_t template, *sdt;
299: kpdt_entry_t kpdt_ent;
300:
301: #ifdef DEBUG
302: if ((pmap_con_dbg & (CD_KMAP | CD_FULL)) == (CD_KMAP | CD_FULL))
303: printf("(pmap_expand_kmap: %x) v %x\n", curproc, virt);
304: #endif
305:
306: template = m88k_protection(prot) | PG_M | SG_V;
307:
308: /* segment table entry derivate from map and virt. */
309: sdt = SDTENT(kernel_pmap, virt);
310: #ifdef DEBUG
311: if (SDT_VALID(sdt))
312: panic("pmap_expand_kmap: segment table entry VALID");
313: #endif
314:
315: kpdt_ent = kpdt_free;
316: if (kpdt_ent == NULL) {
317: if (canfail)
318: return (NULL);
319: else
320: panic("pmap_expand_kmap: Ran out of kernel pte tables");
321: }
322:
323: kpdt_free = kpdt_free->next;
324: /* physical table */
325: *sdt = kpdt_ent->phys | template;
326: /* virtual table */
327: *(sdt + SDT_ENTRIES) = (vaddr_t)kpdt_ent | template;
328:
329: /* Reinitialize this kpdt area to zero */
330: bzero((void *)kpdt_ent, PDT_SIZE);
331:
332: return (pt_entry_t *)(kpdt_ent) + PDTIDX(virt);
333: }
334:
335: /*
336: * Routine: PMAP_MAP
337: *
338: * Function:
339: * Map memory at initialization. The physical addresses being
340: * mapped are not managed and are never unmapped.
341: *
342: * Parameters:
343: * virt virtual address of range to map
344: * start physical address of range to map
345: * end physical address of end of range
346: * prot protection attributes
347: * cmode cache control attributes
348: *
349: * Calls:
350: * pmap_pte
351: * pmap_expand_kmap
352: *
353: * Special Assumptions
354: * For now, VM is already on, only need to map the specified
355: * memory. Used only by pmap_bootstrap() and vm_page_startup().
356: *
357: * For each page that needs mapping:
358: * pmap_pte is called to obtain the address of the page table
359: * table entry (PTE). If the page table does not exist,
360: * pmap_expand_kmap is called to allocate it. Finally, the page table
361: * entry is set to point to the physical page.
362: *
363: * initialize template with paddr, prot, dt
364: * look for number of phys pages in range
365: * {
366: * pmap_pte(virt) - expand if necessary
367: * stuff pte from template
368: * increment virt one page
369: * increment template paddr one page
370: * }
371: *
372: */
373: vaddr_t
374: pmap_map(vaddr_t virt, paddr_t start, paddr_t end, vm_prot_t prot, u_int cmode)
375: {
376: u_int npages;
377: u_int num_phys_pages;
378: pt_entry_t template, *pte;
379: paddr_t page;
380:
381: #ifdef DEBUG
382: if (pmap_con_dbg & CD_MAP)
383: printf ("(pmap_map: %x) phys address from %x to %x mapped at virtual %x, prot %x cmode %x\n",
384: curproc, start, end, virt, prot, cmode);
385: #endif
386:
387: #ifdef DEBUG
388: /* Check for zero if we map the very end of the address space... */
389: if (start > end && end != 0) {
390: panic("pmap_map: start greater than end address");
391: }
392: #endif
393:
394: template = m88k_protection(prot) | cmode | PG_V;
395: #ifdef M88110
396: if (CPU_IS88110 && m88k_protection(prot) != PG_RO)
397: template |= PG_M;
398: #endif
399:
400: page = trunc_page(start);
401: npages = atop(round_page(end) - page);
402: for (num_phys_pages = npages; num_phys_pages != 0; num_phys_pages--) {
403: if ((pte = pmap_pte(kernel_pmap, virt)) == NULL)
404: pte = pmap_expand_kmap(virt,
405: VM_PROT_READ | VM_PROT_WRITE, 0);
406:
407: #ifdef DEBUG
408: if ((pmap_con_dbg & (CD_MAP | CD_FULL)) == (CD_MAP | CD_FULL))
409: if (PDT_VALID(pte))
410: printf("(pmap_map: %x) pte @ %p already valid\n", curproc, pte);
411: #endif
412:
413: *pte = template | page;
414: virt += PAGE_SIZE;
415: page += PAGE_SIZE;
416: }
417: return virt;
418: }
419:
420: /*
421: * Routine: PMAP_CACHE_CONTROL
422: *
423: * Function:
424: * Set the cache-control bits in the page table entries(PTE) which maps
425: * the specified virtual address range.
426: *
427: * Parameters:
428: * pmap_t pmap
429: * vaddr_t s
430: * vaddr_t e
431: * u_int mode
432: *
433: * Calls:
434: * pmap_pte
435: * invalidate_pte
436: * flush_atc_entry
437: *
438: * This routine sequences through the pages of the specified range.
439: * For each, it calls pmap_pte to acquire a pointer to the page table
440: * entry (PTE). If the PTE is invalid, or non-existent, nothing is done.
441: * Otherwise, the cache-control bits in the PTE's are adjusted as specified.
442: *
443: */
444: void
445: pmap_cache_ctrl(pmap_t pmap, vaddr_t s, vaddr_t e, u_int mode)
446: {
447: int spl;
448: pt_entry_t opte, *pte;
449: vaddr_t va;
450: paddr_t pa;
451: cpuid_t cpu;
452:
453: #ifdef DEBUG
454: if ((mode & CACHE_MASK) != mode) {
455: printf("(cache_ctrl) illegal mode %x\n", mode);
456: return;
457: }
458: if (pmap_con_dbg & CD_CACHE) {
459: printf("(pmap_cache_ctrl: %x) pmap %x, va %x, mode %x\n", curproc, pmap, s, mode);
460: }
461:
462: if (pmap == NULL)
463: panic("pmap_cache_ctrl: pmap is NULL");
464: #endif /* DEBUG */
465:
466: spl = splvm();
467: PMAP_LOCK(pmap);
468:
469: for (va = s; va != e; va += PAGE_SIZE) {
470: if ((pte = pmap_pte(pmap, va)) == NULL)
471: continue;
472: #ifdef DEBUG
473: if (pmap_con_dbg & CD_CACHE) {
474: printf("(cache_ctrl) pte@%p\n", pte);
475: }
476: #endif /* DEBUG */
477: /*
478: * Invalidate pte temporarily to avoid being written back
479: * the modified bit and/or the reference bit by any other cpu.
480: * XXX
481: */
482: opte = invalidate_pte(pte);
483: *pte = (opte & ~CACHE_MASK) | mode;
484: flush_atc_entry(pmap, va);
485:
486: /*
487: * Data cache should be copied back and invalidated if
488: * the old mapping was cached.
489: */
490: if ((opte & CACHE_INH) == 0) {
491: pa = ptoa(PG_PFNUM(opte));
492: #ifdef MULTIPROCESSOR
493: for (cpu = 0; cpu < MAX_CPUS; cpu++)
494: if (m88k_cpus[cpu].ci_alive != 0)
495: #else
496: cpu = cpu_number();
497: #endif
498: cmmu_flush_cache(cpu, pa, PAGE_SIZE);
499: }
500: }
501: PMAP_UNLOCK(pmap);
502: splx(spl);
503: }
504:
505: /*
506: * Routine: PMAP_BOOTSTRAP
507: *
508: * Function:
509: * Bootstrap the system enough to run with virtual memory.
510: * Map the kernel's code and data, allocate the kernel
511: * translation table space, and map control registers
512: * and other IO addresses.
513: *
514: * Parameters:
515: * load_start PA where kernel was loaded
516: *
517: * Extern/Global:
518: *
519: * PAGE_SIZE VM (software) page size
520: * etext end of kernel text
521: * phys_map_vaddr VA of page mapped arbitrarily for debug/IO
522: *
523: * Calls:
524: * __cpu_simple_lock_init
525: * pmap_map
526: *
527: * The physical address 'load_start' is mapped at
528: * VM_MIN_KERNEL_ADDRESS, which maps the kernel code and data at the
529: * virtual address for which it was (presumably) linked. Immediately
530: * following the end of the kernel code/data, sufficient page of
531: * physical memory are reserved to hold translation tables for the kernel
532: * address space.
533: *
534: * A pair of virtual pages per cpu are reserved for debugging and
535: * IO purposes. They are arbitrarily mapped when needed. They are used,
536: * for example, by pmap_copy_page and pmap_zero_page.
537: *
538: * This implementation also assumes that the space below the kernel
539: * is reserved (typically from PROM purposes). We should ideally map it
540: * read only except when invoking its services...
541: */
542:
543: void
544: pmap_bootstrap(vaddr_t load_start)
545: {
546: kpdt_entry_t kpdt_virt;
547: sdt_entry_t *kmap;
548: vaddr_t vaddr, virt;
549: paddr_t s_text, e_text, kpdt_phys;
550: unsigned int kernel_pmap_size, pdt_size;
551: int i;
552: #ifndef MULTIPROCESSOR
553: cpuid_t cpu;
554: #endif
555: pmap_table_t ptable;
556: extern void *etext;
557:
558: #ifdef MULTIPROCESSOR
559: __cpu_simple_lock_init(&kernel_pmap->pm_lock);
560: #endif
561:
562: /*
563: * Allocate the kernel page table from the front of available
564: * physical memory, i.e. just after where the kernel image was loaded.
565: */
566: /*
567: * The calling sequence is
568: * ...
569: * pmap_bootstrap(&kernelstart, ...);
570: * kernelstart being the first symbol in the load image.
571: */
572:
573: avail_start = round_page(avail_start);
574: virtual_avail = avail_start;
575:
576: /*
577: * Initialize kernel_pmap structure
578: */
579: kernel_pmap->pm_count = 1;
580: kernel_pmap->pm_cpus = 0;
581: kmap = (sdt_entry_t *)(avail_start);
582: kernel_pmap->pm_stab = (sdt_entry_t *)virtual_avail;
583: kmapva = virtual_avail;
584:
585: /*
586: * Reserve space for segment table entries.
587: * One for the regular segment table and one for the shadow table
588: * The shadow table keeps track of the virtual address of page
589: * tables. This is used in virtual-to-physical address translation
590: * functions. Remember, MMU cares only for physical addresses of
591: * segment and page table addresses. For kernel page tables, we
592: * really don't need this virtual stuff (since the kernel will
593: * be mapped 1-to-1) but for user page tables, this is required.
594: * Just to be consistent, we will maintain the shadow table for
595: * kernel pmap also.
596: */
597: kernel_pmap_size = 2 * SDT_SIZE;
598:
599: #ifdef DEBUG
600: printf("kernel segment table size = 0x%x\n", kernel_pmap_size);
601: #endif
602: /* init all segment descriptors to zero */
603: bzero(kernel_pmap->pm_stab, kernel_pmap_size);
604:
605: avail_start += kernel_pmap_size;
606: virtual_avail += kernel_pmap_size;
607:
608: /* make sure page tables are page aligned!! XXX smurph */
609: avail_start = round_page(avail_start);
610: virtual_avail = round_page(virtual_avail);
611:
612: /* save pointers to where page table entries start in physical memory */
613: kpdt_phys = avail_start;
614: kpdt_virt = (kpdt_entry_t)virtual_avail;
615:
616: /* Compute how much space we need for the kernel page table */
617: pdt_size = atop(VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS)
618: * sizeof(pt_entry_t);
619: for (ptable = pmap_table_build(); ptable->size != (vsize_t)-1; ptable++)
620: pdt_size += atop(ptable->size) * sizeof(pt_entry_t);
621: pdt_size = round_page(pdt_size);
622: kernel_pmap_size += pdt_size;
623: avail_start += pdt_size;
624: virtual_avail += pdt_size;
625:
626: /* init all page descriptors to zero */
627: bzero((void *)kpdt_phys, pdt_size);
628: #ifdef DEBUG
629: printf("--------------------------------------\n");
630: printf(" kernel page start = 0x%x\n", kpdt_phys);
631: printf(" kernel page table size = 0x%x\n", pdt_size);
632: printf(" kernel page end = 0x%x\n", avail_start);
633:
634: printf("kpdt_virt = 0x%x\n", kpdt_virt);
635: #endif
636: /*
637: * init the kpdt queue
638: */
639: kpdt_free = kpdt_virt;
640: for (i = pdt_size / PDT_SIZE; i != 0; i--) {
641: kpdt_virt->next = (kpdt_entry_t)((vaddr_t)kpdt_virt + PDT_SIZE);
642: kpdt_virt->phys = kpdt_phys;
643: kpdt_virt = kpdt_virt->next;
644: kpdt_phys += PDT_SIZE;
645: }
646: kpdt_virt->next = NULL; /* terminate the list */
647:
648: /*
649: * Map the kernel image into virtual space
650: */
651:
652: s_text = trunc_page(load_start); /* paddr of text */
653: e_text = round_page((vaddr_t)&etext); /* paddr of end of text */
654:
655: /* map the PROM area */
656: vaddr = pmap_map(0, 0, s_text, VM_PROT_WRITE | VM_PROT_READ, CACHE_INH);
657:
658: /* map the kernel text read only */
659: vaddr = pmap_map(s_text, s_text, e_text, VM_PROT_READ, 0);
660:
661: vaddr = pmap_map(vaddr, e_text, (paddr_t)kmap,
662: VM_PROT_WRITE | VM_PROT_READ, 0);
663:
664: /*
665: * Map system segment & page tables - should be cache inhibited?
666: * 88200 manual says that CI bit is driven on the Mbus while accessing
667: * the translation tree. I don't think we need to map it CACHE_INH
668: * here...
669: */
670: if (kmapva != vaddr) {
671: while (vaddr < (virtual_avail - kernel_pmap_size))
672: vaddr = round_page(vaddr + 1);
673: }
674: vaddr = pmap_map(vaddr, (paddr_t)kmap, avail_start,
675: VM_PROT_WRITE | VM_PROT_READ, CACHE_INH);
676:
677: vaddr = pmap_bootstrap_md(vaddr);
678:
679: virtual_avail = round_page(virtual_avail);
680: virtual_end = VM_MAX_KERNEL_ADDRESS;
681:
682: /*
683: * Map two pages per cpu for copying/zeroing.
684: */
685:
686: phys_map_vaddr = virtual_avail;
687: phys_map_vaddr_end = virtual_avail + 2 * (max_cpus << PAGE_SHIFT);
688: avail_start += 2 * (max_cpus << PAGE_SHIFT);
689: virtual_avail += 2 * (max_cpus << PAGE_SHIFT);
690:
691: /*
692: * Create all the machine-specific mappings.
693: */
694:
695: for (ptable = pmap_table_build(); ptable->size != (vsize_t)-1; ptable++)
696: if (ptable->size != 0) {
697: pmap_map(ptable->virt_start, ptable->phys_start,
698: ptable->phys_start + ptable->size,
699: ptable->prot, ptable->cacheability);
700: }
701:
702: /*
703: * Allocate all the submaps we need. Note that SYSMAP just allocates
704: * kernel virtual address with no physical backing memory. The idea
705: * is physical memory will be mapped at this va before using that va.
706: * This means that if different physical pages are going to be mapped
707: * at different times, we better do a tlb flush before using it -
708: * else we will be referencing the wrong page.
709: */
710:
711: #define SYSMAP(c, p, v, n) \
712: ({ \
713: v = (c)virt; \
714: if ((p = pmap_pte(kernel_pmap, virt)) == NULL) \
715: pmap_expand_kmap(virt, VM_PROT_READ | VM_PROT_WRITE, 0); \
716: virt += ((n) * PAGE_SIZE); \
717: })
718:
719: virt = virtual_avail;
720:
721: SYSMAP(caddr_t, vmpte, vmmap, 1);
722: invalidate_pte(vmpte);
723:
724: SYSMAP(struct msgbuf *, msgbufmap, msgbufp, btoc(MSGBUFSIZE));
725:
726: virtual_avail = virt;
727:
728: /*
729: * Switch to using new page tables
730: */
731:
732: kernel_pmap->pm_apr = (atop((paddr_t)kmap) << PG_SHIFT) |
733: CACHE_GLOBAL | CACHE_WT | APR_V;
734:
735: /* Invalidate entire kernel TLB and get ready for address translation */
736: #ifdef MULTIPROCESSOR
737: pmap_bootstrap_cpu(cpu_number());
738: #else
739: cpu = cpu_number();
740: cmmu_flush_tlb(cpu, TRUE, 0, -1);
741: /* Load supervisor pointer to segment table. */
742: cmmu_set_sapr(cpu, kernel_pmap->pm_apr);
743: #ifdef DEBUG
744: printf("cpu%d: running virtual\n", cpu);
745: #endif
746: SETBIT_CPUSET(cpu, &kernel_pmap->pm_cpus);
747: #endif /* MULTIPROCESSOR */
748: }
749:
750: #ifdef MULTIPROCESSOR
751: void
752: pmap_bootstrap_cpu(cpuid_t cpu)
753: {
754: if (cpu != master_cpu) {
755: cmmu_initialize_cpu(cpu);
756: } else {
757: cmmu_flush_tlb(cpu, TRUE, 0, -1);
758: }
759: /* Load supervisor pointer to segment table. */
760: cmmu_set_sapr(cpu, kernel_pmap->pm_apr);
761: #ifdef DEBUG
762: printf("cpu%d: running virtual\n", cpu);
763: #endif
764: SETBIT_CPUSET(cpu, &kernel_pmap->pm_cpus);
765: }
766: #endif
767:
768: /*
769: * Routine: PMAP_INIT
770: *
771: * Function:
772: * Initialize the pmap module. It is called by vm_init, to initialize
773: * any structures that the pmap system needs to map virtual memory.
774: *
775: * Calls:
776: * pool_init
777: *
778: * This routine does not really have much to do. It initializes
779: * pools for pmap structures and pv_entry structures.
780: */
781: void
782: pmap_init(void)
783: {
784: #ifdef DEBUG
785: if (pmap_con_dbg & CD_INIT)
786: printf("pmap_init()\n");
787: #endif
788:
789: pool_init(&pmappool, sizeof(struct pmap), 0, 0, 0, "pmappl",
790: &pool_allocator_nointr);
791: pool_init(&pvpool, sizeof(pv_entry_t), 0, 0, 0, "pvpl", NULL);
792: } /* pmap_init() */
793:
794: /*
795: * Routine: PMAP_ZERO_PAGE
796: *
797: * Function:
798: * Zeroes the specified page.
799: *
800: * Parameters:
801: * pg page to zero
802: *
803: * Extern/Global:
804: * phys_map_vaddr
805: *
806: * Special Assumptions:
807: * no locking required
808: *
809: * This routine maps the physical pages at the 'phys_map' virtual
810: * address set up in pmap_bootstrap. It flushes the TLB to make the new
811: * mappings effective, and zeros all the bits.
812: */
813: void
814: pmap_zero_page(struct vm_page *pg)
815: {
816: paddr_t pa = VM_PAGE_TO_PHYS(pg);
817: vaddr_t va;
818: int spl;
819: int cpu = cpu_number();
820: pt_entry_t *pte;
821:
822: va = (vaddr_t)(phys_map_vaddr + 2 * (cpu << PAGE_SHIFT));
823: pte = pmap_pte(kernel_pmap, va);
824:
825: spl = splvm();
826:
827: *pte = m88k_protection(VM_PROT_READ | VM_PROT_WRITE) |
828: PG_M /* 88110 */ | PG_V | pa;
829:
830: /*
831: * We don't need the flush_atc_entry() dance, as these pages are
832: * bound to only one cpu.
833: */
834: cmmu_flush_tlb(cpu, TRUE, va, 1);
835:
836: /*
837: * The page is likely to be a non-kernel mapping, and as
838: * such write back. Also, we might have split U/S caches!
839: * So be sure to have the pa flushed after the filling.
840: */
841: bzero((void *)va, PAGE_SIZE);
842: cmmu_flush_data_page(cpu, pa);
843:
844: splx(spl);
845: }
846:
847: /*
848: * Routine: PMAP_CREATE
849: *
850: * Function:
851: * Create and return a physical map. If the size specified for the
852: * map is zero, the map is an actual physical map, and may be referenced
853: * by the hardware. If the size specified is non-zero, the map will be
854: * used in software only, and is bounded by that size.
855: *
856: * This routines allocates a pmap structure.
857: */
858: pmap_t
859: pmap_create(void)
860: {
861: pmap_t pmap;
862: sdt_entry_t *segdt;
863: paddr_t stpa;
864: u_int s;
865:
866: pmap = pool_get(&pmappool, PR_WAITOK);
867: bzero(pmap, sizeof(*pmap));
868:
869: /*
870: * Allocate memory for *actual* segment table and *shadow* table.
871: */
872: s = round_page(2 * SDT_SIZE);
873: #ifdef DEBUG
874: if (pmap_con_dbg & CD_CREAT) {
875: printf("(pmap_create: %x) need %d pages for sdt\n",
876: curproc, atop(s));
877: }
878: #endif
879:
880: segdt = (sdt_entry_t *)uvm_km_zalloc(kernel_map, s);
881: if (segdt == NULL)
882: panic("pmap_create: uvm_km_zalloc failure");
883:
884: /*
885: * Initialize pointer to segment table both virtual and physical.
886: */
887: pmap->pm_stab = segdt;
888: if (pmap_extract(kernel_pmap, (vaddr_t)segdt,
889: (paddr_t *)&stpa) == FALSE)
890: panic("pmap_create: pmap_extract failed!");
891: pmap->pm_apr = (atop(stpa) << PG_SHIFT) | CACHE_GLOBAL | APR_V;
892:
893: #ifdef DEBUG
894: if (stpa & PAGE_MASK)
895: panic("pmap_create: sdt_table 0x%x not aligned on page boundary",
896: (int)stpa);
897:
898: if (pmap_con_dbg & CD_CREAT) {
899: printf("(pmap_create: %x) pmap=%p, pm_stab=0x%x (pa 0x%x)\n",
900: curproc, pmap, pmap->pm_stab, stpa);
901: }
902: #endif
903:
904: /* memory for page tables should not be writeback or local */
905: pmap_cache_ctrl(kernel_pmap,
906: (vaddr_t)segdt, (vaddr_t)segdt + s, CACHE_WT);
907:
908: /*
909: * Initialize SDT_ENTRIES.
910: */
911: /*
912: * There is no need to clear segment table, since uvm_km_zalloc
913: * provides us clean pages.
914: */
915:
916: /*
917: * Initialize pmap structure.
918: */
919: pmap->pm_count = 1;
920: #ifdef MULTIPROCESSOR
921: __cpu_simple_lock_init(&pmap->pm_lock);
922: #endif
923: pmap->pm_cpus = 0;
924:
925: return pmap;
926: }
927:
928: /*
929: * Routine: PMAP_RELEASE
930: *
931: * Internal procedure used by pmap_destroy() to actualy deallocate
932: * the tables.
933: *
934: * Parameters:
935: * pmap pointer to pmap structure
936: *
937: * Calls:
938: * pmap_pte
939: * uvm_km_free
940: *
941: * Special Assumptions:
942: * No locking is needed, since this is only called which the
943: * pm_count field of the pmap structure goes to zero.
944: *
945: * This routine sequences of through the user address space, releasing
946: * all translation table space back to the system using uvm_km_free.
947: * The loops are indexed by the virtual address space
948: * ranges represented by the table group sizes (1 << SDT_SHIFT).
949: */
950: void
951: pmap_release(pmap_t pmap)
952: {
953: u_int sdt; /* outer loop index */
954: sdt_entry_t *sdttbl; /* ptr to first entry in the segment table */
955: pt_entry_t *gdttbl; /* ptr to first entry in a page table */
956:
957: #ifdef DEBUG
958: if (pmap_con_dbg & CD_FREE)
959: printf("(pmap_release: %x) pmap %x\n", curproc, pmap);
960: #endif
961:
962: /* segment table loop */
963: for (sdt = VM_MIN_ADDRESS >> SDT_SHIFT;
964: sdt <= VM_MAX_ADDRESS >> SDT_SHIFT; sdt++) {
965: if ((gdttbl = pmap_pte(pmap, sdt << SDT_SHIFT)) != NULL) {
966: #ifdef DEBUG
967: if ((pmap_con_dbg & (CD_FREE | CD_FULL)) == (CD_FREE | CD_FULL))
968: printf("(pmap_release: %x) free page table = 0x%x\n",
969: curproc, gdttbl);
970: #endif
971: uvm_km_free(kernel_map, (vaddr_t)gdttbl, PAGE_SIZE);
972: }
973: }
974:
975: /*
976: * Freeing both *actual* and *shadow* segment tables
977: */
978: sdttbl = pmap->pm_stab; /* addr of segment table */
979: #ifdef DEBUG
980: if ((pmap_con_dbg & (CD_FREE | CD_FULL)) == (CD_FREE | CD_FULL))
981: printf("(pmap_release: %x) free segment table = 0x%x\n",
982: curproc, sdttbl);
983: #endif
984: uvm_km_free(kernel_map, (vaddr_t)sdttbl, round_page(2 * SDT_SIZE));
985:
986: #ifdef DEBUG
987: if (pmap_con_dbg & CD_FREE)
988: printf("(pmap_release: %x) pm_count = 0\n", curproc);
989: #endif
990: }
991:
992: /*
993: * Routine: PMAP_DESTROY
994: *
995: * Function:
996: * Retire the given physical map from service. Should only be called
997: * if the map contains no valid mappings.
998: *
999: * Parameters:
1000: * pmap pointer to pmap structure
1001: *
1002: * Calls:
1003: * pmap_release
1004: * pool_put
1005: *
1006: * Special Assumptions:
1007: * Map contains no valid mappings.
1008: *
1009: * This routine decrements the reference count in the pmap
1010: * structure. If it goes to zero, pmap_release is called to release
1011: * the memory space to the system. Then, call pool_put to free the
1012: * pmap structure.
1013: */
1014: void
1015: pmap_destroy(pmap_t pmap)
1016: {
1017: int count;
1018:
1019: #ifdef DEBUG
1020: if (pmap == kernel_pmap)
1021: panic("pmap_destroy: Attempt to destroy kernel pmap");
1022: #endif
1023:
1024: PMAP_LOCK(pmap);
1025: count = --pmap->pm_count;
1026: PMAP_UNLOCK(pmap);
1027: if (count == 0) {
1028: pmap_release(pmap);
1029: pool_put(&pmappool, pmap);
1030: }
1031: }
1032:
1033:
1034: /*
1035: * Routine: PMAP_REFERENCE
1036: *
1037: * Function:
1038: * Add a reference to the specified pmap.
1039: *
1040: * Parameters:
1041: * pmap pointer to pmap structure
1042: *
1043: * Under a pmap read lock, the pm_count field of the pmap structure
1044: * is incremented. The function then returns.
1045: */
1046: void
1047: pmap_reference(pmap_t pmap)
1048: {
1049: PMAP_LOCK(pmap);
1050: pmap->pm_count++;
1051: PMAP_UNLOCK(pmap);
1052: }
1053:
1054: /*
1055: * Routine: PMAP_REMOVE_PTE (internal)
1056: *
1057: * Function:
1058: * Invalidate a given page table entry associated with the
1059: * given virtual address.
1060: *
1061: * Parameters:
1062: * pmap pointer to pmap structure
1063: * va virtual address of page to remove
1064: * pte existing pte
1065: *
1066: * External/Global:
1067: * pv lists
1068: *
1069: * Calls:
1070: * pool_put
1071: * invalidate_pte
1072: * flush_atc_entry
1073: *
1074: * Special Assumptions:
1075: * The pmap must be locked.
1076: *
1077: * If the PTE is valid, the routine must invalidate the entry. The
1078: * 'modified' bit, if on, is referenced to the VM, and into the appropriate
1079: * entry in the PV list entry. Next, the function must find the PV
1080: * list entry associated with this pmap/va (if it doesn't exist - the function
1081: * panics). The PV list entry is unlinked from the list, and returned to
1082: * its zone.
1083: */
1084: void
1085: pmap_remove_pte(pmap_t pmap, vaddr_t va, pt_entry_t *pte)
1086: {
1087: pt_entry_t opte;
1088: pv_entry_t prev, cur, pvl;
1089: struct vm_page *pg;
1090: paddr_t pa;
1091:
1092: #ifdef DEBUG
1093: if (pmap_con_dbg & CD_RM) {
1094: if (pmap == kernel_pmap)
1095: printf("(pmap_remove_pte: %x) pmap kernel va %x\n", curproc, va);
1096: else
1097: printf("(pmap_remove_pte: %x) pmap %x va %x\n", curproc, pmap, va);
1098: }
1099: #endif
1100:
1101: if (pte == NULL || !PDT_VALID(pte)) {
1102: return; /* no page mapping, nothing to do! */
1103: }
1104:
1105: /*
1106: * Update statistics.
1107: */
1108: pmap->pm_stats.resident_count--;
1109: if (pmap_pte_w(pte))
1110: pmap->pm_stats.wired_count--;
1111:
1112: pa = ptoa(PG_PFNUM(*pte));
1113:
1114: /*
1115: * Invalidate the pte.
1116: */
1117:
1118: opte = invalidate_pte(pte) & PG_M_U;
1119: flush_atc_entry(pmap, va);
1120:
1121: pg = PHYS_TO_VM_PAGE(pa);
1122:
1123: /* If this isn't a managed page, just return. */
1124: if (pg == NULL)
1125: return;
1126:
1127: /*
1128: * Remove the mapping from the pvlist for
1129: * this physical page.
1130: */
1131: pvl = pg_to_pvh(pg);
1132:
1133: #ifdef DIAGNOSTIC
1134: if (pvl->pv_pmap == NULL)
1135: panic("pmap_remove_pte: null pv_list");
1136: #endif
1137:
1138: prev = NULL;
1139: for (cur = pvl; cur != NULL; cur = cur->pv_next) {
1140: if (cur->pv_va == va && cur->pv_pmap == pmap)
1141: break;
1142: prev = cur;
1143: }
1144: if (cur == NULL) {
1145: panic("pmap_remove_pte: mapping for va "
1146: "0x%lx (pa 0x%lx) not in pv list at %p",
1147: va, pa, pvl);
1148: }
1149:
1150: if (prev == NULL) {
1151: /*
1152: * Hander is the pv_entry. Copy the next one
1153: * to hander and free the next one (we can't
1154: * free the hander)
1155: */
1156: cur = cur->pv_next;
1157: if (cur != NULL) {
1158: cur->pv_flags = pvl->pv_flags;
1159: *pvl = *cur;
1160: pool_put(&pvpool, cur);
1161: } else {
1162: pvl->pv_pmap = NULL;
1163: }
1164: } else {
1165: prev->pv_next = cur->pv_next;
1166: pool_put(&pvpool, cur);
1167: }
1168:
1169: /* Update saved attributes for managed page */
1170: pvl->pv_flags |= opte;
1171: }
1172:
1173: /*
1174: * Routine: PMAP_REMOVE_RANGE (internal)
1175: *
1176: * Function:
1177: * Invalidate page table entries associated with the
1178: * given virtual address range. The entries given are the first
1179: * (inclusive) and last (exclusive) entries for the VM pages.
1180: *
1181: * Parameters:
1182: * pmap pointer to pmap structure
1183: * s virtual address of start of range to remove
1184: * e virtual address of end of range to remove
1185: *
1186: * External/Global:
1187: * pv lists
1188: *
1189: * Calls:
1190: * pmap_pte
1191: * pmap_remove_pte
1192: *
1193: * Special Assumptions:
1194: * The pmap must be locked.
1195: *
1196: * This routine sequences through the pages defined by the given
1197: * range. For each page, the associated page table entry (PTE) is
1198: * invalidated via pmap_remove_pte().
1199: *
1200: * Empty segments are skipped for performance.
1201: */
1202: void
1203: pmap_remove_range(pmap_t pmap, vaddr_t s, vaddr_t e)
1204: {
1205: vaddr_t va, eseg;
1206:
1207: #ifdef DEBUG
1208: if (pmap_con_dbg & CD_RM) {
1209: if (pmap == kernel_pmap)
1210: printf("(pmap_remove_range: %x) pmap kernel s %x e %x\n", curproc, s, e);
1211: else
1212: printf("(pmap_remove_range: %x) pmap %x s %x e %x\n", curproc, pmap, s, e);
1213: }
1214: #endif
1215:
1216: /*
1217: * Loop through the range in PAGE_SIZE increments.
1218: */
1219: va = s;
1220: while (va != e) {
1221: sdt_entry_t *sdt;
1222:
1223: eseg = (va & SDT_MASK) + (1 << SDT_SHIFT);
1224: if (eseg > e || eseg == 0)
1225: eseg = e;
1226:
1227: sdt = SDTENT(pmap, va);
1228:
1229: /* If no segment table, skip a whole segment */
1230: if (!SDT_VALID(sdt))
1231: va = eseg;
1232: else {
1233: while (va != eseg) {
1234: pmap_remove_pte(pmap, va, sdt_pte(sdt, va));
1235: va += PAGE_SIZE;
1236: }
1237: }
1238: }
1239: }
1240:
1241: /*
1242: * Routine: PMAP_REMOVE
1243: *
1244: * Function:
1245: * Remove the given range of addresses from the specified map.
1246: * It is assumed that start and end are properly rounded to the VM page
1247: * size.
1248: *
1249: * Parameters:
1250: * pmap pointer to pmap structure
1251: * s
1252: * e
1253: *
1254: * Special Assumptions:
1255: * Assumes not all entries must be valid in specified range.
1256: *
1257: * Calls:
1258: * pmap_remove_range
1259: *
1260: * After taking pmap read lock, pmap_remove_range is called to do the
1261: * real work.
1262: */
1263: void
1264: pmap_remove(pmap_t pmap, vaddr_t s, vaddr_t e)
1265: {
1266: int spl;
1267:
1268: if (pmap == NULL)
1269: return;
1270:
1271: #ifdef DEBUG
1272: if (s >= e)
1273: panic("pmap_remove: start greater than end address");
1274: #endif
1275:
1276: spl = splvm();
1277: PMAP_LOCK(pmap);
1278: pmap_remove_range(pmap, s, e);
1279: PMAP_UNLOCK(pmap);
1280: splx(spl);
1281: }
1282:
1283: /*
1284: * Routine: PMAP_REMOVE_ALL
1285: *
1286: * Function:
1287: * Removes this physical page from all physical maps in which it
1288: * resides. Reflects back modify bits to the pager.
1289: *
1290: * Parameters:
1291: * pg physical pages which is to
1292: * be removed from all maps
1293: *
1294: * Extern/Global:
1295: * pv lists
1296: *
1297: * Calls:
1298: * pmap_pte
1299: * pool_put
1300: *
1301: * If the page specified by the given address is not a managed page,
1302: * this routine simply returns. Otherwise, the PV list associated with
1303: * that page is traversed. For each pmap/va pair pmap_pte is called to
1304: * obtain a pointer to the page table entry (PTE) associated with the
1305: * va (the PTE must exist and be valid, otherwise the routine panics).
1306: * The hardware 'modified' bit in the PTE is examined. If it is on, the
1307: * corresponding bit in the PV list entry corresponding
1308: * to the physical page is set to 1.
1309: * Then, the PTE is invalidated, and the PV list entry is unlinked and
1310: * freed.
1311: *
1312: * At the end of this function, the PV list for the specified page
1313: * will be null.
1314: */
1315: void
1316: pmap_remove_all(struct vm_page *pg)
1317: {
1318: pt_entry_t *pte;
1319: pv_entry_t pvl;
1320: vaddr_t va;
1321: pmap_t pmap;
1322: int spl;
1323:
1324: if (pg == NULL) {
1325: /* not a managed page. */
1326: #ifdef DEBUG
1327: if (pmap_con_dbg & CD_RMAL)
1328: printf("(pmap_remove_all: %x) vm page 0x%x not a managed page\n", curproc, pg);
1329: #endif
1330: return;
1331: }
1332:
1333: #ifdef DEBUG
1334: if (pmap_con_dbg & CD_RMAL)
1335: printf("(pmap_remove_all: %x) va %x\n", curproc, pg, pg_to_pvh(pg)->pv_va);
1336: #endif
1337:
1338: spl = splvm();
1339: /*
1340: * Walk down PV list, removing all mappings.
1341: * We don't have to lock the pv list, since we have the entire pmap
1342: * system.
1343: */
1344: #ifdef MULTIPROCESSOR
1345: remove_all_Retry:
1346: #endif
1347:
1348: pvl = pg_to_pvh(pg);
1349:
1350: /*
1351: * Loop for each entry on the pv list
1352: */
1353: while (pvl != NULL && (pmap = pvl->pv_pmap) != NULL) {
1354: #ifdef MULTIPROCESSOR
1355: if (!__cpu_simple_lock_try(&pmap->pm_lock))
1356: goto remove_all_Retry;
1357: #endif
1358:
1359: va = pvl->pv_va;
1360: pte = pmap_pte(pmap, va);
1361:
1362: if (pte == NULL || !PDT_VALID(pte)) {
1363: pvl = pvl->pv_next;
1364: goto next; /* no page mapping */
1365: }
1366: if (pmap_pte_w(pte)) {
1367: #ifdef DEBUG
1368: if (pmap_con_dbg & CD_RMAL)
1369: printf("pmap_remove_all: wired mapping for %lx not removed\n",
1370: pg);
1371: #endif
1372: pvl = pvl->pv_next;
1373: goto next;
1374: }
1375:
1376: pmap_remove_pte(pmap, va, pte);
1377:
1378: /*
1379: * Do not free any page tables,
1380: * leaves that for when VM calls pmap_collect().
1381: */
1382: next:
1383: PMAP_UNLOCK(pmap);
1384: }
1385: splx(spl);
1386: }
1387:
1388: /*
1389: * Routine: PMAP_PROTECT
1390: *
1391: * Function:
1392: * Sets the physical protection on the specified range of this map
1393: * as requested.
1394: *
1395: * Parameters:
1396: * pmap pointer to pmap structure
1397: * s start address of start of range
1398: * e end address of end of range
1399: * prot desired protection attributes
1400: *
1401: * Calls:
1402: * PMAP_LOCK, PMAP_UNLOCK
1403: * pmap_pte
1404: * PDT_VALID
1405: *
1406: * This routine sequences through the pages of the specified range.
1407: * For each, it calls pmap_pte to acquire a pointer to the page table
1408: * entry (PTE). If the PTE is invalid, or non-existent, nothing is done.
1409: * Otherwise, the PTE's protection attributes are adjusted as specified.
1410: */
1411: void
1412: pmap_protect(pmap_t pmap, vaddr_t s, vaddr_t e, vm_prot_t prot)
1413: {
1414: int spl;
1415: pt_entry_t *pte, ap;
1416: vaddr_t va, eseg;
1417:
1418: if ((prot & VM_PROT_READ) == 0) {
1419: pmap_remove(pmap, s, e);
1420: return;
1421: }
1422:
1423: ap = m88k_protection(prot);
1424:
1425: spl = splvm();
1426: PMAP_LOCK(pmap);
1427:
1428: /*
1429: * Loop through the range in PAGE_SIZE increments.
1430: */
1431: va = s;
1432: while (va != e) {
1433: sdt_entry_t *sdt;
1434:
1435: eseg = (va & SDT_MASK) + (1 << SDT_SHIFT);
1436: if (eseg > e || eseg == 0)
1437: eseg = e;
1438:
1439: sdt = SDTENT(pmap, va);
1440:
1441: /* If no segment table, skip a whole segment */
1442: if (!SDT_VALID(sdt))
1443: va = eseg;
1444: else {
1445: while (va != eseg) {
1446: pte = sdt_pte(sdt, va);
1447: if (pte != NULL && PDT_VALID(pte)) {
1448: /*
1449: * Invalidate pte temporarily to avoid
1450: * the modified bit and/or the
1451: * reference bit being written back by
1452: * any other cpu.
1453: */
1454: *pte = ap |
1455: (invalidate_pte(pte) & ~PG_PROT);
1456: flush_atc_entry(pmap, va);
1457: }
1458: va += PAGE_SIZE;
1459: }
1460: }
1461: }
1462: PMAP_UNLOCK(pmap);
1463: splx(spl);
1464: }
1465:
1466: /*
1467: * Routine: PMAP_EXPAND
1468: *
1469: * Function:
1470: * Expands a pmap to be able to map the specified virtual address.
1471: * New kernel virtual memory is allocated for a page table.
1472: *
1473: * Must be called with the pmap system and the pmap unlocked, since
1474: * these must be unlocked to use vm_allocate or vm_deallocate (via
1475: * uvm_km_zalloc). Thus it must be called in a unlock/lock loop
1476: * that checks whether the map has been expanded enough. (We won't loop
1477: * forever, since page table aren't shrunk.)
1478: *
1479: * Parameters:
1480: * pmap point to pmap structure
1481: * v VA indicating which tables are needed
1482: *
1483: * Extern/Global:
1484: * user_pt_map
1485: * kernel_pmap
1486: *
1487: * Calls:
1488: * pmap_pte
1489: * uvm_km_free
1490: * uvm_km_zalloc
1491: * pmap_extract
1492: *
1493: * Special Assumptions
1494: * no pmap locks held
1495: * pmap != kernel_pmap
1496: *
1497: * 1: This routine immediately allocates space for a page table.
1498: *
1499: * 2: The page table entries (PTEs) are initialized (set invalid), and
1500: * the corresponding segment table entry is set to point to the new
1501: * page table.
1502: */
1503: void
1504: pmap_expand(pmap_t pmap, vaddr_t v)
1505: {
1506: int spl;
1507: vaddr_t pdt_vaddr;
1508: paddr_t pdt_paddr;
1509: sdt_entry_t *sdt;
1510: pt_entry_t *pte;
1511:
1512: #ifdef DEBUG
1513: if (pmap_con_dbg & CD_EXP)
1514: printf ("(pmap_expand: %x) map %x v %x\n", curproc, pmap, v);
1515: #endif
1516:
1517: /* XXX */
1518: pdt_vaddr = uvm_km_zalloc(kernel_map, PAGE_SIZE);
1519: if (pmap_extract(kernel_pmap, pdt_vaddr, &pdt_paddr) == FALSE)
1520: panic("pmap_expand: pmap_extract failed");
1521:
1522: /* memory for page tables should not be writeback or local */
1523: pmap_cache_ctrl(kernel_pmap,
1524: pdt_vaddr, pdt_vaddr + PAGE_SIZE, CACHE_WT);
1525:
1526: spl = splvm();
1527: PMAP_LOCK(pmap);
1528:
1529: if ((pte = pmap_pte(pmap, v)) != NULL) {
1530: /*
1531: * Someone else caused us to expand
1532: * during our vm_allocate.
1533: */
1534: PMAP_UNLOCK(pmap);
1535: uvm_km_free(kernel_map, pdt_vaddr, PAGE_SIZE);
1536:
1537: #ifdef DEBUG
1538: if (pmap_con_dbg & CD_EXP)
1539: printf("(pmap_expand: %x) table has already been allocated\n", curproc);
1540: #endif
1541: splx(spl);
1542: return;
1543: }
1544: /*
1545: * Apply a mask to V to obtain the vaddr of the beginning of
1546: * its containing page 'table group', i.e. the group of
1547: * page tables that fit eithin a single VM page.
1548: * Using that, obtain the segment table pointer that references the
1549: * first page table in the group, and initialize all the
1550: * segment table descriptions for the page 'table group'.
1551: */
1552: v &= ~((1 << (PDT_BITS + PG_BITS)) - 1);
1553:
1554: sdt = SDTENT(pmap, v);
1555:
1556: /*
1557: * Init each of the segment entries to point the freshly allocated
1558: * page tables.
1559: */
1560: *((sdt_entry_t *)sdt) = pdt_paddr | SG_RW | SG_V;
1561: *((sdt_entry_t *)(sdt + SDT_ENTRIES)) = pdt_vaddr | SG_RW | SG_V;
1562:
1563: PMAP_UNLOCK(pmap);
1564: splx(spl);
1565: }
1566:
1567: /*
1568: * Routine: PMAP_ENTER
1569: *
1570: * Function:
1571: * Insert the given physical page (p) at the specified virtual
1572: * address (v) in the target phisical map with the protecton requested.
1573: * If specified, the page will be wired down, meaning that the
1574: * related pte can not be reclaimed.
1575: *
1576: * N.B.: This is the only routine which MAY NOT lazy-evaluation or lose
1577: * information. That is, this routine must actually insert this page
1578: * into the given map NOW.
1579: *
1580: * Parameters:
1581: * pmap pointer to pmap structure
1582: * va VA of page to be mapped
1583: * pa PA of page to be mapped
1584: * prot protection attributes for page
1585: * wired wired attribute for page
1586: *
1587: * Extern/Global:
1588: * pv lists
1589: *
1590: * Calls:
1591: * pmap_pte
1592: * pmap_expand
1593: * pmap_remove_pte
1594: *
1595: * This routine starts off by calling pmap_pte to obtain a (virtual)
1596: * pointer to the page table entry corresponding to given virtual
1597: * address. If the page table itself does not exist, pmap_expand is
1598: * called to allocate it.
1599: *
1600: * If the page table entry (PTE) already maps the given physical page,
1601: * all that is needed is to set the protection and wired attributes as
1602: * given. TLB entries are flushed and pmap_enter returns.
1603: *
1604: * If the page table entry (PTE) maps a different physical page than
1605: * that given, the old mapping is removed by a call to map_remove_range.
1606: * And execution of pmap_enter continues.
1607: *
1608: * To map the new physical page, the routine first inserts a new
1609: * entry in the PV list exhibiting the given pmap and virtual address.
1610: * It then inserts the physical page address, protection attributes, and
1611: * wired attributes into the page table entry (PTE).
1612: *
1613: *
1614: * get machine-dependent prot code
1615: * get the pte for this page
1616: * if necessary pmap_expand(pmap, v)
1617: * if (changing wired attribute or protection) {
1618: * flush entry from TLB
1619: * update template
1620: * for (ptes per vm page)
1621: * stuff pte
1622: * } else if (mapped at wrong addr)
1623: * flush entry from TLB
1624: * pmap_remove_pte
1625: * } else {
1626: * enter mapping in pv_list
1627: * setup template and stuff ptes
1628: * }
1629: *
1630: */
1631: int
1632: pmap_enter(pmap_t pmap, vaddr_t va, paddr_t pa, vm_prot_t prot, int flags)
1633: {
1634: int spl;
1635: pt_entry_t *pte, template;
1636: paddr_t old_pa;
1637: pv_entry_t pv_e, pvl;
1638: boolean_t wired = (flags & PMAP_WIRED) != 0;
1639: struct vm_page *pg;
1640:
1641: #ifdef DEBUG
1642: if (pmap_con_dbg & CD_ENT) {
1643: if (pmap == kernel_pmap)
1644: printf("(pmap_enter: %x) pmap kernel va %x pa %x\n", curproc, va, pa);
1645: else
1646: printf("(pmap_enter: %x) pmap %x va %x pa %x\n", curproc, pmap, va, pa);
1647: }
1648: #endif
1649:
1650: template = m88k_protection(prot);
1651:
1652: spl = splvm();
1653: PMAP_LOCK(pmap);
1654:
1655: /*
1656: * Expand pmap to include this pte.
1657: */
1658: while ((pte = pmap_pte(pmap, va)) == NULL) {
1659: if (pmap == kernel_pmap) {
1660: /* will only return NULL if PMAP_CANFAIL is set */
1661: if (pmap_expand_kmap(va, VM_PROT_READ | VM_PROT_WRITE,
1662: flags & PMAP_CANFAIL) == NULL)
1663: return (ENOMEM);
1664: } else {
1665: /*
1666: * Must unlock to expand the pmap.
1667: */
1668: PMAP_UNLOCK(pmap);
1669: pmap_expand(pmap, va);
1670: PMAP_LOCK(pmap);
1671: }
1672: }
1673: /*
1674: * Special case if the physical page is already mapped at this address.
1675: */
1676: old_pa = ptoa(PG_PFNUM(*pte));
1677: #ifdef DEBUG
1678: if (pmap_con_dbg & CD_ENT)
1679: printf("(pmap_enter) old_pa %x pte %x\n", old_pa, *pte);
1680: #endif
1681:
1682: pg = PHYS_TO_VM_PAGE(pa);
1683: if (pg != NULL)
1684: pvl = pg_to_pvh(pg);
1685: else
1686: pvl = NULL;
1687:
1688: if (old_pa == pa) {
1689: /* May be changing its wired attributes or protection */
1690: if (wired && !(pmap_pte_w(pte)))
1691: pmap->pm_stats.wired_count++;
1692: else if (!wired && pmap_pte_w(pte))
1693: pmap->pm_stats.wired_count--;
1694: } else {
1695: /* Remove old mapping from the PV list if necessary. */
1696: pmap_remove_pte(pmap, va, pte);
1697:
1698: if (pvl != NULL) {
1699: /*
1700: * Enter the mapping in the PV list for this
1701: * managed page.
1702: */
1703: if (pvl->pv_pmap == NULL) {
1704: /*
1705: * No mappings yet
1706: */
1707: pvl->pv_va = va;
1708: pvl->pv_pmap = pmap;
1709: pvl->pv_next = NULL;
1710: pvl->pv_flags = 0;
1711:
1712: } else {
1713: /*
1714: * Add new pv_entry after header.
1715: */
1716: pv_e = pool_get(&pvpool, PR_NOWAIT);
1717: if (pv_e == NULL) {
1718: if (flags & PMAP_CANFAIL) {
1719: PMAP_UNLOCK(pmap);
1720: splx(spl);
1721: return (ENOMEM);
1722: } else
1723: panic("pmap_enter: "
1724: "pvpool exhausted");
1725: }
1726: pv_e->pv_va = va;
1727: pv_e->pv_pmap = pmap;
1728: pv_e->pv_next = pvl->pv_next;
1729: pv_e->pv_flags = 0;
1730: pvl->pv_next = pv_e;
1731: }
1732: }
1733:
1734: /*
1735: * And count the mapping.
1736: */
1737: pmap->pm_stats.resident_count++;
1738: if (wired)
1739: pmap->pm_stats.wired_count++;
1740: } /* if (pa == old_pa) ... else */
1741:
1742: template |= PG_V;
1743: if (wired)
1744: template |= PG_W;
1745:
1746: /*
1747: * If outside physical memory, disable cache on this (I/O) page.
1748: */
1749: if ((unsigned long)pa >= last_addr)
1750: template |= CACHE_INH;
1751:
1752: if (flags & VM_PROT_WRITE)
1753: template |= PG_M_U;
1754: else if (flags & VM_PROT_ALL)
1755: template |= PG_U;
1756:
1757: /*
1758: * Invalidate pte temporarily to avoid being written
1759: * back the modified bit and/or the reference bit by
1760: * any other cpu.
1761: */
1762: template |= invalidate_pte(pte) & PG_M_U;
1763: *pte = template | pa;
1764: flush_atc_entry(pmap, va);
1765: #ifdef DEBUG
1766: if (pmap_con_dbg & CD_ENT)
1767: printf("(pmap_enter) set pte to %x\n", *pte);
1768: #endif
1769:
1770: /*
1771: * Cache attribute flags
1772: */
1773: if (pvl != NULL)
1774: pvl->pv_flags |= template & PG_M_U;
1775:
1776: PMAP_UNLOCK(pmap);
1777: splx(spl);
1778:
1779: return 0;
1780: }
1781:
1782: /*
1783: * Routine: pmap_unwire
1784: *
1785: * Function: Change the wiring attributes for a map/virtual-address pair.
1786: *
1787: * Parameters:
1788: * pmap pointer to pmap structure
1789: * v virtual address of page to be unwired
1790: *
1791: * Calls:
1792: * pmap_pte
1793: *
1794: * Special Assumptions:
1795: * The mapping must already exist in the pmap.
1796: */
1797: void
1798: pmap_unwire(pmap_t pmap, vaddr_t v)
1799: {
1800: pt_entry_t *pte;
1801: int spl;
1802:
1803: spl = splvm();
1804: PMAP_LOCK(pmap);
1805:
1806: if ((pte = pmap_pte(pmap, v)) == NULL)
1807: panic("pmap_unwire: pte missing");
1808:
1809: if (pmap_pte_w(pte)) {
1810: /* unwired mapping */
1811: pmap->pm_stats.wired_count--;
1812: *pte &= ~PG_W;
1813: }
1814:
1815: PMAP_UNLOCK(pmap);
1816: splx(spl);
1817: }
1818:
1819: /*
1820: * Routine: PMAP_EXTRACT
1821: *
1822: * Function:
1823: * Extract the physical page address associoated
1824: * with the given map/virtual_address pair.
1825: *
1826: * Parameters:
1827: * pmap pointer to pmap structure
1828: * va virtual address
1829: * pap storage for result.
1830: *
1831: * Calls:
1832: * PMAP_LOCK, PMAP_UNLOCK
1833: * pmap_pte
1834: *
1835: * The routine calls pmap_pte to get a (virtual) pointer to
1836: * the page table entry (PTE) associated with the given virtual
1837: * address. If the page table does not exist, or if the PTE is not valid,
1838: * then 0 address is returned. Otherwise, the physical page address from
1839: * the PTE is returned.
1840: */
1841: boolean_t
1842: pmap_extract(pmap_t pmap, vaddr_t va, paddr_t *pap)
1843: {
1844: pt_entry_t *pte;
1845: paddr_t pa;
1846: int spl;
1847: boolean_t rv = FALSE;
1848:
1849: #ifdef DIAGNOSTIC
1850: if (pmap == NULL)
1851: panic("pmap_extract: pmap is NULL");
1852: #endif
1853:
1854: #ifdef M88100
1855: /*
1856: * 88100-based designs have two hardwired BATC entries which map
1857: * the upper 1MB 1:1 in supervisor space.
1858: */
1859: if (CPU_IS88100) {
1860: if (va >= BATC8_VA && pmap == kernel_pmap) {
1861: *pap = va;
1862: return (TRUE);
1863: }
1864: }
1865: #endif
1866:
1867: spl = splvm();
1868: PMAP_LOCK(pmap);
1869:
1870: pte = pmap_pte(pmap, va);
1871: if (pte != NULL && PDT_VALID(pte)) {
1872: rv = TRUE;
1873: if (pap != NULL) {
1874: pa = ptoa(PG_PFNUM(*pte));
1875: pa |= (va & PAGE_MASK); /* offset within page */
1876: *pap = pa;
1877: }
1878: }
1879:
1880: PMAP_UNLOCK(pmap);
1881: splx(spl);
1882: return rv;
1883: }
1884:
1885: /*
1886: * Routine: PMAP_COLLECT
1887: *
1888: * Runction:
1889: * Garbage collects the physical map system for pages which are
1890: * no longer used. there may well be pages which are not
1891: * referenced, but others may be collected as well.
1892: * Called by the pageout daemon when pages are scarce.
1893: *
1894: * Parameters:
1895: * pmap pointer to pmap structure
1896: *
1897: * Calls:
1898: * pmap_pte
1899: * pmap_remove_range
1900: * uvm_km_free
1901: *
1902: * The intent of this routine is to release memory pages being used
1903: * by translation tables. They can be release only if they contain no
1904: * valid mappings, and their parent table entry has been invalidated.
1905: *
1906: * The routine sequences through the entries user address space,
1907: * inspecting page-sized groups of page tables for wired entries. If
1908: * a full page of tables has no wired enties, any otherwise valid
1909: * entries are invalidated (via pmap_remove_range). Then, the segment
1910: * table entries corresponding to this group of page tables are
1911: * invalidated. Finally, uvm_km_free is called to return the page to the
1912: * system.
1913: *
1914: * If all entries in a segment table are invalidated, it too can
1915: * be returned to the system.
1916: */
1917: void
1918: pmap_collect(pmap_t pmap)
1919: {
1920: u_int sdt; /* outer loop index */
1921: vaddr_t sdt_va;
1922: sdt_entry_t *sdtp; /* ptr to index into segment table */
1923: pt_entry_t *gdttbl; /* ptr to first entry in a page table */
1924: pt_entry_t *gdttblend; /* ptr to byte after last entry in
1925: table group */
1926: pt_entry_t *gdtp; /* ptr to index into a page table */
1927: boolean_t found_gdt_wired; /* flag indicating a wired page exists
1928: in a page table's address range */
1929: int spl;
1930:
1931: #ifdef DEBUG
1932: if (pmap_con_dbg & CD_COL)
1933: printf ("(pmap_collect: %x) pmap %x\n", curproc, pmap);
1934: #endif
1935:
1936: spl = splvm();
1937: PMAP_LOCK(pmap);
1938:
1939: sdtp = pmap->pm_stab; /* addr of segment table */
1940:
1941: /* segment table loop */
1942: for (sdt = VM_MIN_ADDRESS >> SDT_SHIFT;
1943: sdt <= VM_MAX_ADDRESS >> SDT_SHIFT; sdt++, sdtp++) {
1944: sdt_va = sdt << SDT_SHIFT;
1945: gdttbl = pmap_pte(pmap, sdt_va);
1946: if (gdttbl == NULL)
1947: continue; /* no maps in this range */
1948:
1949: gdttblend = gdttbl + PDT_ENTRIES;
1950:
1951: /* scan page maps for wired pages */
1952: found_gdt_wired = FALSE;
1953: for (gdtp = gdttbl; gdtp < gdttblend; gdtp++) {
1954: if (pmap_pte_w(gdtp)) {
1955: found_gdt_wired = TRUE;
1956: break;
1957: }
1958: }
1959:
1960: if (found_gdt_wired)
1961: continue; /* can't free this range */
1962:
1963: /* invalidate all maps in this range */
1964: pmap_remove_range(pmap, sdt_va, sdt_va + (1 << SDT_SHIFT));
1965:
1966: /*
1967: * we can safely deallocate the page map(s)
1968: */
1969: *((sdt_entry_t *) sdtp) = 0;
1970: *((sdt_entry_t *)(sdtp + SDT_ENTRIES)) = 0;
1971:
1972: /*
1973: * we have to unlock before freeing the table, since
1974: * uvm_km_free will invoke another pmap routine
1975: */
1976: PMAP_UNLOCK(pmap);
1977: uvm_km_free(kernel_map, (vaddr_t)gdttbl, PAGE_SIZE);
1978: PMAP_LOCK(pmap);
1979: }
1980:
1981: PMAP_UNLOCK(pmap);
1982: splx(spl);
1983:
1984: #ifdef DEBUG
1985: if (pmap_con_dbg & CD_COL)
1986: printf("(pmap_collect: %x) done\n", curproc);
1987: #endif
1988: }
1989:
1990: /*
1991: * Routine: PMAP_ACTIVATE
1992: *
1993: * Function:
1994: * Binds the pmap associated to the process to the current processor.
1995: *
1996: * Parameters:
1997: * p pointer to proc structure
1998: *
1999: * Notes:
2000: * If the specified pmap is not kernel_pmap, this routine stores its
2001: * apr template into UAPR (user area pointer register) in the
2002: * CMMUs connected to the specified CPU.
2003: *
2004: * Then it flushes the TLBs mapping user virtual space, in the CMMUs
2005: * connected to the specified CPU.
2006: */
2007: void
2008: pmap_activate(struct proc *p)
2009: {
2010: pmap_t pmap = vm_map_pmap(&p->p_vmspace->vm_map);
2011: int cpu = cpu_number();
2012:
2013: #ifdef DEBUG
2014: if (pmap_con_dbg & CD_ACTIVATE)
2015: printf("(pmap_activate: %x) pmap %p\n", p, pmap);
2016: #endif
2017:
2018: if (pmap != kernel_pmap) {
2019: /*
2020: * Lock the pmap to put this cpu in its active set.
2021: */
2022: PMAP_LOCK(pmap);
2023:
2024: cmmu_set_uapr(pmap->pm_apr);
2025: cmmu_flush_tlb(cpu, FALSE, 0, -1);
2026:
2027: /*
2028: * Mark that this cpu is using the pmap.
2029: */
2030: SETBIT_CPUSET(cpu, &(pmap->pm_cpus));
2031:
2032: PMAP_UNLOCK(pmap);
2033: }
2034: }
2035:
2036: /*
2037: * Routine: PMAP_DEACTIVATE
2038: *
2039: * Function:
2040: * Unbinds the pmap associated to the process from the current processor.
2041: *
2042: * Parameters:
2043: * p pointer to proc structure
2044: */
2045: void
2046: pmap_deactivate(struct proc *p)
2047: {
2048: pmap_t pmap = vm_map_pmap(&p->p_vmspace->vm_map);
2049: int cpu = cpu_number();
2050:
2051: if (pmap != kernel_pmap) {
2052: /*
2053: * We expect the spl to already have been raised to sched level.
2054: */
2055: PMAP_LOCK(pmap);
2056: CLRBIT_CPUSET(cpu, &(pmap->pm_cpus));
2057: PMAP_UNLOCK(pmap);
2058: }
2059: }
2060:
2061: /*
2062: * Routine: PMAP_COPY_PAGE
2063: *
2064: * Function:
2065: * Copies the specified pages.
2066: *
2067: * Parameters:
2068: * src PA of source page
2069: * dst PA of destination page
2070: *
2071: * Extern/Global:
2072: * phys_map_vaddr
2073: *
2074: * Special Assumptions:
2075: * no locking required
2076: *
2077: * This routine maps the physical pages at the 'phys_map' virtual
2078: * addresses set up in pmap_bootstrap. It flushes the TLB to make the
2079: * new mappings effective, and performs the copy.
2080: */
2081: void
2082: pmap_copy_page(struct vm_page *srcpg, struct vm_page *dstpg)
2083: {
2084: paddr_t src = VM_PAGE_TO_PHYS(srcpg);
2085: paddr_t dst = VM_PAGE_TO_PHYS(dstpg);
2086: vaddr_t dstva, srcva;
2087: int spl;
2088: pt_entry_t *dstpte, *srcpte;
2089: int cpu = cpu_number();
2090:
2091: dstva = (vaddr_t)(phys_map_vaddr + 2 * (cpu << PAGE_SHIFT));
2092: srcva = dstva + PAGE_SIZE;
2093: dstpte = pmap_pte(kernel_pmap, dstva);
2094: srcpte = pmap_pte(kernel_pmap, srcva);
2095:
2096: spl = splvm();
2097:
2098: *dstpte = m88k_protection(VM_PROT_READ | VM_PROT_WRITE) |
2099: PG_M /* 88110 */ | PG_V | dst;
2100: *srcpte = m88k_protection(VM_PROT_READ) |
2101: PG_V | src;
2102:
2103: /*
2104: * We don't need the flush_atc_entry() dance, as these pages are
2105: * bound to only one cpu.
2106: */
2107: cmmu_flush_tlb(cpu, TRUE, dstva, 2);
2108:
2109: /*
2110: * The source page is likely to be a non-kernel mapping, and as
2111: * such write back. Also, we might have split U/S caches!
2112: * So be sure to have the source pa flushed before the copy is
2113: * attempted, and the destination pa flushed afterwards.
2114: */
2115: cmmu_flush_data_page(cpu, src);
2116: bcopy((const void *)srcva, (void *)dstva, PAGE_SIZE);
2117: cmmu_flush_data_page(cpu, dst);
2118:
2119: splx(spl);
2120: }
2121:
2122: /*
2123: * Routine: PMAP_CHANGEBIT
2124: *
2125: * Function:
2126: * Update the pte bits on the specified physical page.
2127: *
2128: * Parameters:
2129: * pg physical page
2130: * set bits to set
2131: * mask bits to mask
2132: *
2133: * Extern/Global:
2134: * pv_lists
2135: *
2136: * Calls:
2137: * pmap_pte
2138: *
2139: * The pte bits corresponding to the page's frame index will be changed as
2140: * requested. The PV list will be traversed.
2141: * For each pmap/va the hardware the necessary bits in the page descriptor
2142: * table entry will be altered as well if necessary. If any bits were changed,
2143: * a TLB flush will be performed.
2144: */
2145: void
2146: pmap_changebit(struct vm_page *pg, int set, int mask)
2147: {
2148: pv_entry_t pvl, pvep;
2149: pt_entry_t *pte, npte, opte;
2150: pmap_t pmap;
2151: int spl;
2152: vaddr_t va;
2153:
2154: spl = splvm();
2155:
2156: #ifdef MULTIPROCESSOR
2157: changebit_Retry:
2158: #endif
2159: pvl = pg_to_pvh(pg);
2160:
2161: /*
2162: * Clear saved attributes (modify, reference)
2163: */
2164: pvl->pv_flags &= mask;
2165:
2166: if (pvl->pv_pmap == NULL) {
2167: #ifdef DEBUG
2168: if (pmap_con_dbg & CD_CBIT)
2169: printf("(pmap_changebit: %x) vm page 0x%x not mapped\n",
2170: curproc, pg);
2171: #endif
2172: splx(spl);
2173: return;
2174: }
2175:
2176: /* for each listed pmap, update the affected bits */
2177: for (pvep = pvl; pvep != NULL; pvep = pvep->pv_next) {
2178: pmap = pvep->pv_pmap;
2179: #ifdef MULTIPROCESSOR
2180: if (!__cpu_simple_lock_try(&pmap->pm_lock)) {
2181: goto changebit_Retry;
2182: }
2183: #endif
2184: va = pvep->pv_va;
2185: pte = pmap_pte(pmap, va);
2186:
2187: /*
2188: * Check for existing and valid pte
2189: */
2190: if (pte == NULL || !PDT_VALID(pte)) {
2191: goto next; /* no page mapping */
2192: }
2193: #ifdef DIAGNOSTIC
2194: if (ptoa(PG_PFNUM(*pte)) != VM_PAGE_TO_PHYS(pg))
2195: panic("pmap_changebit: pte %x in pmap %p doesn't point to page %p %lx",
2196: *pte, pmap, pg, VM_PAGE_TO_PHYS(pg));
2197: #endif
2198:
2199: /*
2200: * Update bits
2201: */
2202: opte = *pte;
2203: npte = (opte | set) & mask;
2204:
2205: /*
2206: * Flush TLB of which cpus using pmap.
2207: *
2208: * Invalidate pte temporarily to avoid the modified bit
2209: * and/or the reference being written back by any other cpu.
2210: */
2211: if (npte != opte) {
2212: invalidate_pte(pte);
2213: *pte = npte;
2214: flush_atc_entry(pmap, va);
2215: }
2216: next:
2217: PMAP_UNLOCK(pmap);
2218: }
2219: splx(spl);
2220: }
2221:
2222: /*
2223: * Routine: PMAP_TESTBIT
2224: *
2225: * Function:
2226: * Test the modified/referenced bits of a physical page.
2227: *
2228: * Parameters:
2229: * pg physical page
2230: * bit bit to test
2231: *
2232: * Extern/Global:
2233: * pv lists
2234: *
2235: * Calls:
2236: * pmap_pte
2237: *
2238: * If the attribute list for the given page has the bit, this routine
2239: * returns TRUE.
2240: *
2241: * Otherwise, this routine walks the PV list corresponding to the
2242: * given page. For each pmap/va pair, the page descriptor table entry is
2243: * examined. If the selected bit is found on, the function returns TRUE
2244: * immediately (doesn't need to walk remainder of list), and updates the
2245: * attribute list.
2246: */
2247: boolean_t
2248: pmap_testbit(struct vm_page *pg, int bit)
2249: {
2250: pv_entry_t pvl, pvep;
2251: pt_entry_t *pte;
2252: pmap_t pmap;
2253: int spl;
2254:
2255: spl = splvm();
2256:
2257: #ifdef MULTIPROCESSOR
2258: testbit_Retry:
2259: #endif
2260: pvl = pg_to_pvh(pg);
2261:
2262: if (pvl->pv_flags & bit) {
2263: /* we've already cached this flag for this page,
2264: no use looking further... */
2265: #ifdef DEBUG
2266: if (pmap_con_dbg & CD_TBIT)
2267: printf("(pmap_testbit: %x) already cached a %x flag for this page\n",
2268: curproc, bit);
2269: #endif
2270: splx(spl);
2271: return (TRUE);
2272: }
2273:
2274: if (pvl->pv_pmap == NULL) {
2275: #ifdef DEBUG
2276: if (pmap_con_dbg & CD_TBIT)
2277: printf("(pmap_testbit: %x) vm page 0x%x not mapped\n",
2278: curproc, pg);
2279: #endif
2280: splx(spl);
2281: return (FALSE);
2282: }
2283:
2284: /* for each listed pmap, check modified bit for given page */
2285: for (pvep = pvl; pvep != NULL; pvep = pvep->pv_next) {
2286: pmap = pvep->pv_pmap;
2287: #ifdef MULTIPROCESSOR
2288: if (!__cpu_simple_lock_try(&pmap->pm_lock)) {
2289: goto testbit_Retry;
2290: }
2291: #endif
2292:
2293: pte = pmap_pte(pmap, pvep->pv_va);
2294: if (pte == NULL || !PDT_VALID(pte)) {
2295: goto next;
2296: }
2297:
2298: #ifdef DIAGNOSTIC
2299: if (ptoa(PG_PFNUM(*pte)) != VM_PAGE_TO_PHYS(pg))
2300: panic("pmap_testbit: pte %x in pmap %p %d doesn't point to page %p %lx",
2301: *pte, pmap, pmap == kernel_pmap ? 1 : 0, pg, VM_PAGE_TO_PHYS(pg));
2302: #endif
2303:
2304: if ((*pte & bit) != 0) {
2305: PMAP_UNLOCK(pmap);
2306: pvl->pv_flags |= bit;
2307: #ifdef DEBUG
2308: if ((pmap_con_dbg & (CD_TBIT | CD_FULL)) == (CD_TBIT | CD_FULL))
2309: printf("(pmap_testbit: %x) true on page pte@%p\n", curproc, pte);
2310: #endif
2311: splx(spl);
2312: return (TRUE);
2313: }
2314: next:
2315: PMAP_UNLOCK(pmap);
2316: }
2317:
2318: splx(spl);
2319: return (FALSE);
2320: }
2321:
2322: /*
2323: * Routine: PMAP_UNSETBIT
2324: *
2325: * Function:
2326: * Clears a pte bit and returns its previous state, for the
2327: * specified physical page.
2328: * This is an optimized version of:
2329: * rv = pmap_testbit(pg, bit);
2330: * pmap_changebit(pg, 0, ~bit);
2331: * return rv;
2332: */
2333: boolean_t
2334: pmap_unsetbit(struct vm_page *pg, int bit)
2335: {
2336: boolean_t rv = FALSE;
2337: pv_entry_t pvl, pvep;
2338: pt_entry_t *pte, opte;
2339: pmap_t pmap;
2340: int spl;
2341: vaddr_t va;
2342:
2343: spl = splvm();
2344:
2345: #ifdef MULTIPROCESSOR
2346: unsetbit_Retry:
2347: #endif
2348: pvl = pg_to_pvh(pg);
2349:
2350: /*
2351: * Clear saved attributes
2352: */
2353: pvl->pv_flags &= ~bit;
2354:
2355: if (pvl->pv_pmap == NULL) {
2356: #ifdef DEBUG
2357: if (pmap_con_dbg & CD_USBIT)
2358: printf("(pmap_unsetbit: %x) vm page 0x%x not mapped\n",
2359: curproc, pg);
2360: #endif
2361: splx(spl);
2362: return (FALSE);
2363: }
2364:
2365: /* for each listed pmap, update the specified bit */
2366: for (pvep = pvl; pvep != NULL; pvep = pvep->pv_next) {
2367: pmap = pvep->pv_pmap;
2368: #ifdef MULTIPROCESSOR
2369: if (!__cpu_simple_lock_try(&pmap->pm_lock)) {
2370: goto unsetbit_Retry;
2371: }
2372: #endif
2373: va = pvep->pv_va;
2374: pte = pmap_pte(pmap, va);
2375:
2376: /*
2377: * Check for existing and valid pte
2378: */
2379: if (pte == NULL || !PDT_VALID(pte)) {
2380: goto next; /* no page mapping */
2381: }
2382: #ifdef DIAGNOSTIC
2383: if (ptoa(PG_PFNUM(*pte)) != VM_PAGE_TO_PHYS(pg))
2384: panic("pmap_unsetbit: pte %x in pmap %p doesn't point to page %p %lx",
2385: *pte, pmap, pg, VM_PAGE_TO_PHYS(pg));
2386: #endif
2387:
2388: /*
2389: * Update bits
2390: */
2391: opte = *pte;
2392: if (opte & bit) {
2393: /*
2394: * Flush TLB of which cpus using pmap.
2395: *
2396: * Invalidate pte temporarily to avoid the specified
2397: * bit being written back by any other cpu.
2398: */
2399: invalidate_pte(pte);
2400: *pte = opte ^ bit;
2401: flush_atc_entry(pmap, va);
2402: } else
2403: rv = TRUE;
2404: next:
2405: PMAP_UNLOCK(pmap);
2406: }
2407: splx(spl);
2408:
2409: return (rv);
2410: }
2411:
2412: /*
2413: * Routine: PMAP_IS_MODIFIED
2414: *
2415: * Function:
2416: * Return whether or not the specified physical page is modified
2417: * by any physical maps.
2418: */
2419: boolean_t
2420: pmap_is_modified(struct vm_page *pg)
2421: {
2422: return pmap_testbit(pg, PG_M);
2423: }
2424:
2425: /*
2426: * Routine: PMAP_IS_REFERENCED
2427: *
2428: * Function:
2429: * Return whether or not the specified physical page is referenced by
2430: * any physical maps.
2431: */
2432: boolean_t
2433: pmap_is_referenced(struct vm_page *pg)
2434: {
2435: return pmap_testbit(pg, PG_U);
2436: }
2437:
2438: /*
2439: * Routine: PMAP_PAGE_PROTECT
2440: *
2441: * Calls:
2442: * pmap_changebit
2443: * pmap_remove_all
2444: *
2445: * Lower the permission for all mappings to a given page.
2446: */
2447: void
2448: pmap_page_protect(struct vm_page *pg, vm_prot_t prot)
2449: {
2450: if ((prot & VM_PROT_READ) == VM_PROT_NONE)
2451: pmap_remove_all(pg);
2452: else if ((prot & VM_PROT_WRITE) == VM_PROT_NONE)
2453: pmap_changebit(pg, PG_RO, ~0);
2454: }
2455:
2456: void
2457: pmap_virtual_space(vaddr_t *startp, vaddr_t *endp)
2458: {
2459: *startp = virtual_avail;
2460: *endp = virtual_end;
2461: }
2462:
2463: void
2464: pmap_kenter_pa(vaddr_t va, paddr_t pa, vm_prot_t prot)
2465: {
2466: int spl;
2467: pt_entry_t template, *pte;
2468:
2469: #ifdef DEBUG
2470: if (pmap_con_dbg & CD_ENT) {
2471: printf ("(pmap_kenter_pa: %x) va %x pa %x\n", curproc, va, pa);
2472: }
2473: #endif
2474:
2475: spl = splvm();
2476: PMAP_LOCK(kernel_pmap);
2477:
2478: template = m88k_protection(prot);
2479: #ifdef M88110
2480: if (CPU_IS88110 && m88k_protection(prot) != PG_RO)
2481: template |= PG_M;
2482: #endif
2483:
2484: /*
2485: * Expand pmap to include this pte.
2486: */
2487: while ((pte = pmap_pte(kernel_pmap, va)) == NULL)
2488: pmap_expand_kmap(va, VM_PROT_READ | VM_PROT_WRITE, 0);
2489:
2490: /*
2491: * And count the mapping.
2492: */
2493: kernel_pmap->pm_stats.resident_count++;
2494: kernel_pmap->pm_stats.wired_count++;
2495:
2496: invalidate_pte(pte);
2497:
2498: /*
2499: * If outside physical memory, disable cache on this (I/O) page.
2500: */
2501: if ((unsigned long)pa >= last_addr)
2502: template |= CACHE_INH | PG_V | PG_W;
2503: else
2504: template |= PG_V | PG_W;
2505: *pte = template | pa;
2506: flush_atc_entry(kernel_pmap, va);
2507:
2508: PMAP_UNLOCK(kernel_pmap);
2509: splx(spl);
2510: }
2511:
2512: void
2513: pmap_kremove(vaddr_t va, vsize_t len)
2514: {
2515: int spl;
2516: vaddr_t e, eseg;
2517:
2518: #ifdef DEBUG
2519: if (pmap_con_dbg & CD_RM)
2520: printf("(pmap_kremove: %x) va %x len %x\n", curproc, va, len);
2521: #endif
2522:
2523: spl = splvm();
2524: PMAP_LOCK(kernel_pmap);
2525:
2526: e = va + len;
2527: while (va != e) {
2528: sdt_entry_t *sdt;
2529: pt_entry_t *pte;
2530:
2531: eseg = (va & SDT_MASK) + (1 << SDT_SHIFT);
2532: if (eseg > e || eseg == 0)
2533: eseg = e;
2534:
2535: sdt = SDTENT(kernel_pmap, va);
2536:
2537: /* If no segment table, skip a whole segment */
2538: if (!SDT_VALID(sdt))
2539: va = eseg;
2540: else {
2541: while (va != eseg) {
2542: pte = sdt_pte(sdt, va);
2543: if (pte != NULL && PDT_VALID(pte)) {
2544: /* Update the counts */
2545: kernel_pmap->pm_stats.resident_count--;
2546: kernel_pmap->pm_stats.wired_count--;
2547:
2548: invalidate_pte(pte);
2549: flush_atc_entry(kernel_pmap, va);
2550: }
2551: va += PAGE_SIZE;
2552: }
2553: }
2554: }
2555: PMAP_UNLOCK(kernel_pmap);
2556: splx(spl);
2557: }
2558:
2559: void
2560: pmap_proc_iflush(struct proc *p, vaddr_t va, vsize_t len)
2561: {
2562: pmap_t pmap = vm_map_pmap(&p->p_vmspace->vm_map);
2563: paddr_t pa;
2564: vsize_t count;
2565: u_int32_t users;
2566: int cpu;
2567:
2568: while (len != 0) {
2569: count = min(len, PAGE_SIZE - (va & PAGE_MASK));
2570: if (pmap_extract(pmap, va, &pa)) {
2571: users = pmap->pm_cpus;
2572: while ((cpu = ff1(users)) != 32) {
2573: cmmu_flush_inst_cache(cpu, pa, count);
2574: users &= ~(1 << cpu);
2575: }
2576: }
2577: va += count;
2578: len -= count;
2579: }
2580: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to pmap.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / m88k / m88k