![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to savearea_asm.s 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 savearea_asm.s 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: #include <assym.s> ! 23: #include <debug.h> ! 24: #include <cpus.h> ! 25: #include <db_machine_commands.h> ! 26: #include <mach_rt.h> ! 27: ! 28: #include <mach_debug.h> ! 29: #include <ppc/asm.h> ! 30: #include <ppc/proc_reg.h> ! 31: #include <ppc/exception.h> ! 32: #include <ppc/Performance.h> ! 33: #include <ppc/exception.h> ! 34: #include <ppc/pmap_internals.h> ! 35: #include <mach/ppc/vm_param.h> ! 36: ! 37: .text ! 38: ! 39: /* ! 40: * This routine will add a savearea block to the free list. ! 41: * Note really well: we can take NO exceptions of any kind, ! 42: * including a PTE miss once the savearea lock is held. That's ! 43: * a guaranteed deadlock. That means we must disable for interrutions ! 44: * and turn all translation off. ! 45: * ! 46: * Note that the savearea list should NEVER be empty ! 47: */ ! 48: ! 49: ENTRY(save_queue,TAG_NO_FRAME_USED) ! 50: ! 51: ! 52: mfmsr r12 /* Get the MSR */ ! 53: lis r10,HIGH_ADDR(EXT(saveanchor)) /* Get the high part of the anchor */ ! 54: andi. r11,r12,0x7FCF /* Turn off all translation and 'rupts */ ! 55: ori r10,r10,LOW_ADDR(EXT(saveanchor)) /* Bottom half of the anchor */ ! 56: mtmsr r11 /* Make the MSR current */ ! 57: ! 58: isync ! 59: ! 60: #if 0 ! 61: rlwinm. r3,r3,0,0,19 /* (TEST/DEBUG) */ ! 62: bne+ notraceit /* (TEST/DEBUG) */ ! 63: BREAKPOINT_TRAP /* (TEST/DEBUG) */ ! 64: notraceit: /* (TEST/DEBUG) */ ! 65: #else ! 66: rlwinm r3,r3,0,0,19 /* Make sure it's clean and tidy */ ! 67: #endif ! 68: ! 69: lwarx r9,0,r10 ; ? ! 70: ! 71: sqlck: lwarx r9,0,r10 /* Grab the lock value */ ! 72: li r8,1 /* Use part of the delay time */ ! 73: mr. r9,r9 /* Is it locked? */ ! 74: bne- sqlcks /* Yeah, wait for it to clear... */ ! 75: stwcx. r8,0,r10 /* Try to seize that there durn lock */ ! 76: beq+ sqlckd /* Got it... */ ! 77: b sqlck /* Collision, try again... */ ! 78: ! 79: sqlcks: lwz r9,SVlock(r10) /* Get that lock in here */ ! 80: mr. r9,r9 /* Is it free yet? */ ! 81: beq+ sqlck /* Yeah, try for it again... */ ! 82: b sqlcks /* Sniff away... */ ! 83: ! 84: sqlckd: isync /* Make sure translation is off */ ! 85: lwz r7,SVfree(r10) /* Get the free save area list anchor */ ! 86: lwz r6,SVcount(r10) /* Get the total count of saveareas */ ! 87: stw r3,SVfree(r10) /* Queue in the new one */ ! 88: addi r6,r6,sac_cnt /* Count the ones we are linking in */ ! 89: stw r7,SACnext(r3) /* Queue the old first one off of us */ ! 90: li r8,0 /* Get a free lock value */ ! 91: stw r6,SVcount(r10) /* Save the new count */ ! 92: ! 93: sync /* Make sure everything is done */ ! 94: stw r8,SVlock(r10) /* Unlock the savearea chain */ ! 95: ! 96: mtmsr r12 /* Restore interrupts and translation */ ! 97: isync /* Dump any speculations */ ! 98: ! 99: #if 0 ! 100: lis r0,HIGH_ADDR(CutTrace) /* (TEST/DEBUG) */ ! 101: li r2,0x2201 ; (TEST/DEBUG) ! 102: oris r0,r0,LOW_ADDR(CutTrace) /* (TEST/DEBUG) */ ! 103: sc /* (TEST/DEBUG) */ ! 104: #endif ! 105: ! 106: blr /* Leave... */ ! 107: ! 108: ! 109: /* ! 110: * This routine will find and remove an empty savearea block from the free list. ! 111: * Note really well: we can take NO exceptions of any kind, ! 112: * including a PTE miss once the savearea lock is held. That's ! 113: * a guaranteed deadlock. That means we must disable for interrutions ! 114: * and turn all translation off. ! 115: * ! 116: * We pass back the virtual address of the one we just released ! 117: * or a zero if none to free. ! 118: * ! 119: * Note that the savearea list should NEVER be empty ! 120: */ ! 121: ! 122: ENTRY(save_dequeue,TAG_NO_FRAME_USED) ! 123: ! 124: ! 125: mfmsr r12 /* Get the MSR */ ! 126: lis r10,HIGH_ADDR(EXT(saveanchor)) /* Get the high part of the anchor */ ! 127: andi. r11,r12,0x7FCF /* Turn off all translation and 'rupts */ ! 128: ori r10,r10,LOW_ADDR(EXT(saveanchor)) /* Bottom half of the anchor */ ! 129: mtmsr r11 /* Make the MSR current */ ! 130: isync /* Make sure translation is off */ ! 131: ! 132: lwarx r9,0,r10 ; ? ! 133: ! 134: sdqlck: lwarx r9,0,r10 /* Grab the lock value */ ! 135: li r8,1 /* Use part of the delay time */ ! 136: mr. r9,r9 /* Is it locked? */ ! 137: bne- sdqlcks /* Yeah, wait for it to clear... */ ! 138: stwcx. r8,0,r10 /* Try to seize that there durn lock */ ! 139: beq+ sdqlckd /* Got it... */ ! 140: b sdqlck /* Collision, try again... */ ! 141: ! 142: sdqlcks: lwz r9,SVlock(r10) /* Get that lock in here */ ! 143: mr. r9,r9 /* Is it free yet? */ ! 144: beq+ sdqlck /* Yeah, try for it again... */ ! 145: b sdqlcks /* Sniff away... */ ! 146: ! 147: ! 148: sdqlckd: lwz r3,SVfree(r10) /* Get the free save area list anchor */ ! 149: la r5,SVfree(r10) /* Remember that the we're just starting out */ ! 150: lwz r6,SVcount(r10) /* Get the total count of saveareas for later */ ! 151: lis r8,sac_empty>>16 /* Get the empty block indication */ ! 152: ! 153: sdqchk: lwz r4,SACalloc(r3) /* Get the allocation flags */ ! 154: lwz r9,SACflags(r3) /* Get the flags */ ! 155: lwz r7,SACnext(r3) /* Point on to the next one */ ! 156: andis. r9,r9,hi16(sac_perm) /* Is this permanently allocated? */ ! 157: cmplw cr1,r4,r8 /* Does this look empty? */ ! 158: bne- sdqperm /* It's permanent, can't release... */ ! 159: beq- cr1,sdqfnd /* Yeah, empty... */ ! 160: ! 161: sdqperm: la r5,SACnext(r3) /* Remember the last guy */ ! 162: mr. r3,r7 /* Any more left? */ ! 163: bne+ sdqchk /* Yeah... */ ! 164: b sdqunlk /* Nope, just go unlock and leave... */ ! 165: ! 166: sdqfnd: subi r6,r6,sac_cnt /* Back off the number of saveareas in here */ ! 167: stw r7,0(r5) /* Dequeue our guy */ ! 168: lwz r9,SACvrswap(r3) /* Get addressing conversion */ ! 169: stw r6,SVcount(r10) /* Back off the count for this block */ ! 170: xor r3,r3,r9 /* Flip to virtual addressing */ ! 171: ! 172: sdqunlk: li r8,0 /* Get a free lock value */ ! 173: sync /* Make sure everything is done */ ! 174: stw r8,SVlock(r10) /* Unlock the savearea chain */ ! 175: ! 176: mtmsr r12 /* Restore interrupts and translation */ ! 177: isync /* Dump any speculations */ ! 178: ! 179: #if 0 ! 180: lis r0,HIGH_ADDR(CutTrace) /* (TEST/DEBUG) */ ! 181: li r2,0x2202 ; (TEST/DEBUG) ! 182: oris r0,r0,LOW_ADDR(CutTrace) /* (TEST/DEBUG) */ ! 183: sc /* (TEST/DEBUG) */ ! 184: #endif ! 185: ! 186: blr /* Leave... */ ! 187: ! 188: ! 189: ! 190: /* ! 191: * This routine will obtain a savearea from the free list. ! 192: * Note really well: we can take NO exceptions of any kind, ! 193: * including a PTE miss once the savearea lock is held. That's ! 194: * a guaranteed deadlock. That means we must disable for interrutions ! 195: * and turn all translation off. ! 196: * ! 197: * We pass back the virtual address of the one we just obtained ! 198: * or a zero if none to allocate. ! 199: * ! 200: * Note that the savearea list should NEVER be empty ! 201: * NOTE!!! NEVER USE R0, R2, or R12 IN HERE THAT WAY WE DON'T NEED A ! 202: * STACK FRAME IN FPU_SAVE, FPU_SWITCH, VEC_SAVE, OR VEC_SWITCH. ! 203: */ ! 204: ! 205: ENTRY(save_get_phys,TAG_NO_FRAME_USED) ! 206: ! 207: cmplw cr1,r1,r1 ; Set CR1_eq to indicate we want physical address ! 208: b csaveget ; Join the common... ! 209: ! 210: ENTRY(save_get,TAG_NO_FRAME_USED) ! 211: ! 212: cmplwi cr1,r1,0 ; Set CR1_ne to indicate we want virutal address ! 213: ! 214: csaveget: mfmsr r11 /* Get the MSR */ ! 215: lis r10,HIGH_ADDR(EXT(saveanchor)) /* Get the high part of the anchor */ ! 216: andi. r8,r11,0x7FCF /* Turn off all translation and 'rupts */ ! 217: ori r10,r10,LOW_ADDR(EXT(saveanchor)) /* Bottom half of the anchor */ ! 218: mtmsr r8 /* Make the MSR current */ ! 219: isync ; Make sure it is done ! 220: ! 221: lwarx r9,0,r10 ; ? ! 222: ! 223: sglck: lwarx r9,0,r10 /* Grab the lock value */ ! 224: li r7,1 /* Use part of the delay time */ ! 225: mr. r9,r9 /* Is it locked? */ ! 226: bne- sglcks /* Yeah, wait for it to clear... */ ! 227: stwcx. r7,0,r10 /* Try to seize that there durn lock */ ! 228: beq+ sglckd /* Got it... */ ! 229: b sglck /* Collision, try again... */ ! 230: ! 231: sglcks: lwz r9,SVlock(r10) /* Get that lock in here */ ! 232: mr. r9,r9 /* Is it free yet? */ ! 233: beq+ sglck /* Yeah, try for it again... */ ! 234: b sglcks /* Sniff away... */ ! 235: ! 236: sglckd: isync /* Make sure translation is off */ ! 237: lwz r8,SVfree(r10) /* Get the head of the save area list */ ! 238: lwz r9,SVinuse(r10) /* Get the inuse field */ ! 239: ! 240: lwz r7,SACalloc(r8) /* Pick up the allocation bits */ ! 241: lwz r5,SACvrswap(r8) /* Get real to virtual translation */ ! 242: mr. r7,r7 /* Can we use the first one? */ ! 243: blt use1st /* Yeah... */ ! 244: ! 245: andis. r7,r7,0x8000 /* Show we used the second and remember if it was the last */ ! 246: addi r3,r8,0x0800 /* Point to the first one */ ! 247: b gotsave /* We have the area now... */ ! 248: ! 249: use1st: andis. r7,r7,0x4000 /* Mark first gone and remember if empty */ ! 250: mr r3,r8 /* Set the save area */ ! 251: ! 252: gotsave: stw r7,SACalloc(r8) /* Put back the allocation bits */ ! 253: bne nodqsave /* There's still an empty slot, don't dequeue... */ ! 254: ! 255: lwz r4,SACnext(r8) /* Get the next in line */ ! 256: stw r4,SVfree(r10) /* Dequeue our now empty save area block */ ! 257: ! 258: nodqsave: lis r6,HIGH_ADDR(SAVattach) /* Show that it is attached for now */ ! 259: li r4,0 /* Clear this for the lock */ ! 260: stw r6,SAVflags(r3) /* Set the flags to attached */ ! 261: addi r9,r9,1 /* Bump up the inuse count */ ! 262: stw r4,SAVprev(r3) /* Make sure that backchain is clear */ ! 263: stw r9,SVinuse(r10) /* Set the inuse field */ ! 264: sync /* Make sure all stores are done */ ! 265: stw r4,SVlock(r10) /* Unlock both save and trace areas */ ! 266: mtmsr r11 /* Restore translation and exceptions */ ! 267: isync /* Make sure about it */ ! 268: ! 269: #if 0 ! 270: mr r11,r0 /* (TEST/DEBUG) */ ! 271: mr r7,r2 /* (TEST/DEBUG) */ ! 272: lis r0,HIGH_ADDR(CutTrace) /* (TEST/DEBUG) */ ! 273: li r2,0x2203 ; (TEST/DEBUG) ! 274: oris r0,r0,LOW_ADDR(CutTrace) /* (TEST/DEBUG) */ ! 275: sc /* (TEST/DEBUG) */ ! 276: mr r0,r11 /* (TEST/DEBUG) */ ! 277: mr r2,r7 /* (TEST/DEBUG) */ ! 278: #endif ! 279: ! 280: li r7,0 ; NOTE WELL: we set R7 to zero for vector and float saving code in cswtch.s ! 281: beqlr- cr1 ; Return now if we want the physical address ! 282: xor r3,r3,r5 /* Get the virtual address */ ! 283: blr /* Leave... */ ! 284: ! 285: ! 286: /* ! 287: * This routine will return a savearea to the free list. ! 288: * Note really well: we can take NO exceptions of any kind, ! 289: * including a PTE miss once the savearea lock is held. That's ! 290: * a guaranteed deadlock. That means we must disable for interrutions ! 291: * and turn all translation off. ! 292: * ! 293: * We take a virtual address. ! 294: * ! 295: */ ! 296: ! 297: ENTRY(save_ret,TAG_NO_FRAME_USED) ! 298: ! 299: #if 0 ! 300: cmplwi r3,0x1000 ; (TEST/DEBUG) ! 301: bgt+ notpage0 ; (TEST/DEBUG) ! 302: BREAKPOINT_TRAP /* (TEST/DEBUG) */ ! 303: ! 304: notpage0: rlwinm r6,r3,0,0,19 /* (TEST/DEBUG) */ ! 305: rlwinm r7,r3,21,31,31 /* (TEST/DEBUG) */ ! 306: lis r8,0x8000 /* (TEST/DEBUG) */ ! 307: lwz r6,SACalloc(r6) /* (TEST/DEBUG) */ ! 308: srw r8,r8,r7 /* (TEST/DEBUG) */ ! 309: and. r8,r8,r6 /* (TEST/DEBUG) */ ! 310: beq+ nodoublefret /* (TEST/DEBUG) */ ! 311: BREAKPOINT_TRAP /* (TEST/DEBUG) */ ! 312: ! 313: nodoublefret: /* (TEST/DEBUG) */ ! 314: #endif ! 315: ! 316: lwz r7,SAVflags(r3) /* Get the flags */ ! 317: rlwinm r6,r3,0,0,19 /* Round back down to the savearea page block */ ! 318: andis. r7,r7,HIGH_ADDR(SAVinuse) /* Still in use? */ ! 319: mfmsr r12 /* Get the MSR */ ! 320: bnelr- /* Still in use, just leave... */ ! 321: lwz r5,SACvrswap(r6) /* Get the conversion to real */ ! 322: lis r10,HIGH_ADDR(EXT(saveanchor)) /* Get the high part of the anchor */ ! 323: andi. r11,r12,0x7FCF /* Turn off all translation and 'rupts */ ! 324: ori r10,r10,LOW_ADDR(EXT(saveanchor)) /* Bottom half of the anchor */ ! 325: mtmsr r11 /* Make the MSR current */ ! 326: isync /* Make sure translation is off */ ! 327: ! 328: mfsprg r11,1 /* Get the active save area */ ! 329: xor r3,r3,r5 /* Get the real address of the savearea */ ! 330: cmplw r11,r3 /* Are we trying to toss the active one? */ ! 331: xor r6,r6,r5 /* Make the savearea block real also */ ! 332: beq- srbigtimepanic /* This is a no-no... */ ! 333: ! 334: rlwinm r7,r3,21,31,31 /* Get position of savearea in block */ ! 335: lis r8,0x8000 /* Build a bit mask and assume first savearea */ ! 336: srw r8,r8,r7 /* Get bit position of do deallocate */ ! 337: ! 338: lwarx r11,0,r10 ; ? ! 339: ! 340: srlck: lwarx r11,0,r10 /* Grab the lock value */ ! 341: li r7,1 /* Use part of the delay time */ ! 342: mr. r11,r11 /* Is it locked? */ ! 343: bne- srlcks /* Yeah, wait for it to clear... */ ! 344: stwcx. r7,0,r10 /* Try to seize that there durn lock */ ! 345: beq+ srlckd /* Got it... */ ! 346: b srlck /* Collision, try again... */ ! 347: ! 348: srlcks: lwz r11,SVlock(r10) /* Get that lock in here */ ! 349: mr. r11,r11 /* Is it free yet? */ ! 350: beq+ srlck /* Yeah, try for it again... */ ! 351: b srlcks /* Sniff away... */ ! 352: ! 353: srlckd: isync /* Toss preexecutions */ ! 354: lwz r11,SACalloc(r6) /* Get the allocation for this block */ ! 355: lwz r7,SVinuse(r10) /* Get the in use count */ ! 356: or r11,r11,r8 /* Turn on our bit */ ! 357: subi r7,r7,1 /* We released one, adjust count */ ! 358: cmplw r11,r8 /* Is our's the only one free? */ ! 359: stw r7,SVinuse(r10) /* Save out count */ ! 360: stw r11,SACalloc(r6) /* Save it out */ ! 361: bne+ srtrest /* Nope, then the block is already on the free list */ ! 362: ! 363: lwz r11,SVfree(r10) /* Get the old head of the free list */ ! 364: stw r6,SVfree(r10) /* Point the head at us now */ ! 365: stw r11,SACnext(r6) /* Point us at the old last */ ! 366: ! 367: srtrest: li r8,0 /* Get set to clear the savearea lock */ ! 368: sync /* Make sure it's all out there */ ! 369: stw r8,SVlock(r10) /* Unlock it */ ! 370: mtmsr r12 /* Restore interruptions and translation */ ! 371: isync ! 372: ! 373: #if 0 ! 374: lis r0,HIGH_ADDR(CutTrace) /* (TEST/DEBUG) */ ! 375: li r2,0x2204 ; (TEST/DEBUG) ! 376: oris r0,r0,LOW_ADDR(CutTrace) /* (TEST/DEBUG) */ ! 377: sc /* (TEST/DEBUG) */ ! 378: #endif ! 379: ! 380: blr /* Go away... */ ! 381: ! 382: srbigtimepanic: ! 383: lis r6,HIGH_ADDR(EXT(panic)) /* First half of panic call */ ! 384: lis r3,HIGH_ADDR(EXT(srfreeactive)) /* First half of panic string */ ! 385: ori r6,r6,LOW_ADDR(EXT(panic)) /* Second half of panic call */ ! 386: ori r3,r3,LOW_ADDR(EXT(srfreeactive)) /* Second half of panic string */ ! 387: mtlr r6 /* Get the address of the panic routine */ ! 388: mtmsr r12 /* Restore interruptions and translation */ ! 389: isync ! 390: blrl /* Panic... */ ! 391: ! 392: .data ! 393: EXT(srfreeactive): ! 394: STRINGD "save_ret: Attempting to release the active savearea!!!!" ! 395: .text ! 396: ! 397: ! 398: /* ! 399: * This routine will return the virtual address of the first free savearea ! 400: * block and disable for interruptions. ! 401: * Note really well: this is only for debugging, don't expect it to always work! ! 402: * ! 403: * We take a virtual address in R4 to save the original MSR, and ! 404: * return the virtual address. ! 405: * ! 406: */ ! 407: ! 408: ENTRY(save_deb,TAG_NO_FRAME_USED) ! 409: ! 410: mfmsr r12 /* Get the MSR */ ! 411: lis r10,HIGH_ADDR(EXT(saveanchor)) /* Get the high part of the anchor */ ! 412: stw r12,0(r3) /* Save it */ ! 413: andi. r11,r12,0x7FCF /* Turn off all translation and 'rupts */ ! 414: ori r10,r10,LOW_ADDR(EXT(saveanchor)) /* Bottom half of the anchor */ ! 415: mtmsr r11 /* Make the MSR current */ ! 416: isync /* Make sure translation is off */ ! 417: lwz r3,SVfree(r10) /* Get the physical first in list */ ! 418: andi. r11,r12,0x7FFF /* Clear only interruption */ ! 419: lwz r5,SACvrswap(r3) /* Get the conversion to virtual */ ! 420: mtmsr r11 /* Restore DAT but not INT */ ! 421: xor r3,r3,r5 /* Make it virtual */ ! 422: isync ! 423: blr ! 424: ! 425: ! 426: ! 427: ! 428:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.