![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mappings.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / ppc|
Return to mappings.c CVS log | Up to [Apple XNU] / XNU / osfmk / ppc |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * This file is used to maintain the virtual to real mappings for a PowerPC machine.
24: * The code herein is primarily used to bridge between the pmap layer and the hardware layer.
25: * Currently, some of the function of this module is contained within pmap.c. We may want to move
26: * all of this into it (or most anyway) for the sake of performance. We shall see as we write it.
27: *
28: * We also depend upon the structure of the phys_entry control block. We do put some processor
29: * specific stuff in there.
30: *
31: */
32:
33: #include <cpus.h>
34: #include <debug.h>
35: #include <mach_kgdb.h>
36: #include <mach_vm_debug.h>
37: #include <db_machine_commands.h>
38:
39: #include <kern/thread.h>
40: #include <kern/thread_act.h>
41: #include <mach/vm_attributes.h>
42: #include <mach/vm_param.h>
43: #include <vm/vm_kern.h>
44: #include <vm/vm_map.h>
45: #include <vm/vm_page.h>
46: #include <kern/spl.h>
47:
48: #include <kern/misc_protos.h>
49: #include <ppc/misc_protos.h>
50: #include <ppc/proc_reg.h>
51:
52: #include <vm/pmap.h>
53: #include <ppc/pmap.h>
54: #include <ppc/pmap_internals.h>
55: #include <ppc/mem.h>
56:
57: #include <ppc/new_screen.h>
58: #include <ppc/Firmware.h>
59: #include <ppc/mappings.h>
60: #include <ppc/miscserv.h>
61: #include <ddb/db_output.h>
62:
63: #define PERFTIMES 0
64:
65: #if PERFTIMES && DEBUG
66: #define debugLog2(a, b, c) dbgLog2(a, b, c)
67: #else
68: #define debugLog2(a, b, c)
69: #endif
70:
71: autogenblok *AutoGenList; /* Anchor for the autogeb list */
72: space_t curr_spaceID = 0; /* Highest used space ID */
73: unsigned int incrVSID = 0; /* VSID increment value */
74: unsigned int mappingdeb0 = 0;
75: extern unsigned int hash_table_size;
76: extern unsigned int debsave0;
77: extern unsigned int dbdbdb; /* (TEST/DEBUG) */
78: extern vm_offset_t mem_size;
79: /*
80: * ppc_prot translates from the mach representation of protections to the PPC version.
81: * Calculation of it like this saves a memory reference - and maybe a couple of microseconds.
82: * It eliminates the used of this table.
83: * unsigned char ppc_prot[8] = { 0, 3, 2, 2, 3, 3, 2, 2 };
84: */
85:
86: #define ppc_prot(p) ((0xAFAC >> (p << 1)) & 3)
87:
88: /*
89: * mapping_space();
90: * This function is called to generate an address space ID. This space ID must be unique within
91: * the system. For the PowerPC, it is used to build the VSID. We build a VSID in the following
92: * way: space ID << 4 | segment. Since a VSID is 24 bits, and out of that, we reserve the last
93: * 4, so, we can have 2^20 (2M) unique IDs. Each pmap has a unique space ID, so we should be able
94: * to have 2M pmaps at a time, which we couldn't, we'd run out of memory way before then. The
95: * problem is that only a certain number of pmaps are kept in a free list and if that is full,
96: * they are release. This causes us to lose track of what space IDs are free to be reused.
97: * We can do 4 things: 1) not worry about it, 2) keep all free pmaps, 3) rebuild all mappings
98: * when the space ID wraps, or 4) scan the list of pmaps and find a free one.
99: *
100: * Yet another consideration is the hardware use of the VSID. It is used as part of the hash
101: * calculation for virtual address lookup. An improperly chosen value could potentially cause
102: * too many hashes to hit the same bucket, causing PTEG overflows. The actual hash function
103: * is (page index XOR vsid) mod number of ptegs. For a 32MB machine, using the suggested
104: * hash table size, there are 2^12 (8192) PTEGs. Remember, though, that the bottom 4 bits
105: * are reserved for the segment number, which means that we really have 2^(12-4) 512 space IDs
106: * before we start hashing to the same buckets with the same vaddrs. Also, within a space ID,
107: * every 8192 pages (32MB) within a segment will hash to the same bucket. That's 8 collisions
108: * per segment. So, a scan of every page for 256MB would fill 32 PTEGs completely, but
109: * with no overflow. I don't think that this is a problem.
110: *
111: * There may be a problem with the space ID, though. A new space ID is generate (mainly)
112: * whenever there is a fork. There shouldn't really be any problem because (for a 32MB
113: * machine) we can have 512 pmaps and still not have hash collisions for the same address.
114: * The potential problem, though, is if we get long-term pmaps that have space IDs that are
115: * the same modulo 512. We can reduce this problem by having the segment number be bits
116: * 0-3 of the space ID rather than 20-23. Doing this means that, in effect, corresponding
117: * vaddrs in different segments hash to the same PTEG. While this is somewhat of a problem,
118: * I don't think that it is as signifigant as the other, so, I'll make the space ID
119: * with segment first.
120: *
121: * The final, and biggest problem is the wrap, which will happen every 2^20 space IDs.
122: * While this is a problem that should only happen in periods counted in weeks, it can and
123: * will happen. This is assuming a monotonically increasing space ID. If we were to search
124: * for an inactive space ID, there could not be a wrap until there was 2^20 concurrent space IDs.
125: * That's pretty unlikely to happen. There couldn't be enough storage to support a million tasks.
126: * Another potential solution is to monitor for the wrap, and reorganize the space IDs when it happens.
127: * This is rather severe, and would have user-perceivable performance impact. It would be necessary
128: * to quiese all other processors, invalidate and purge the entire hash table, and then to reassign
129: * all space IDs in active pmaps. It may be better to amortize the problem by keeping pmaps in sorted
130: * order and keeping track of the lowest unused space ID. I'll think on this one and do a panic
131: * until I got it sussed.
132: */
133:
134: space_t mapping_space(void) { /* Generate a unique space ID */
135:
136: register space_t currSID, nextSID;
137:
138: while(1) { /* Keep trying until something happens */
139: currSID=curr_spaceID; /* Get a copy of the current ID */
140: if(!(nextSID = ((currSID + incrVSID) & SID_MAX))) { /* Get the next one and check if we wrapped */
141: panic("Address space ID wrapped; Temporarily fatal system error. Add more code here...\n"); /* Die */
142: }
143: if(hw_compare_and_store(currSID, nextSID, &curr_spaceID)) { /* Have we found a good one yet? */
144: debugLog2(0, nextSID, 0); /* Log mapping_space call */
145: return (nextSID); /* Yeah, return it... */
146: } /* save the new and exit if not, */
147: }
148: }
149:
150:
151: /*
152: * mapping_init();
153: * Do anything that needs to be done before the mapping system can be used.
154: * Hash table must be initialized before we call this.
155: *
156: * Calculate the SID increment. Currently we use size^(1/2) + size^(1/4) + 1;
157: */
158:
159: void mapping_init(void) {
160:
161: unsigned int tmp;
162:
163: __asm__ volatile("cntlzw %0, %1" : "=r" (tmp) : "r" (hash_table_size)); /* Get number of leading 0s */
164:
165: incrVSID = 1 << ((32 - tmp + 1) >> 1); /* Get ceiling of sqrt of table size */
166: incrVSID |= 1 << ((32 - tmp + 1) >> 2); /* Get ceiling of quadroot of table size */
167: incrVSID |= 1; /* Set bit and add 1 */
168: return;
169:
170: }
171:
172:
173: /*
174: * mapping_remove(space_t space, vm_offset_t va);
175: * Given a space ID and virtual address, this routine finds the mapping and removes if from
176: * both its PTEG hash list and the physical entry list. The mapping block will be added to
177: * the free list. If the free list threshold is reached, garbage collection will happen.
178: * We also kick back a return code to say whether or not we had one to remove.
179: *
180: * We have a strict ordering here: the mapping must be removed from the PTEG hash list before
181: * it can be removed from the physical entry list. This allows us to get by with only the PTEG
182: * hash lock at page fault time. The physical entry lock must be held while we remove the mapping
183: * from both lists. The PTEG lock is one of the lowest level locks. No PTE fault, interruptions,
184: * losing control, getting other locks, etc., are allowed when you hold it. You do, and you die.
185: * It's just that simple!
186: *
187: * When the phys_entry lock is held, the mappings chained to that one are guaranteed to stay around.
188: * However, a mapping's order on the PTEG hash chain is not. The interrupt handler uses the PTEG
189: * lock to control the hash cahin and may move the position of the mapping for MRU calculations.
190: *
191: * Note that mappings do not need to point to a physical entry. When they don't, it indicates
192: * the mapping is outside of physical memory and usually refers to a memory mapped device of
193: * some sort. Naturally, we can't lock what we don't have, so the phys entry lock and unlock
194: * routines return normally, but don't do anything.
195: */
196:
197: boolean_t mapping_remove(space_t space, vm_offset_t va) { /* Remove a single mapping for this VADDR
198: Returns TRUE if a mapping was found to remove */
199:
200: mapping *mp, *mpv;
201: spl_t s;
202:
203: debugLog2(1, va, space); /* start mapping_remove */
204: s=splhigh(); /* Don't bother me */
205:
206: mp = hw_lock_phys_vir(space, va); /* Lock the physical entry for this mapping */
207:
208: if(!mp) { /* Did we find one? */
209: splx(s); /* Restore the interrupt level */
210: debugLog2(2, 0, 0); /* end mapping_remove */
211: return FALSE; /* Didn't find any, return FALSE... */
212: }
213: if((unsigned int)mp&1) { /* Did we timeout? */
214: panic("mapping_remove: timeout locking physical entry\n"); /* Yeah, scream about it! */
215: splx(s); /* Restore the interrupt level */
216: return FALSE; /* Bad hair day, return FALSE... */
217: }
218:
219: mpv = hw_cpv(mp); /* Get virtual address of mapping */
220: if(mpv->pmap) { /* Check for a pmap */
221: #if DEBUG
222: if(hw_atomic_sub(&mpv->pmap->stats.resident_count, 1) < 0) panic("pmap resident count went negative\n");
223: #else
224: (void)hw_atomic_sub(&mpv->pmap->stats.resident_count, 1); /* Decrement the resident page count */
225: #endif
226: }
227:
228: hw_rem_map(mp); /* Remove the corresponding mapping */
229:
230: if(mpv->physent)hw_unlock_bit((unsigned int *)&mpv->physent->phys_link, PHYS_LOCK); /* Unlock physical entry associated with mapping */
231:
232: splx(s); /* Was there something you needed? */
233:
234: mapping_free(mpv); /* Add mapping to the free list */
235: debugLog2(2, 1, 0); /* end mapping_remove */
236: return TRUE; /* Tell them we did it */
237: }
238:
239: /*
240: * mapping_purge(struct phys_entry *pp) - release all mappings for this physent to the free list
241: *
242: * This guy releases any mappings that exist for a physical page.
243: * We get the lock on the phys_entry, and hold it through out this whole routine.
244: * That way, no one can change the queue out from underneath us. We keep fetching
245: * the physents mapping anchor until it is null, then we're done.
246: *
247: * For each mapping, we call the remove routine to remove it from the PTEG hash list and
248: * decriment the pmap's residency count. Then we release the mapping back to the free list.
249: *
250: */
251:
252: void mapping_purge(struct phys_entry *pp) { /* Remove all mappings for this physent */
253:
254: mapping *mp, *mpv;
255: spl_t s;
256:
257: s=splhigh(); /* Don't bother me */
258: debugLog2(3, pp->pte1, 0); /* start mapping_purge */
259:
260: if(!hw_lock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK, LockTimeOut)) { /* Lock the physical entry */
261: panic("\nmapping_purge: Timeout attempting to lock physical entry at %08X: %08X %08X\n",
262: pp, pp->phys_link, pp->pte1); /* Complain about timeout */
263: }
264:
265: while(mp = (mapping *)((unsigned int)pp->phys_link & ~PHYS_FLAGS)) { /* Keep going so long as there's another */
266:
267: mpv = hw_cpv(mp); /* Get the virtual address */
268: if(mpv->pmap) { /* See if there is a pmap to worry about */
269: #if DEBUG
270: if(hw_atomic_sub(&mpv->pmap->stats.resident_count, 1) < 0) panic("pmap resident count went negative\n");
271: #else
272: (void)hw_atomic_sub(&mpv->pmap->stats.resident_count, 1); /* Decrement the resident page count */
273: #endif
274: }
275:
276: hw_rem_map(mp); /* Remove the mapping */
277: mapping_free(mpv); /* Add mapping to the free list */
278: }
279:
280: hw_unlock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK); /* We're done, unlock the physical entry */
281:
282: debugLog2(4, pp->pte1, 0); /* end mapping_purge */
283: splx(s); /* Was there something you needed? */
284: return; /* Tell them we did it */
285: }
286:
287:
288: /*
289: * mapping_make(pmap, space, pp, va, spa, prot, attr) - map a virtual address to a real one
290: *
291: * This routine takes the given parameters, builds a mapping block, and queues it into the
292: * correct lists.
293: *
294: * The pmap and pp parameters can be null. This allows us to make a mapping that is not
295: * associated with any physical page or pmap. We may need this for certain I/O areas.
296: *
297: * If the pmap is null, we don't diddle with it, i.e., the residency counts.
298: * If the phys_entry address is null, we neither lock or chain into it.
299: */
300:
301: mapping *mapping_make(pmap_t pmap, space_t space, struct phys_entry *pp, vm_offset_t va, vm_offset_t pa, vm_prot_t prot, int attr) { /* Make an address mapping */
302:
303: register mapping *mp, *mpv;
304: spl_t s;
305:
306: debugLog2(5, va, pa); /* start mapping_purge */
307: mpv = mapping_alloc(); /* Get a spare mapping block */
308:
309: mpv->pmap = pmap; /* Initialize the pmap pointer */
310: mpv->physent = pp; /* Initialize the pointer to the physical entry */
311: mpv->PTEr = ((unsigned int)pa & ~(PAGE_SIZE - 1)) | attr<<3 | ppc_prot(prot); /* Build the real portion of the PTE */
312: mpv->PTEv = (((unsigned int)va >> 1) & 0x78000000) | (space << 7) | (((unsigned int)va >> 22) & 0x0000003F); /* Build the VSID */
313:
314: s=splhigh(); /* Don't bother from now on */
315:
316: mp = hw_cvp(mpv); /* Get the physical address of this */
317:
318: if(pp) { /* Is there a physical entry? */
319: if(!hw_lock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK, LockTimeOut)) { /* Lock the physical entry */
320: panic("\nmapping_make: Timeout attempting to lock physical entry at %08X: %08X %08X\n",
321: pp, pp->phys_link, pp->pte1); /* Complain about timeout */
322: }
323:
324: mpv->next = (mapping *)((unsigned int)pp->phys_link & ~PHYS_FLAGS); /* Move the old anchor to the new mappings forward */
325: pp->phys_link = (mapping *)((unsigned int)mp | (unsigned int)pp->phys_link & PHYS_FLAGS); /* Point the anchor at us. Now we're on the list (keep the flags) */
326: }
327:
328: hw_add_map(mp, space, va); /* Stick it on the PTEG hash list */
329:
330: if(pmap) { /* If there is a pmap, adjust the residency count */
331: (void)hw_atomic_add(&mpv->pmap->stats.resident_count, 1); /* Increment the resident page count */
332: }
333:
334: if(pp)hw_unlock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK); /* If we have one, unlock the physical entry */
335:
336: splx(s); /* Ok for interruptions now */
337: debugLog2(6, space, prot); /* end mapping_purge */
338: return mpv; /* Leave... */
339: }
340:
341:
342: /*
343: * mapping_remap(space_t space, vm_offset_t from, vm_offset_t to) - remap a physical address to a different virtual address
344: *
345: * This routine takes the given parameters, finds the mapping for the "from" address
346: * and removes it. Then it modifies the virtual address and adds it back.
347: *
348: * It returns failure if the "from" address is not mapped.
349: */
350:
351: int mapping_remap(space_t space, vm_offset_t from, vm_offset_t to) { /* Remap an address mapping */
352:
353: register mapping *mp, *mpv;
354: spl_t s;
355:
356: s=splhigh(); /* Don't bother from now on */
357:
358: mp = hw_lock_phys_vir(space, from); /* Lock the physical entry for this mapping */
359: debugLog2(7, from, to); /* start remap */
360: if(!mp) { /* Did we find one? */
361: splx(s); /* Restore the interrupt level */
362: return FALSE; /* Didn't find source, return FALSE... */
363: }
364: if((unsigned int)mp&1) { /* Did we timeout? */
365: panic("mapping_remap: timeout locking physical entry\n"); /* Yeah, scream about it! */
366: splx(s); /* Restore the interrupt level */
367: return FALSE; /* Bad hair day, return FALSE... */
368: }
369:
370: hw_rem_map(mp); /* Remove from the old address. Removes from both PTEG and physent lists */
371:
372: mpv = hw_cpv(mp); /* Convert to virtual address */
373:
374: mpv->PTEv = (((unsigned int)to >> 1) & 0x78000000) |
375: (space << 7) | (((unsigned int)to >> 22) & 0x0000003F); /* Rebuild the VSID */
376:
377: if(mpv->physent) { /* Is there a physical entry? */
378: mpv->next = (mapping *)((unsigned int)mpv->physent->phys_link & ~PHYS_FLAGS); /* Move the old anchor to the new mappings forward */
379: mpv->physent->phys_link = (mapping *)((unsigned int)mp | ((unsigned int)mpv->physent->phys_link & PHYS_FLAGS)); /* Point the anchor at us. Now we're back on the list (keep the flags) */
380: }
381:
382: hw_add_map(mp, space, to); /* Map it to the new one */
383:
384: if(mp->physent)hw_unlock_bit((unsigned int *)&mpv->physent->phys_link, PHYS_LOCK); /* Unlock physical entry associated with mapping */
385:
386: debugLog2(8, space, 0); /* end remap */
387: splx(s); /* Ok for interruptions now */
388: return TRUE; /* Leave... */
389: }
390:
391:
392: /*
393: * void mapping_protect(phys_entry *pp, vm_prot_t prot, boolean_t locked) - change the protection of a physical page
394: *
395: * This routine takes a physical entry and runs through all mappings attached to it and changes
396: * the protection. If there are PTEs associated with the mappings, they will be invalidated before
397: * the protection is changed. We don't try to save the PTE. We won't worry about the LRU calculations
398: * either (I don't think, maybe I'll change my mind later). There is no limitation on changes, e.g.,
399: * higher to lower, lower to higher.
400: *
401: * If locked is true, the physent is already locked and should not be unlocked at exit.
402: *
403: * Interruptions should be disabled at entry.
404: */
405:
406: void mapping_protect(struct phys_entry *pp, vm_prot_t prot, boolean_t locked) { /* Change protection of all mappings to page */
407:
408: debugLog2(9, pp->pte1, prot); /* end remap */
409: if(!locked) { /* Do we need to lock the physent? */
410: if(!hw_lock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK, LockTimeOut)) { /* Lock the physical entry */
411: panic("\nmapping_protect: Timeout attempting to lock physical entry at %08X: %08X %08X\n",
412: pp, pp->phys_link, pp->pte1); /* Complain about timeout */
413: }
414: }
415:
416: hw_prot(pp, ppc_prot(prot)); /* Go set the protection on this physical page */
417:
418: if(!locked) hw_unlock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK); /* We're done, unlock the physical entry */
419: debugLog2(10, pp->pte1, 0); /* end remap */
420:
421: return; /* Leave... */
422: }
423:
424: /*
425: * mapping_phys_attr(struct phys_entry *pp, vm_prot_t prot, unsigned int wimg) Sets the default physical page attributes
426: *
427: * This routine takes a physical entry and sets the physical attributes. There can be no mappings
428: * associated with this page when we do it.
429: */
430:
431: void mapping_phys_attr(struct phys_entry *pp, vm_prot_t prot, unsigned int wimg) { /* Sets the default physical page attributes */
432:
433: debugLog2(11, pp->pte1, prot); /* end remap */
434:
435: if(!hw_lock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK, LockTimeOut)) { /* Lock the physical entry */
436: panic("\nmapping_phys_attr: Timeout attempting to lock physical entry at %08X: %08X %08X\n",
437: pp, pp->phys_link, pp->pte1); /* Complain about timeout */
438: }
439:
440: // if(pp->phys_link) panic("\nmapping_phys_attr: attempt to change default attributes when mappings exist!\n");
441:
442: hw_phys_attr(pp, ppc_prot(prot), wimg); /* Go set the default WIMG and protection */
443:
444: hw_unlock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK); /* We're done, unlock the physical entry */
445: debugLog2(12, pp->pte1, wimg); /* end remap */
446:
447: return; /* Leave... */
448: }
449:
450: /*
451: * void mapping_invall(phys_entry *pp) - invalidates all ptes associated with a page
452: *
453: * This routine takes a physical entry and runs through all mappings attached to it and invalidates
454: * any PTEs it finds.
455: *
456: * Interruptions must be disabled and the physical entry locked at entry.
457: */
458:
459: void mapping_invall(struct phys_entry *pp) { /* Clear all PTEs pointing to a physical page */
460:
461: hw_inv_all(pp); /* Go set the change bit of a physical page */
462:
463: return; /* Leave... */
464: }
465:
466:
467: /*
468: * void mapping_clr_mod(phys_entry *pp) - clears the change bit of a physical page
469: *
470: * This routine takes a physical entry and runs through all mappings attached to it and turns
471: * off the change bit. If there are PTEs associated with the mappings, they will be invalidated before
472: * the change bit is changed. We don't try to save the PTE. We won't worry about the LRU calculations
473: * either (I don't think, maybe I'll change my mind later).
474: *
475: * Interruptions must be disabled and the physical entry locked at entry.
476: */
477:
478: void mapping_clr_mod(struct phys_entry *pp) { /* Clears the change bit of a physical page */
479:
480: hw_clr_mod(pp); /* Go clear the change bit of a physical page */
481: return; /* Leave... */
482: }
483:
484:
485: /*
486: * void mapping_set_mod(phys_entry *pp) - set the change bit of a physical page
487: *
488: * This routine takes a physical entry and runs through all mappings attached to it and turns
489: * on the change bit. If there are PTEs associated with the mappings, they will be invalidated before
490: * the change bit is changed. We don't try to save the PTE. We won't worry about the LRU calculations
491: * either (I don't think, maybe I'll change my mind later).
492: *
493: * Interruptions must be disabled and the physical entry locked at entry.
494: */
495:
496: void mapping_set_mod(struct phys_entry *pp) { /* Sets the change bit of a physical page */
497:
498: hw_set_mod(pp); /* Go set the change bit of a physical page */
499: return; /* Leave... */
500: }
501:
502:
503: /*
504: * void mapping_clr_ref(struct phys_entry *pp) - clears the reference bit of a physical page
505: *
506: * This routine takes a physical entry and runs through all mappings attached to it and turns
507: * off the reference bit. If there are PTEs associated with the mappings, they will be invalidated before
508: * the reference bit is changed. We don't try to save the PTE. We won't worry about the LRU calculations
509: * either (I don't think, maybe I'll change my mind later).
510: *
511: * Interruptions must be disabled at entry.
512: */
513:
514: void mapping_clr_ref(struct phys_entry *pp) { /* Clears the reference bit of a physical page */
515:
516: mapping *mp;
517:
518: debugLog2(13, pp->pte1, 0); /* end remap */
519: if(!hw_lock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK, LockTimeOut)) { /* Lock the physical entry for this mapping */
520: panic("Lock timeout getting lock on physical entry\n"); /* Just die... */
521: }
522: hw_clr_ref(pp); /* Go clear the reference bit of a physical page */
523: hw_unlock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK); /* Unlock physical entry */
524: debugLog2(14, pp->pte1, 0); /* end remap */
525: return; /* Leave... */
526: }
527:
528:
529: /*
530: * void mapping_set_ref(phys_entry *pp) - set the reference bit of a physical page
531: *
532: * This routine takes a physical entry and runs through all mappings attached to it and turns
533: * on the reference bit. If there are PTEs associated with the mappings, they will be invalidated before
534: * the reference bit is changed. We don't try to save the PTE. We won't worry about the LRU calculations
535: * either (I don't think, maybe I'll change my mind later).
536: *
537: * Interruptions must be disabled and the physical entry locked at entry.
538: */
539:
540: void mapping_set_ref(struct phys_entry *pp) { /* Sets the reference bit of a physical page */
541:
542: hw_set_ref(pp); /* Go set the reference bit of a physical page */
543: return; /* Leave... */
544: }
545:
546:
547: /*
548: * void mapping_tst_mod(phys_entry *pp) - test the change bit of a physical page
549: *
550: * This routine takes a physical entry and runs through all mappings attached to it and tests
551: * the changed bit. If there are PTEs associated with the mappings, they will be invalidated before
552: * the changed bit is tested. We don't try to save the PTE. We won't worry about the LRU calculations
553: * either (I don't think, maybe I'll change my mind later).
554: *
555: * Interruptions must be disabled and the physical entry locked at entry.
556: */
557:
558: boolean_t mapping_tst_mod(struct phys_entry *pp) { /* Tests the change bit of a physical page */
559:
560: return(hw_tst_mod(pp)); /* Go test the change bit of a physical page */
561: }
562:
563:
564: /*
565: * void mapping_tst_ref(phys_entry *pp) - tests the reference bit of a physical page
566: *
567: * This routine takes a physical entry and runs through all mappings attached to it and tests
568: * the reference bit. If there are PTEs associated with the mappings, they will be invalidated before
569: * the reference bit is changed. We don't try to save the PTE. We won't worry about the LRU calculations
570: * either (I don't think, maybe I'll change my mind later).
571: *
572: * Interruptions must be disabled and the physical entry locked at entry.
573: */
574:
575: boolean_t mapping_tst_ref(struct phys_entry *pp) { /* Tests the reference bit of a physical page */
576:
577: return(hw_tst_ref(pp)); /* Go test the reference bit of a physical page */
578: }
579:
580:
581: /*
582: * void mapping_phys_init(physent, wimg) - fills in the default processor dependent areas of the phys ent
583: *
584: * Currently, this sets the default word 1 of the PTE. The only bits set are the WIMG bits
585: */
586:
587: void mapping_phys_init(struct phys_entry *pp, unsigned int pa, unsigned int wimg) { /* Initializes hw specific storage attributes */
588:
589: pp->pte1 = (pa & -PAGE_SIZE) | ((wimg << 3) & 0x00000078); /* Set the WIMG and phys addr in the default PTE1 */
590:
591: return; /* Leave... */
592: }
593:
594:
595: /*
596: * mapping_adjust(void) - Releases free mapping blocks and/or allocates new ones
597: *
598: * This routine frees any mapping blocks queued to mapCtl.mapcrel. It also checks
599: * the number of free mappings remaining, and if below a threshold, replenishes them.
600: * The list will be replenshed from mapCtl.mapcrel if there are enough. Otherwise,
601: * a new one is allocated.
602: *
603: * This routine allocates and/or memory and must be called from a safe place.
604: * Currently, vm_pageout_scan is the safest place. We insure that the
605: */
606:
607: thread_call_t mapping_adjust_call;
608: static thread_call_data_t mapping_adjust_call_data;
609:
610: void mapping_adjust(void) { /* Adjust free mappings */
611:
612: kern_return_t retr;
613: mappingblok *mb, *mbn;
614: spl_t s;
615: int allocsize, i;
616:
617: if(mapCtl.mapcmin <= MAPPERBLOK) { /* Do the first time only */
618: mapCtl.mapcmin = mem_size >> 12; /* Make sure we have enough for all of physical memory */
619: #if DEBUG
620: kprintf("mapping_adjust: minimum entries rqrd = %08X\n", mapCtl.mapcmin);
621: kprintf("mapping_adjust: free = %08X; in use = %08X; release = %08X\n",
622: mapCtl.mapcfree, mapCtl.mapcinuse, mapCtl.mapcreln);
623: #endif
624: }
625:
626: s = splhigh(); /* Don't bother from now on */
627: if(!hw_lock_to((hw_lock_t)&mapCtl.mapclock, LockTimeOut)) { /* Lock the control header */
628: panic("mapping_adjust - timeout getting control lock (1)\n"); /* Tell all and die */
629: }
630:
631: if (mapping_adjust_call == NULL) {
632: thread_call_setup(&mapping_adjust_call_data, mapping_adjust, NULL);
633: mapping_adjust_call = &mapping_adjust_call_data;
634: }
635:
636: while(1) { /* Keep going until we've got enough */
637:
638: allocsize = mapCtl.mapcmin - mapCtl.mapcfree; /* Figure out how much we need */
639: if(allocsize < 1) break; /* Leave if we have all we need */
640:
641: if((unsigned int)(mbn = mapCtl.mapcrel)) { /* Can we rescue a free one? */
642: mapCtl.mapcrel = mbn->nextblok; /* Dequeue it */
643: mapCtl.mapcreln--; /* Back off the count */
644: allocsize = MAPPERBLOK; /* Show we allocated one block */
645: }
646: else { /* No free ones, try to get it */
647:
648: allocsize = (allocsize + MAPPERBLOK - 1) / MAPPERBLOK; /* Get the number of pages we need */
649: if(allocsize > (mapCtl.mapcfree / 2)) allocsize = (mapCtl.mapcfree / 2); /* Don't try for anything that we can't comfortably map */
650:
651: hw_lock_unlock((hw_lock_t)&mapCtl.mapclock); /* Unlock our stuff */
652: splx(s); /* Restore 'rupts */
653:
654: for(; allocsize > 0; allocsize >>= 1) { /* Try allocating in descending halves */
655: retr = kmem_alloc_wired(kernel_map, (vm_offset_t *)&mbn, PAGE_SIZE * allocsize); /* Find a virtual address to use */
656: if((retr != KERN_SUCCESS) && (allocsize == 1)) { /* Did we find any memory at all? */
657: panic("Whoops... Not a bit of wired memory left for anyone\n");
658: }
659: if(retr == KERN_SUCCESS) break; /* We got some memory, bail out... */
660: }
661:
662: allocsize = allocsize * MAPPERBLOK; /* Convert pages to number of maps allocated */
663: s = splhigh(); /* Don't bother from now on */
664: if(!hw_lock_to((hw_lock_t)&mapCtl.mapclock, LockTimeOut)) { /* Lock the control header */
665: panic("mapping_adjust - timeout getting control lock (2)\n"); /* Tell all and die */
666: }
667: }
668: for(; allocsize > 0; allocsize -= MAPPERBLOK) { /* Release one block at a time */
669: mapping_free_init((vm_offset_t)mbn, 0, 1); /* Initialize a non-permanent block */
670: mbn = (mappingblok *)((unsigned int)mbn + PAGE_SIZE); /* Point to the next slot */
671: }
672: }
673:
674: if(mapCtl.mapcholdoff) { /* Should we hold off this release? */
675: mapCtl.mapcrecurse = 0; /* We are done now */
676: hw_lock_unlock((hw_lock_t)&mapCtl.mapclock); /* Unlock our stuff */
677: splx(s); /* Restore 'rupts */
678: return; /* Return... */
679: }
680:
681: mbn = mapCtl.mapcrel; /* Get first pending release block */
682: mapCtl.mapcrel = 0; /* Dequeue them */
683: mapCtl.mapcreln = 0; /* Set count to 0 */
684:
685: hw_lock_unlock((hw_lock_t)&mapCtl.mapclock); /* Unlock our stuff */
686: splx(s); /* Restore 'rupts */
687:
688: while((unsigned int)mbn) { /* Toss 'em all */
689: mb = mbn->nextblok; /* Get the next */
690: kmem_free(kernel_map, (vm_offset_t) mbn, PAGE_SIZE); /* Release this mapping block */
691: mbn = mb; /* Chain to the next */
692: }
693:
694: __asm__ volatile("sync"); /* Make sure all is well */
695: mapCtl.mapcrecurse = 0; /* We are done now */
696: return;
697: }
698:
699: /*
700: * mapping_free(mapping *mp) - release a mapping to the free list
701: *
702: * This routine takes a mapping and adds it to the free list.
703: * If this mapping make the block non-empty, we queue it to the free block list.
704: * NOTE: we might want to queue it to the end to keep quelch the pathalogical
705: * case when we get a mapping and free it repeatedly causing the block to chain and unchain.
706: * If this release fills a block and we are above the threshold, we release the block
707: */
708:
709: void mapping_free(struct mapping *mp) { /* Release a mapping */
710:
711: mappingblok *mb, *mbn;
712: spl_t s;
713: unsigned int full, mindx;
714:
715: mindx = ((unsigned int)mp & (PAGE_SIZE - 1)) >> 5; /* Get index to mapping */
716: mb = (mappingblok *)((unsigned int)mp & -PAGE_SIZE); /* Point to the mapping block */
717:
718: s = splhigh(); /* Don't bother from now on */
719: if(!hw_lock_to((hw_lock_t)&mapCtl.mapclock, LockTimeOut)) { /* Lock the control header */
720: panic("mapping_free - timeout getting control lock\n"); /* Tell all and die */
721: }
722:
723: full = !(mb->mapblokfree[0] | mb->mapblokfree[1] | mb->mapblokfree[2] | mb->mapblokfree[3]); /* See if full now */
724: mb->mapblokfree[mindx >> 5] |= (0x80000000 >> (mindx & 31)); /* Flip on the free bit */
725:
726: if(full) { /* If it was full before this: */
727: mb->nextblok = mapCtl.mapcnext; /* Move head of list to us */
728: mapCtl.mapcnext = mb; /* Chain us to the head of the list */
729: }
730:
731: mapCtl.mapcfree++; /* Bump free count */
732: mapCtl.mapcinuse--; /* Decriment in use count */
733:
734: mapCtl.mapcfreec++; /* Count total calls */
735:
736: if(mapCtl.mapcfree > mapCtl.mapcmin) { /* Should we consider releasing this? */
737: if(((mb->mapblokfree[0] | 0x80000000) & mb->mapblokfree[1] & mb->mapblokfree[2] & mb->mapblokfree[3])
738: == 0xFFFFFFFF) { /* See if empty now */
739:
740: if(mapCtl.mapcnext == mb) { /* Are we first on the list? */
741: mapCtl.mapcnext = mb->nextblok; /* Unchain us */
742: if(!((unsigned int)mapCtl.mapcnext)) mapCtl.mapclast = 0; /* If last, remove last */
743: }
744: else { /* We're not first */
745: for(mbn = mapCtl.mapcnext; mbn != 0; mbn = mbn->nextblok) { /* Search for our block */
746: if(mbn->nextblok == mb) break; /* Is the next one our's? */
747: }
748: if(!mbn) panic("mapping_free: attempt to release mapping block (%08X) not on list\n", mp);
749: mbn->nextblok = mb->nextblok; /* Dequeue us */
750: if(mapCtl.mapclast == mb) mapCtl.mapclast = mbn; /* If last, make our predecessor last */
751: }
752:
753: if(mb->mapblokflags & mbPerm) { /* Is this permanently assigned? */
754: mb->nextblok = mapCtl.mapcnext; /* Move chain head to us */
755: mapCtl.mapcnext = mb; /* Chain us to the head */
756: if(!((unsigned int)mb->nextblok)) mapCtl.mapclast = mb; /* If last, make us so */
757: }
758: else {
759: mapCtl.mapcfree -= MAPPERBLOK; /* Remove the block from the free count */
760: mapCtl.mapcreln++; /* Count on release list */
761: mb->nextblok = mapCtl.mapcrel; /* Move pointer */
762: mapCtl.mapcrel = mb; /* Chain us in front */
763: }
764: }
765: }
766:
767: if(mapCtl.mapcreln > MAPFRTHRSH) { /* Do we have way too many releasable mappings? */
768: if(hw_compare_and_store(0, 1, &mapCtl.mapcrecurse)) { /* Make sure we aren't recursing */
769: thread_call_enter(mapping_adjust_call); /* Go toss some */
770: }
771: }
772: hw_lock_unlock((hw_lock_t)&mapCtl.mapclock); /* Unlock our stuff */
773: splx(s); /* Restore 'rupts */
774:
775: return; /* Bye, dude... */
776: }
777:
778:
779: /*
780: * mapping_alloc(void) - obtain a mapping from the free list
781: *
782: * This routine takes a mapping off of the free list and returns it's address.
783: *
784: * We do this by finding a free entry in the first block and allocating it.
785: * If this allocation empties the block, we remove it from the free list.
786: * If this allocation drops the total number of free entries below a threshold,
787: * we allocate a new block.
788: *
789: */
790:
791: mapping *mapping_alloc(void) { /* Obtain a mapping */
792:
793: register mapping *mp;
794: mappingblok *mb, *mbn;
795: spl_t s;
796: int mindx;
797: kern_return_t retr;
798:
799: s = splhigh(); /* Don't bother from now on */
800: if(!hw_lock_to((hw_lock_t)&mapCtl.mapclock, LockTimeOut)) { /* Lock the control header */
801: panic("mapping_alloc - timeout getting control lock\n"); /* Tell all and die */
802: }
803:
804: if(!(mb = mapCtl.mapcnext)) { /* Get the first block entry */
805: panic("mapping_alloc - free mappings exhausted\n"); /* Whine and moan */
806: }
807:
808:
809: if(!(mindx = mapalc(mb))) { /* Allocate a slot */
810: panic("mapping_alloc - empty mapping block detected at %08X\n", mb); /* Not allowed to find none */
811: }
812:
813: if(mindx < 0) { /* Did we just take the last one */
814: mindx = -mindx; /* Make positive */
815: mapCtl.mapcnext = mb->nextblok; /* Remove us from the list */
816: if(!((unsigned int)mapCtl.mapcnext)) mapCtl.mapclast = 0; /* Removed the last one */
817: }
818:
819: mapCtl.mapcfree--; /* Decrement free count */
820: mapCtl.mapcinuse++; /* Bump in use count */
821:
822: mapCtl.mapcallocc++; /* Count total calls */
823:
824: /*
825: * Note: in the following code, we will attempt to rescue blocks only one at a time.
826: * Eventually, after a few more mapping_alloc calls, we will catch up. If there are none
827: * rescueable, we will kick the misc scan who will allocate some for us. We only do this
828: * if we haven't already done it.
829: * For early boot, we are set up to only rescue one block at a time. This is because we prime
830: * the release list with as much as we need until threads start.
831: */
832: if(mapCtl.mapcfree < mapCtl.mapcmin) { /* See if we need to replenish */
833: if(mbn = mapCtl.mapcrel) { /* Try to rescue a block from impending doom */
834: mapCtl.mapcrel = mbn->nextblok; /* Pop the queue */
835: mapCtl.mapcreln--; /* Back off the count */
836: mapping_free_init((vm_offset_t)mbn, 0, 1); /* Initialize a non-permanent block */
837: }
838: else { /* We need to replenish */
839: if(hw_compare_and_store(0, 1, &mapCtl.mapcrecurse)) { /* Make sure we aren't recursing */
840: thread_call_enter(mapping_adjust_call); /* Go allocate some more */
841: }
842: }
843: }
844:
845: hw_lock_unlock((hw_lock_t)&mapCtl.mapclock); /* Unlock our stuff */
846: splx(s); /* Restore 'rupts */
847:
848: mp = &((mapping *)mb)[mindx]; /* Point to the allocated mapping */
849: __asm__ volatile("dcbz 0,%0" : : "r" (mp)); /* Clean it up */
850: return mp; /* Send it back... */
851: }
852:
853:
854: /*
855: * void mapping_free_init(mb, perm) - Adds a block of storage to the free mapping list
856: *
857: * The mapping block is a page size area on a page boundary. It contains 1 header and 127
858: * mappings. This call adds and initializes a block for use.
859: *
860: * The header contains a chain link, bit maps, a virtual to real translation mask, and
861: * some statistics. Bit maps map each slot on the page (bit 0 is not used because it
862: * corresponds to the header). The translation mask is the XOR of the virtual and real
863: * addresses (needless to say, the block must be wired).
864: *
865: * We handle these mappings the same way as saveareas: the block is only on the chain so
866: * long as there are free entries in it.
867: *
868: * Empty blocks are garbage collected when there are at least mapCtl.mapcmin pages worth of free
869: * mappings. Blocks marked PERM won't ever be released.
870: *
871: * If perm is negative, the mapping is initialized, but immediately queued to the mapCtl.mapcrel
872: * list. We do this only at start up time. This is done because we only allocate blocks
873: * in the pageout scan and it doesn't start up until after we run out of the initial mappings.
874: * Therefore, we need to preallocate a bunch, but we don't want them to be permanent. If we put
875: * them on the release queue, the allocate routine will rescue them. Then when the
876: * pageout scan starts, all extra ones will be released.
877: *
878: */
879:
880:
881: void mapping_free_init(vm_offset_t mbl, int perm, boolean_t locked) {
882: /* Set's start and end of a block of mappings
883: perm indicates if the block can be released
884: or goes straight to the release queue .
885: locked indicates if the lock is held already */
886:
887: mappingblok *mb;
888: spl_t s;
889: int i;
890: unsigned int raddr;
891:
892: mb = (mappingblok *)mbl; /* Start of area */
893:
894:
895: if(perm >= 0) { /* See if we need to initialize the block */
896: if(perm) {
897: raddr = (unsigned int)mbl; /* Perm means V=R */
898: mb->mapblokflags = mbPerm; /* Set perm */
899: }
900: else {
901: raddr = kvtophys(mbl); /* Get real address */
902: mb->mapblokflags = 0; /* Set not perm */
903: }
904:
905: mb->mapblokvrswap = raddr ^ (unsigned int)mbl; /* Form translation mask */
906:
907: mb->mapblokfree[0] = 0x7FFFFFFF; /* Set first 32 (minus 1) free */
908: mb->mapblokfree[1] = 0xFFFFFFFF; /* Set next 32 free */
909: mb->mapblokfree[2] = 0xFFFFFFFF; /* Set next 32 free */
910: mb->mapblokfree[3] = 0xFFFFFFFF; /* Set next 32 free */
911: }
912:
913: s = splhigh(); /* Don't bother from now on */
914: if(!locked) { /* Do we need the lock? */
915: if(!hw_lock_to((hw_lock_t)&mapCtl.mapclock, LockTimeOut)) { /* Lock the control header */
916: panic("mapping_free_init - timeout getting control lock\n"); /* Tell all and die */
917: }
918: }
919:
920: if(perm < 0) { /* Direct to release queue? */
921: mb->nextblok = mapCtl.mapcrel; /* Move forward pointer */
922: mapCtl.mapcrel = mb; /* Queue us on in */
923: mapCtl.mapcreln++; /* Count the free block */
924: }
925: else { /* Add to the free list */
926:
927: mb->nextblok = 0; /* We always add to the end */
928: mapCtl.mapcfree += MAPPERBLOK; /* Bump count */
929:
930: if(!((unsigned int)mapCtl.mapcnext)) { /* First entry on list? */
931: mapCtl.mapcnext = mapCtl.mapclast = mb; /* Chain to us */
932: }
933: else { /* We are not the first */
934: mapCtl.mapclast->nextblok = mb; /* Point the last to us */
935: mapCtl.mapclast = mb; /* We are now last */
936: }
937: }
938:
939: if(!locked) { /* Do we need to unlock? */
940: hw_lock_unlock((hw_lock_t)&mapCtl.mapclock); /* Unlock our stuff */
941: }
942: splx(s); /* Restore 'rupts */
943: return; /* All done, leave... */
944: }
945:
946:
947: /*
948: * void mapping_prealloc(unsigned int) - Preallocates mapppings for large request
949: *
950: * No locks can be held, because we allocate memory here.
951: * This routine needs a corresponding mapping_relpre call to remove the
952: * hold off flag so that the adjust routine will free the extra mapping
953: * blocks on the release list. I don't like this, but I don't know
954: * how else to do this for now...
955: *
956: */
957:
958: void mapping_prealloc(unsigned int size) { /* Preallocates mapppings for large request */
959:
960: int nmapb, i;
961: kern_return_t retr;
962: mappingblok *mbn;
963: spl_t s;
964:
965: s = splhigh(); /* Don't bother from now on */
966: if(!hw_lock_to((hw_lock_t)&mapCtl.mapclock, LockTimeOut)) { /* Lock the control header */
967: panic("mapping_prealloc - timeout getting control lock\n"); /* Tell all and die */
968: }
969:
970: nmapb = (size >> 12) + mapCtl.mapcmin; /* Get number of entries needed for this and the minimum */
971:
972: mapCtl.mapcholdoff++; /* Bump the hold off count */
973:
974: if((nmapb = (nmapb - mapCtl.mapcfree)) <= 0) { /* Do we already have enough? */
975: hw_lock_unlock((hw_lock_t)&mapCtl.mapclock); /* Unlock our stuff */
976: splx(s); /* Restore 'rupts */
977: return;
978: }
979:
980: nmapb = (nmapb + MAPPERBLOK - 1) / MAPPERBLOK; /* Get number of blocks to get */
981:
982: hw_lock_unlock((hw_lock_t)&mapCtl.mapclock); /* Unlock our stuff */
983: splx(s); /* Restore 'rupts */
984:
985: for(i = 0; i < nmapb; i++) { /* Allocate 'em all */
986: retr = kmem_alloc_wired(kernel_map, (vm_offset_t *)&mbn, PAGE_SIZE); /* Find a virtual address to use */
987: if(retr != KERN_SUCCESS) { /* Did we get some memory? */
988: panic("Whoops... Not a bit of wired memory left for anyone\n");
989: }
990: mapping_free_init((vm_offset_t)mbn, -1, 0); /* Initialize on to the release queue */
991: }
992: }
993:
994: /*
995: * void mapping_relpre(void) - Releases preallocation release hold off
996: *
997: * This routine removes the
998: * hold off flag so that the adjust routine will free the extra mapping
999: * blocks on the release list. I don't like this, but I don't know
1000: * how else to do this for now...
1001: *
1002: */
1003:
1004: void mapping_relpre(void) { /* Releases release hold off */
1005:
1006: spl_t s;
1007:
1008: s = splhigh(); /* Don't bother from now on */
1009: if(!hw_lock_to((hw_lock_t)&mapCtl.mapclock, LockTimeOut)) { /* Lock the control header */
1010: panic("mapping_relpre - timeout getting control lock\n"); /* Tell all and die */
1011: }
1012: if(--mapCtl.mapcholdoff < 0) { /* Back down the hold off count */
1013: panic("mapping_relpre: hold-off count went negative\n");
1014: }
1015:
1016: hw_lock_unlock((hw_lock_t)&mapCtl.mapclock); /* Unlock our stuff */
1017: splx(s); /* Restore 'rupts */
1018: }
1019:
1020: /*
1021: * void mapping_free_prime(void) - Primes the mapping block release list
1022: *
1023: * See mapping_free_init.
1024: * No locks can be held, because we allocate memory here.
1025: * One processor running only.
1026: *
1027: */
1028:
1029: void mapping_free_prime(void) { /* Primes the mapping block release list */
1030:
1031: int nmapb, i;
1032: kern_return_t retr;
1033: mappingblok *mbn;
1034:
1035: nmapb = (mapCtl.mapcfree + mapCtl.mapcinuse + MAPPERBLOK - 1) / MAPPERBLOK; /* Get permanent allocation */
1036: nmapb = nmapb * 4; /* Get 4 times our initial allocation */
1037:
1038: #if DEBUG
1039: kprintf("mapping_free_prime: free = %08X; in use = %08X; priming = %08X\n",
1040: mapCtl.mapcfree, mapCtl.mapcinuse, nmapb);
1041: #endif
1042:
1043: for(i = 0; i < nmapb; i++) { /* Allocate 'em all */
1044: retr = kmem_alloc_wired(kernel_map, (vm_offset_t *)&mbn, PAGE_SIZE); /* Find a virtual address to use */
1045: if(retr != KERN_SUCCESS) { /* Did we get some memory? */
1046: panic("Whoops... Not a bit of wired memory left for anyone\n");
1047: }
1048: mapping_free_init((vm_offset_t)mbn, -1, 0); /* Initialize onto release queue */
1049: }
1050: }
1051:
1052: /*
1053: * vm_offset_t mapping_p2v(space_t space, phys_entry *pp) - Finds first virtual mapping of a physical page in a space
1054: *
1055: * Gets a lock on the physical entry. Then it searches the list of attached mappings for one with
1056: * the same space. If it finds it, it returns the virtual address.
1057: */
1058:
1059: vm_offset_t mapping_p2v(space_t space, struct phys_entry *pp) { /* Finds first virtual mapping of a physical page in a space */
1060:
1061: spl_t s;
1062: register mapping *mp, *mpv;
1063: vm_offset_t va;
1064:
1065: if(!hw_lock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK, LockTimeOut)) { /* Try to get the lock on the physical entry */
1066: splx(s); /* Restore 'rupts */
1067: panic("mapping_p2v: timeout getting lock on physent\n"); /* Arrrgghhhh! */
1068: return(0); /* Should die before here */
1069: }
1070:
1071: va = 0; /* Assume failure */
1072:
1073: for(mpv = hw_cpv(pp->phys_link); mpv; mp = hw_cpv(mp->next)) { /* Scan 'em all */
1074:
1075: if(!(((mpv->PTEv >> 7) & 0x000FFFFF) == space)) continue; /* Skip all the rest if this is not the right space... */
1076:
1077: va = ((((unsigned int)mpv->PTEhash & -64) << 5) ^ (space << 12)) & 0x003FF000; /* Backward hash to the wrapped VADDR */
1078: va = va | ((mpv->PTEv << 8) & 0xF0000000); /* Move in the segment number */
1079: va = va | ((mpv->PTEv << 22) & 0x0FC00000); /* Add in the API for the top of the address */
1080: break; /* We're done now, pass virtual address back */
1081: }
1082:
1083: hw_unlock_bit((unsigned int *)&pp->phys_link, PHYS_LOCK); /* Unlock the physical entry */
1084: splx(s); /* Restore 'rupts */
1085: return(va); /* Return the result or 0... */
1086: }
1087:
1088: /*
1089: * kvtophys(addr)
1090: *
1091: * Convert a kernel virtual address to a physical address
1092: */
1093: vm_offset_t kvtophys(vm_offset_t va) {
1094:
1095: register mapping *mp, *mpv;
1096: register vm_offset_t pa;
1097: spl_t s;
1098:
1099: s=splhigh(); /* Don't bother from now on */
1100: mp = hw_lock_phys_vir(PPC_SID_KERNEL, va); /* Find mapping and lock the physical entry for this mapping */
1101:
1102: if((unsigned int)mp&1) { /* Did the lock on the phys entry time out? */
1103: splx(s); /* Restore 'rupts */
1104: panic("kvtophys: timeout obtaining lock on physical entry (vaddr=%08X)\n", va); /* Scream bloody murder! */
1105: return 0;
1106: }
1107:
1108: if(!mp) { /* If it was not found, or no physical entry */
1109: splx(s); /* Restore 'rupts */
1110: return 0; /* Return 0 */
1111: }
1112:
1113: mpv = hw_cpv(mp); /* Convert to virtual addressing */
1114:
1115: if(!mpv->physent) { /* Was there a physical entry? */
1116: pa = (vm_offset_t)((mpv->PTEr & -PAGE_SIZE) | ((unsigned int)va & (PAGE_SIZE-1))); /* Get physical address from physent */
1117: }
1118: else {
1119: pa = (vm_offset_t)((mpv->physent->pte1 & -PAGE_SIZE) | ((unsigned int)va & (PAGE_SIZE-1))); /* Get physical address from physent */
1120: hw_unlock_bit((unsigned int *)&mpv->physent->phys_link, PHYS_LOCK); /* Unlock the physical entry */
1121: }
1122:
1123: splx(s); /* Restore 'rupts */
1124: return pa; /* Return the physical address... */
1125: }
1126:
1127: /*
1128: * phystokv(addr)
1129: *
1130: * Convert a physical address to a kernel virtual address if
1131: * there is a mapping, otherwise return NULL
1132: */
1133:
1134: vm_offset_t phystokv(vm_offset_t pa) {
1135:
1136: struct phys_entry *pp;
1137: vm_offset_t va;
1138:
1139: pp = pmap_find_physentry(pa); /* Find the physical entry */
1140: if (PHYS_NULL == pp) {
1141: return (vm_offset_t)NULL; /* If none, return null */
1142: }
1143: if(!(va=mapping_p2v(PPC_SID_KERNEL, pp))) {
1144: return 0; /* Can't find it, return 0... */
1145: }
1146: return (va | (pa & (PAGE_SIZE-1))); /* Build and return VADDR... */
1147:
1148: }
1149:
1150: /*
1151: * Enters translations into the autogen maps.
1152: *
1153: * Not implemented yet, just stubbed out...
1154: */
1155:
1156: boolean_t autogen_map(space_t space, vm_offset_t va, vm_offset_t spa, vm_offset_t epa, vm_prot_t prot, int attr) { /* Build an autogen area */
1157:
1158: return(0); /* Just return false for now */
1159: }
1160:
1161:
1162: /*
1163: * Dumps out the mapping stuff associated with a virtual address
1164: */
1165: void dumpaddr(space_t space, vm_offset_t va) {
1166:
1167: mapping *mp, *mpv;
1168: vm_offset_t pa;
1169: spl_t s;
1170:
1171: s=splhigh(); /* Don't bother me */
1172:
1173: mp = hw_lock_phys_vir(space, va); /* Lock the physical entry for this mapping */
1174: if(!mp) { /* Did we find one? */
1175: splx(s); /* Restore the interrupt level */
1176: printf("dumpaddr: virtual address (%08X) not mapped\n", va);
1177: return; /* Didn't find any, return FALSE... */
1178: }
1179: if((unsigned int)mp&1) { /* Did we timeout? */
1180: panic("dumpaddr: timeout locking physical entry for virtual address (%08X)\n", va); /* Yeah, scream about it! */
1181: splx(s); /* Restore the interrupt level */
1182: return; /* Bad hair day, return FALSE... */
1183: }
1184: printf("dumpaddr: space=%08X; vaddr=%08X\n", space, va); /* Say what address were dumping */
1185: mpv = hw_cpv(mp); /* Get virtual address of mapping */
1186: dumpmapping(mpv);
1187: if(mpv->physent) {
1188: dumppca(mpv);
1189: hw_unlock_bit((unsigned int *)&mpv->physent->phys_link, PHYS_LOCK); /* Unlock physical entry associated with mapping */
1190: }
1191: splx(s); /* Was there something you needed? */
1192: return; /* Tell them we did it */
1193: }
1194:
1195:
1196:
1197: /*
1198: * Prints out a mapping control block
1199: *
1200: */
1201:
1202: void dumpmapping(struct mapping *mp) { /* Dump out a mapping */
1203:
1204: printf("Dump of mapping block: %08X\n", mp); /* Header */
1205: printf(" next: %08X\n", mp->next);
1206: printf(" hashnext: %08X\n", mp->hashnext);
1207: printf(" PTEhash: %08X\n", mp->PTEhash);
1208: printf(" PTEent: %08X\n", mp->PTEent);
1209: printf(" physent: %08X\n", mp->physent);
1210: printf(" PTEv: %08X\n", mp->PTEv);
1211: printf(" PTEr: %08X\n", mp->PTEr);
1212: printf(" pmap: %08X\n", mp->pmap);
1213:
1214: if(mp->physent) { /* Print physent if it exists */
1215: printf("Associated physical entry: %08X %08X\n", mp->physent->phys_link, mp->physent->pte1);
1216: }
1217: else {
1218: printf("Associated physical entry: none\n");
1219: }
1220:
1221: dumppca(mp); /* Dump out the PCA information */
1222:
1223: return;
1224: }
1225:
1226: /*
1227: * Prints out a PTEG control area
1228: *
1229: */
1230:
1231: void dumppca(struct mapping *mp) { /* PCA */
1232:
1233: PCA *pca;
1234: unsigned int *pteg;
1235:
1236: pca = (PCA *)((unsigned int)mp->PTEhash&-64); /* Back up to the start of the PCA */
1237: pteg=(unsigned int *)((unsigned int)pca-(((hash_table_base&0x0000FFFF)+1)<<16));
1238: printf(" Dump of PCA: %08X\n", pca); /* Header */
1239: printf(" PCAlock: %08X\n", pca->PCAlock);
1240: printf(" PCAallo: %08X\n", pca->flgs.PCAallo);
1241: printf(" PCAhash: %08X %08X %08X %08X\n", pca->PCAhash[0], pca->PCAhash[1], pca->PCAhash[2], pca->PCAhash[3]);
1242: printf(" %08X %08X %08X %08X\n", pca->PCAhash[4], pca->PCAhash[5], pca->PCAhash[6], pca->PCAhash[7]);
1243: printf("Dump of PTEG: %08X\n", pteg); /* Header */
1244: printf(" %08X %08X %08X %08X\n", pteg[0], pteg[1], pteg[2], pteg[3]);
1245: printf(" %08X %08X %08X %08X\n", pteg[4], pteg[5], pteg[6], pteg[7]);
1246: printf(" %08X %08X %08X %08X\n", pteg[8], pteg[9], pteg[10], pteg[11]);
1247: printf(" %08X %08X %08X %08X\n", pteg[12], pteg[13], pteg[14], pteg[15]);
1248: return;
1249: }
1250:
1251: /*
1252: * Dumps starting with a physical entry
1253: */
1254:
1255: void dumpphys(struct phys_entry *pp) { /* Dump from physent */
1256:
1257: mapping *mp;
1258: PCA *pca;
1259: unsigned int *pteg;
1260:
1261: printf("Dump from physical entry %08X: %08X %08X\n", pp, pp->phys_link, pp->pte1);
1262: mp = hw_cpv(pp->phys_link);
1263: while(mp) {
1264: dumpmapping(mp);
1265: dumppca(mp);
1266: mp = hw_cpv(mp->next);
1267: }
1268:
1269: return;
1270: }
1271:
1272: /*
1273: * void ignore_zero_fault(boolean_t) - Sets up to ignore or honor any fault on
1274: * page 0 access for the current thread.
1275: *
1276: * If parameter is TRUE, faults are ignored
1277: * If parameter is FALSE, faults are honored
1278: *
1279: */
1280:
1281: void ignore_zero_fault(boolean_t type) { /* Sets up to ignore or honor any fault on page 0 access for the current thread */
1282:
1283: if(type) current_act()->mact.specFlags |= ignoreZeroFault; /* Ignore faults on page 0 */
1284: else current_act()->mact.specFlags &= ~ignoreZeroFault; /* Honor faults on page 0 */
1285:
1286: return; /* Return the result or 0... */
1287: }
1288:
1289:
1290:
1291:
1292:
1293:
1294:
1295:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.