[apple/xnu.git] / 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");
                        }
                }
        }
        if (saveanchor.savecount > saveanchor.savemaxcount)
                saveanchor.savemaxcount = saveanchor.savecount;

        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;
        
}


save_fake_zone_info(int *count, vm_size_t *cur_size, vm_size_t *max_size, vm_size_t *elem_size,
                    vm_size_t *alloc_size, int *collectable, int *exhaustable)
{
        *count      = saveanchor.saveinuse;
        *cur_size   = saveanchor.savecount * (PAGE_SIZE / 2);
        *max_size   = saveanchor.savemaxcount * (PAGE_SIZE / 2);
        *elem_size  = PAGE_SIZE / 2;
        *alloc_size = PAGE_SIZE;
        *collectable = 1;
        *exhaustable = 0;
}



/*
 *              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;
}