osfmk/ppc/savearea.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
   7  *
   8  * This file contains Original Code and/or Modifications of Original Code
   9  * as defined in and that are subject to the Apple Public Source License
  10  * Version 2.0 (the 'License'). You may not use this file except in
  11  * compliance with the License. Please obtain a copy of the License at
  12  * http://www.opensource.apple.com/apsl/ and read it before using this
  13  * file.
  14  *
  15  * The Original Code and all software distributed under the License are
  16  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  17  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  18  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  20  * Please see the License for the specific language governing rights and
  21  * limitations under the License.
  22  *
  23  * @APPLE_LICENSE_HEADER_END@
  24  */
  25 /*
  26  *      This file is used to maintain the exception save areas
  27  *
  28  */
  29
  30 #include <cpus.h>
  31 #include <debug.h>
  32 #include <mach_kgdb.h>
  33 #include <mach_vm_debug.h>
  34
  35 #include <kern/thread.h>
  36 #include <mach/vm_attributes.h>
  37 #include <mach/vm_param.h>
  38 #include <vm/vm_kern.h>
  39 #include <vm/vm_map.h>
  40 #include <vm/vm_page.h>
  41 #include <mach/ppc/thread_status.h>
  42 #include <kern/spl.h>
  43 #include <kern/simple_lock.h>
  44
  45 #include <kern/misc_protos.h>
  46 #include <ppc/misc_protos.h>
  47 #include <ppc/proc_reg.h>
  48 #include <ppc/mem.h>
  49 #include <ppc/pmap.h>
  50 #include <ppc/pmap_internals.h>
  51 #include <ppc/Firmware.h>
  52 #include <ppc/mappings.h>
  53 #include <ppc/exception.h>
  54 #include <ppc/savearea.h>
  55 #include <ddb/db_output.h>
  56
  57
  58 extern struct   Saveanchor saveanchor;                                                  /* Aliged savearea anchor */
  59 struct Saveanchor backpocket;                                                                   /* Emergency saveareas */
  60 unsigned int    debsave0 = 0;                                                                   /* Debug flag */
  61 unsigned int    backchain = 0;                                                                  /* Debug flag */
  62
  63 /*
  64  *              These routines keep track of exception save areas and keeps the count within specific limits.  If there are
  65  *              too few, more are allocated, too many, and they are released. This savearea is where the PCBs are
  66  *              stored.  They never span a page boundary and are referenced by both virtual and real addresses.
  67  *              Within the interrupt vectors, the real address is used because at that level, no exceptions
  68  *              can be tolerated.  Save areas can be dynamic or permanent.  Permanant saveareas are allocated
  69  *              at boot time and must be in place before any type of exception occurs.  These are never released,
  70  *              and the number is based upon some arbitrary (yet to be determined) amount times the number of
  71  *              processors.  This represents the minimum number required to process a total system failure without
  72  *              destroying valuable and ever-so-handy system debugging information.
  73  *
  74  *              We keep two global free lists (the savearea free pool and the savearea free list) and one local
  75  *              list per processor.
  76  *
  77  *              The local lists are small and require no locked access.  They are chained using physical addresses
  78  *              and no interruptions are allowed when adding to or removing from the list. Also known as the
  79  *              qfret list. This list is local to a processor and is intended for use only by very low level
  80  *              context handling code.
  81  *
  82  *              The savearea free list is a medium size list that is globally accessible.  It is updated
  83  *              while holding a simple lock. The length of time that the lock is held is kept short.  The
  84  *              longest period of time is when the list is trimmed. Like the qfret lists, this is chained physically
  85  *              and must be accessed with translation and interruptions disabled. This is where the bulk
  86  *              of the free entries are located.
  87  *
  88  *              The saveareas are allocated from full pages.  A pool element is marked
  89  *              with an allocation map that shows which "slots" are free.  These pages are allocated via the
  90  *              normal kernel memory allocation functions. Queueing is with physical addresses.  The enqueue,
  91  *              dequeue, and search for free blocks is done under free list lock.
  92  *              only if there are empty slots in it.
  93  *
  94  *              Saveareas that are counted as "in use" once they are removed from the savearea free list.
  95  *              This means that all areas on the local qfret list are considered in use.
  96  *
  97  *              There are two methods of obtaining a savearea.  The save_get function (which is also inlined
  98  *              in the low-level exception handler) attempts to get an area from the local qfret list.  This is
  99  *              done completely without locks.  If qfret is exahusted (or maybe just too low) an area is allocated
 100  *              from the savearea free list. If the free list is empty, we install the back pocket areas and
 101  *              panic.
 102  *
 103  *              The save_alloc function is designed to be called by high level routines, e.g., thread creation,
 104  *              etc.  It will allocate from the free list.  After allocation, it will compare the free count
 105  *              to the target value.  If outside of the range, it will adjust the size either upwards or
 106  *              downwards.
 107  *
 108  *              If we need to shrink the list, it will be trimmed to the target size and unlocked.  The code
 109  *              will walk the chain and return each savearea to its pool page.  If a pool page becomes
 110  *              completely empty, it is dequeued from the free pool list and enqueued (atomic queue
 111  *              function) to be released.
 112  *
 113  *              Once the trim list is finished, the pool release queue is checked to see if there are pages
 114  *              waiting to be released. If so, they are released one at a time.
 115  *
 116  *              If the free list needed to be grown rather than shrunken, we will first attempt to recover
 117  *              a page from the pending release queue (built when we trim the free list).  If we find one,
 118  *              it is allocated, otherwise, a page of kernel memory is allocated.  This loops until there are
 119  *              enough free saveareas.
 120  *
 121  */
 122
 123
 124
 125 /*
 126  *              Allocate our initial context save areas.  As soon as we do this,
 127  *              we can take an interrupt. We do the saveareas here, 'cause they're guaranteed
 128  *              to be at least page aligned.
 129  */
 130
 131
 132 void savearea_init(vm_offset_t *addrx) {
 133
 134         savearea_comm   *savec, *savec2, *saveprev;
 135         vm_offset_t             save, save2, addr;
 136         int i;
 137
 138
 139         saveanchor.savetarget   = InitialSaveTarget;            /* Initial target value */
 140         saveanchor.saveinuse    = 0;                                            /* Number of areas in use */
 141
 142         saveanchor.savefree = 0;                                                        /* Remember the start of the free chain */
 143         saveanchor.savefreecnt = 0;                                                     /* Remember the length */
 144         saveanchor.savepoolfwd = (unsigned int *)&saveanchor;   /* Remember pool forward */
 145         saveanchor.savepoolbwd = (unsigned int *)&saveanchor;   /* Remember pool backward */
 146
 147         addr = *addrx;                                                                          /* Make this easier for ourselves */
 148
 149         save =  addr;                                                                           /* Point to the whole block of blocks */
 150
 151 /*
 152  *      First we allocate the back pocket in case of emergencies
 153  */
 154
 155
 156         for(i=0; i < 8; i++) {                                                          /* Initialize the back pocket saveareas */
 157
 158                 savec = (savearea_comm *)save;                                  /* Get the control area for this one */
 159
 160                 savec->sac_alloc = 0;                                                   /* Mark it allocated */
 161                 savec->sac_vrswap = 0;                                                  /* V=R, so the translation factor is 0 */
 162                 savec->sac_flags = sac_perm;                                    /* Mark it permanent */
 163                 savec->sac_flags |= 0x0000EE00;                                 /* Debug eyecatcher */
 164                 save_queue((savearea *)savec);                                  /* Add page to savearea lists */
 165                 save += PAGE_SIZE;                                                              /* Jump up to the next one now */
 166
 167         }
 168
 169         backpocket = saveanchor;                                                        /* Save this for emergencies */
 170
 171
 172 /*
 173  *      We've saved away the back pocket savearea info, so reset it all and
 174  *      now allocate for real
 175  */
 176
 177
 178         saveanchor.savefree = 0;                                                        /* Remember the start of the free chain */
 179         saveanchor.savefreecnt = 0;                                                     /* Remember the length */
 180         saveanchor.saveadjust = 0;                                                      /* Set none needed yet */
 181         saveanchor.savepoolfwd = (unsigned int *)&saveanchor;   /* Remember pool forward */
 182         saveanchor.savepoolbwd = (unsigned int *)&saveanchor;   /* Remember pool backward */
 183
 184         for(i=0; i < InitialSaveBloks; i++) {                           /* Initialize the saveareas */
 185
 186                 savec = (savearea_comm *)save;                                  /* Get the control area for this one */
 187
 188                 savec->sac_alloc = 0;                                                   /* Mark it allocated */
 189                 savec->sac_vrswap = 0;                                                  /* V=R, so the translation factor is 0 */
 190                 savec->sac_flags = sac_perm;                                    /* Mark it permanent */
 191                 savec->sac_flags |= 0x0000EE00;                                 /* Debug eyecatcher */
 192                 save_queue((savearea *)savec);                                  /* Add page to savearea lists */
 193                 save += PAGE_SIZE;                                                              /* Jump up to the next one now */
 194
 195         }
 196
 197         *addrx = save;                                                                          /* Move the free storage lowwater mark */
 198
 199 /*
 200  *      We now have a free list that has our initial number of entries
 201  *      The local qfret lists is empty.  When we call save_get below it will see that
 202  *      the local list is empty and fill it for us.
 203  *
 204  *      It is ok to call save_get_phys here because even though if we are translation on, we are still V=R and
 205  *      running with BAT registers so no interruptions.  Regular interruptions will be off.  Using save_get
 206  *      would be wrong if the tracing was enabled--it would cause an exception.
 207  */
 208
 209         save2 = (vm_offset_t)save_get_phys();                           /* This will populate the local list
 210                                                                                                                    and get the first one for the system */
 211         per_proc_info[0].next_savearea = (unsigned int)save2; /* Tell the exception handler about it */
 212
 213 /*
 214  *      The system is now able to take interruptions
 215  */
 216
 217         return;
 218
 219 }
 220
 221
 222
 223
 224 /*
 225  *              Returns a savearea.  If the free list needs size adjustment it happens here.
 226  *              Don't actually allocate the savearea until after the adjustment is done.
 227  */
 228
 229 struct savearea *save_alloc(void) {                                             /* Reserve a save area */
 230
 231
 232         if(saveanchor.saveadjust) save_adjust();                        /* If size need adjustment, do it now */
 233
 234         return save_get();                                                                      /* Pass the baby... */
 235 }
 236
 237
 238 /*
 239  *              This routine releases a save area to the free queue.  If after that, we have more than our maximum target,
 240  *              we start releasing what we can until we hit the normal target.
 241  */
 242
 243
 244
 245 void save_release(struct savearea *save) {                              /* Release a save area */
 246
 247         save_ret(save);                                                                         /* Return a savearea to the free list */
 248
 249         if(saveanchor.saveadjust) save_adjust();                        /* Adjust the savearea free list and pool size if needed */
 250
 251         return;
 252
 253 }
 254
 255
 256 /*
 257  *              Adjusts the size of the free list.  Can either release or allocate full pages
 258  *              of kernel memory.  This can block.
 259  *
 260  *              Note that we will only run one adjustment and the amount needed may change
 261  *              while we are executing.
 262  *
 263  *              Calling this routine is triggered by saveanchor.saveadjust.  This value is always calculated just before
 264  *              we unlock the saveanchor lock (this keeps it pretty accurate).  If the total of savefreecnt and saveinuse
 265  *              is within the hysteresis range, it is set to 0.  If outside, it is set to the number needed to bring
 266  *              the total to the target value.  Note that there is a minimum size to the free list (FreeListMin) and if
 267  *              savefreecnt falls below that, saveadjust is set to the number needed to bring it to that.
 268  */
 269
 270
 271 void save_adjust(void) {
 272
 273         savearea_comm   *sctl, *sctlnext, *freepool, *freepage, *realpage;
 274         kern_return_t ret;
 275
 276         if(saveanchor.saveadjust < 0)                                   {       /* Do we need to adjust down? */
 277
 278                 sctl = (savearea_comm *)save_trim_free();               /* Trim list to the need count, return start of trim list */
 279
 280                 while(sctl) {                                                                   /* Release the free pages back to the kernel */
 281                         sctlnext = (savearea_comm *)sctl->save_prev;    /* Get next in list */
 282                         kmem_free(kernel_map, (vm_offset_t) sctl, PAGE_SIZE);   /* Release the page */
 283                         sctl = sctlnext;                                                        /* Chain onwards */
 284                 }
 285         }
 286         else {                                                                                          /* We need more... */
 287
 288                 if(save_recover()) return;                                              /* If we can recover enough from the pool, return */
 289
 290                 while(saveanchor.saveadjust > 0) {                              /* Keep going until we have enough */
 291
 292                         ret = kmem_alloc_wired(kernel_map, (vm_offset_t *)&freepage, PAGE_SIZE);        /* Get a page for free pool */
 293                         if(ret != KERN_SUCCESS) {                                       /* Did we get some memory? */
 294                                 panic("Whoops...  Not a bit of wired memory left for saveareas\n");
 295                         }
 296
 297                         realpage = (savearea_comm *)pmap_extract(kernel_pmap, (vm_offset_t)freepage);   /* Get the physical */
 298
 299                         bzero((void *)freepage, PAGE_SIZE);                     /* Clear it all to zeros */
 300                         freepage->sac_alloc = 0;                                        /* Mark all entries taken */
 301                         freepage->sac_vrswap = (unsigned int)freepage ^ (unsigned int)realpage;         /* Form mask to convert V to R and vice versa */
 302
 303                         freepage->sac_flags |= 0x0000EE00;                      /* Set debug eyecatcher */
 304
 305                         save_queue((savearea *)realpage);                       /* Add all saveareas on page to free list */
 306                 }
 307         }
 308 }
 309
 310 /*
 311  *              Fake up information to make the saveareas look like a zone
 312  */
 313
 314 save_fake_zone_info(int *count, vm_size_t *cur_size, vm_size_t *max_size, vm_size_t *elem_size,
 315                     vm_size_t *alloc_size, int *collectable, int *exhaustable)
 316 {
 317         *count      = saveanchor.saveinuse;
 318         *cur_size   = (saveanchor.savefreecnt + saveanchor.saveinuse) * (PAGE_SIZE / sac_cnt);
 319         *max_size   = saveanchor.savemaxcount * (PAGE_SIZE / sac_cnt);
 320         *elem_size  = sizeof(savearea);
 321         *alloc_size = PAGE_SIZE;
 322         *collectable = 1;
 323         *exhaustable = 0;
 324 }
 325
 326