Source to osfmk/ppc/savearea.c
/*
* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* The contents of this file constitute Original Code as defined in and
* are subject to the Apple Public Source License Version 1.1 (the
* "License"). You may not use this file except in compliance with the
* License. Please obtain a copy of the License at
* http://www.apple.com/publicsource and read it before using this file.
*
* This Original Code and all software distributed under the License are
* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
* License for the specific language governing rights and limitations
* under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/*
* This file is used to maintain the exception save areas
*
*/
#include <cpus.h>
#include <debug.h>
#include <mach_kgdb.h>
#include <mach_vm_debug.h>
#include <kern/thread.h>
#include <mach/vm_attributes.h>
#include <mach/vm_param.h>
#include <vm/vm_kern.h>
#include <vm/vm_map.h>
#include <vm/vm_page.h>
#include <mach/ppc/thread_status.h>
#include <kern/spl.h>
#include <kern/simple_lock.h>
#include <kern/misc_protos.h>
#include <ppc/misc_protos.h>
#include <ppc/proc_reg.h>
#include <ppc/mem.h>
#include <ppc/pmap.h>
#include <ppc/pmap_internals.h>
#include <ppc/Firmware.h>
#include <ppc/mappings.h>
#include <ppc/exception.h>
#include <ppc/savearea.h>
#include <ddb/db_output.h>
extern struct Saveanchor saveanchor; /* Aliged savearea anchor */
unsigned int debsave0 = 0; /* Debug flag */
unsigned int backchain = 0; /* Debug flag */
/*
* These routines keep track of exception save areas and keeps the count within specific limits. If there are
* too few, more are allocated, too many, and they are released. This savearea is where the PCBs are
* stored. They never span a page boundary and are referenced by both virtual and real addresses.
* Within the interrupt vectors, the real address is used because at that level, no exceptions
* can be tolerated. Save areas can be dynamic or permanent. Permanant saveareas are allocated
* at boot time and must be in place before any type of exception occurs. These are never released,
* and the number is based upon some arbitrary (yet to be determined) amount times the number of
* processors. This represents the minimum number required to process a total system failure without
* destroying valuable and ever-so-handy system debugging information.
*
*
*/
/*
* This routine allocates a save area. It checks if enough are available.
* If not, it allocates upward to the target free count.
* Then, it allocates one and returns it.
*/
struct savearea *save_alloc(void) { /* Reserve a save area */
kern_return_t retr;
savectl *sctl; /* Previous and current save pages */
vm_offset_t vaddr, paddr;
struct savearea *newbaby;
if(saveanchor.savecount <= (saveanchor.saveneed - saveanchor.saveneghyst)) { /* Start allocating if we drop too far */
while(saveanchor.savecount < saveanchor.saveneed) { /* Keep adding until the adjustment is done */
retr = kmem_alloc_wired(kernel_map, &vaddr, PAGE_SIZE); /* Find a virtual address to use */
if(retr != KERN_SUCCESS) { /* Did we get some memory? */
panic("Whoops... Not a bit of wired memory left for saveareas\n");
}
paddr = pmap_extract(kernel_pmap, vaddr); /* Get the physical */
bzero((void *)vaddr, PAGE_SIZE); /* Clear it all to zeros */
sctl = (savectl *)(vaddr+PAGE_SIZE-sizeof(savectl)); /* Point to the control area of the new page */
sctl->sac_alloc = sac_empty; /* Mark all entries free */
sctl->sac_vrswap = (unsigned int)vaddr ^ (unsigned int)paddr; /* Form mask to convert V to R and vice versa */
sctl->sac_flags |= 0x0000EE00; /* (TEST/DEBUG) */
if(!save_queue(paddr)) { /* Add the new ones to the free savearea list */
panic("Arrgghhhh, time out trying to lock the savearea anchor during upward adjustment\n");
}
}
}
newbaby = save_get(); /* Get a savearea and return it */
if(!((unsigned int)newbaby & 0xFFFFF000)) { /* Whoa... None left??? No, way, no can do... */
panic("No saveareas?!?!?! No way! Can't happen! Nuh-uh... I'm dead, done for, kaput...\n");
}
return newbaby; /* Bye-bye baby... */
}
/*
* This routine releases a save area to the free queue. If after that, we have more than our maximum target,
* we start releasing what we can until we hit the normal target.
*/
void save_release(struct savearea *save) { /* Release a save area */
savectl *csave; /* The just released savearea block */
save_ret(save); /* Return a savearea to the free list */
if(saveanchor.savecount > (saveanchor.saveneed + saveanchor.saveposhyst)) { /* Start releasing if we have to many */
csave = (savectl *)42; /* Start with some nonzero garbage */
while((unsigned int)csave && (saveanchor.savecount > saveanchor.saveneed)) { /* Keep removing until the adjustment is done */
csave = save_dequeue(); /* Find and dequeue one that is all empty */
if((unsigned int)csave & 1) { /* Did we timeout trying to get the lock? */
panic("Arrgghhhh, time out trying to lock the savearea anchor during downward adjustment\n");
return;
}
if((unsigned int)csave) kmem_free(kernel_map, (vm_offset_t) csave, PAGE_SIZE); /* Release the page if we found one */
}
}
return;
}
/*
* This routine prints the free savearea block chain for debugging.
*/
void save_free_dump(void) { /* Dump the free chain */
unsigned int *dsv, omsr;
savectl *dsc;
dsv = save_deb(&omsr); /* Get the virtual of the first and disable interrupts */
while(dsv) { /* Do 'em all */
dsc=(savectl *)((unsigned int)dsv+4096-sizeof(savectl)); /* Point to the control area */
// printf("%08X %08X: nxt=%08X; alloc=%08X; flags=%08X\n", dsv, /* Print it all out */
// ((unsigned int)dsv)^(dsc->sac_vrswap), dsc->sac_next, dsc->sac_alloc, dsc->sac_flags);
dsv=(unsigned int *)(((unsigned int) dsc->sac_next)^(dsc->sac_vrswap)); /* On to the next, virtually */
}
__asm__ volatile ("mtmsr %0" : : "r" (omsr)); /* Restore the interruption mask */
return;
}
/*
* This routine prints the free savearea block chain for debugging.
*/
void DumpTheSave(struct savearea *save) { /* Dump the free chain */
unsigned int *r;
printf("savearea at %08X\n", save);
printf(" srrs: %08X %08X\n", save->save_srr0, save->save_srr1);
printf(" cr, xer, lr: %08X %08X %08X\n", save->save_cr, save->save_xer, save->save_lr);
printf("ctr, dar, dsisr: %08X %08X %08X\n", save->save_ctr, save->save_dar, save->save_dsisr);
printf(" space, copyin: %08X %08X\n", save->save_space, save->save_sr_copyin);
r=&save->save_r0;
printf(" regs: %08X %08X %08X %08X %08X %08X %08X %08X\n", r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7]);
printf(" %08X %08X %08X %08X %08X %08X %08X %08X\n", r[8], r[9], r[10], r[11], r[12], r[13], r[14], r[15]);
printf(" %08X %08X %08X %08X %08X %08X %08X %08X\n", r[16], r[17], r[18], r[19], r[20], r[21], r[22], r[23]);
printf(" %08X %08X %08X %08X %08X %08X %08X %08X\n", r[24], r[25], r[29], r[27], r[28], r[29], r[30], r[31]);
r=(unsigned int *)&save->save_fp0;
printf(" floats: %08X%08X %08X%08X %08X%08X %08X%08X\n", r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7]);
printf(" %08X%08X %08X%08X %08X%08X %08X%08X\n", r[8], r[9], r[10], r[11], r[12], r[13], r[14], r[15]);
printf(" %08X%08X %08X%08X %08X%08X %08X%08X\n", r[16], r[17], r[18], r[19], r[20], r[21], r[22], r[23]);
printf(" %08X%08X %08X%08X %08X%08X %08X%08X\n", r[24], r[25], r[29], r[27], r[28], r[29], r[30], r[31]);
printf(" %08X%08X %08X%08X %08X%08X %08X%08X\n", r[32], r[33], r[34], r[35], r[36], r[37], r[38], r[39]);
printf(" %08X%08X %08X%08X %08X%08X %08X%08X\n", r[40], r[41], r[42], r[43], r[44], r[45], r[46], r[47]);
printf(" %08X%08X %08X%08X %08X%08X %08X%08X\n", r[48], r[49], r[50], r[51], r[52], r[53], r[54], r[55]);
printf(" %08X%08X %08X%08X %08X%08X %08X%08X\n", r[56], r[57], r[58], r[59], r[60], r[61], r[62], r[63]);
r=&save->save_sr0;
printf(" srs: %08X %08X %08X %08X %08X %08X %08X %08X\n", r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7]);
printf(" %08X %08X %08X %08X %08X %08X %08X %08X\n", r[8], r[9], r[10], r[11], r[12], r[13], r[14], r[15]);
printf("prev, phys, act: %08X %08X %08X\n", save->save_prev, save->save_phys, save->save_act);
printf(" flags: %08X\n", save->save_flags);
return;
}
/*
* Dumps out savearea and stack backchains
*/
void DumpBackChain(struct savearea *save) { /* Prints out back chains */
unsigned int *r;
savearea *sv;
if(!backchain) return;
printf("Proceeding back from savearea at %08X:\n", save);
sv=save;
while(sv) {
printf(" curr=%08X; prev=%08X; stack=%08X\n", sv, sv->save_prev, sv->save_r1);
sv=sv->save_prev;
}
return;
}