]> git.saurik.com Git - apple/xnu.git/blobdiff - osfmk/ppc/pcb.c
projects / apple / xnu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xnu-1228.12.14.tar.gz
[apple/xnu.git] / osfmk / ppc / pcb.c
diff --git a/osfmk/ppc/pcb.c b/osfmk/ppc/pcb.c
index 475c9763740817d5bf48570ceb1b8d5ca8a08b99..38569fc947db92cdb320671a5e6d1b8901629837 100644 (file)
--- a/osfmk/ppc/pcb.c
+++ b/osfmk/ppc/pcb.c
@@ -1,23 +1,29 @@
 /*
 /*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
  *
  *
- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_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 file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
  * 
  * 
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The 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,
  * 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.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
  * 
  * 
- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*
  * @OSF_COPYRIGHT@
  */
 /*
  * @OSF_COPYRIGHT@
@@ -44,38 +50,44 @@
  *     Utah $Hdr: pcb.c 1.23 92/06/27$
  */
 
  *     Utah $Hdr: pcb.c 1.23 92/06/27$
  */
 
-#include <cpus.h>
 #include <debug.h>
 
 #include <types.h>
 #include <debug.h>
 
 #include <types.h>
+
+#include <mach/mach_types.h>
+#include <mach/thread_status.h>
+
+#include <kern/kern_types.h>
 #include <kern/task.h>
 #include <kern/thread.h>
 #include <kern/task.h>
 #include <kern/thread.h>
-#include <kern/thread_act.h>
-#include <kern/thread_swap.h>
-#include <mach/thread_status.h>
-#include <vm/vm_kern.h>
+#include <kern/misc_protos.h>
 #include <kern/mach_param.h>
 #include <kern/mach_param.h>
+#include <kern/spl.h>
+#include <kern/machine.h>
+
+#include <vm/vm_map.h>
+#include <vm/vm_kern.h>
+#include <vm/vm_protos.h>
 
 
-#include <kern/misc_protos.h>
 #include <ppc/misc_protos.h>
 #include <ppc/misc_protos.h>
-#include <ppc/fpu_protos.h>
+#include <ppc/cpu_internal.h>
 #include <ppc/exception.h>
 #include <ppc/proc_reg.h>
 #include <ppc/exception.h>
 #include <ppc/proc_reg.h>
-#include <kern/spl.h>
 #include <ppc/pmap.h>
 #include <ppc/trap.h>
 #include <ppc/mappings.h>
 #include <ppc/savearea.h>
 #include <ppc/Firmware.h>
 #include <ppc/asm.h>
 #include <ppc/pmap.h>
 #include <ppc/trap.h>
 #include <ppc/mappings.h>
 #include <ppc/savearea.h>
 #include <ppc/Firmware.h>
 #include <ppc/asm.h>
-#include <ppc/thread_act.h>
+#include <ppc/thread.h>
 #include <ppc/vmachmon.h>
 #include <ppc/low_trace.h>
 #include <ppc/vmachmon.h>
 #include <ppc/low_trace.h>
+#include <ppc/lowglobals.h>
+#include <ppc/fpu_protos.h>
 
 #include <sys/kdebug.h>
 
 
 #include <sys/kdebug.h>
 
-extern int             real_ncpus;                                             /* Number of actual CPUs */
-extern struct  Saveanchor saveanchor;                  /* Aliged savearea anchor */
+void   machine_act_terminate(thread_t);
 
 /*
  * These constants are dumb. They should not be in asm.h!
 
 /*
  * These constants are dumb. They should not be in asm.h!
@@ -90,156 +102,104 @@ int   vec_trap_count = 0;
 int   vec_switch_count = 0;
 #endif
 
 int   vec_switch_count = 0;
 #endif
 
-extern struct thread_shuttle   *Switch_context(
-                                       struct thread_shuttle   *old,
-                                       void                    (*cont)(void),
-                                       struct thread_shuttle   *new);
-
-
-#if    MACH_LDEBUG || MACH_KDB
-void           log_thread_action (char *, long, long, long);
-#endif
-
-
 /*
  * consider_machine_collect: try to collect machine-dependent pages
  */
 void
 /*
  * consider_machine_collect: try to collect machine-dependent pages
  */
 void
-consider_machine_collect()
+consider_machine_collect(void)
 {
     /*
 {
     /*
-     * none currently available
+     * XXX none currently available
      */
      */
-       return;
 }
 
 void
 }
 
 void
-consider_machine_adjust()
+consider_machine_adjust(void)
 {
         consider_mapping_adjust();
 }
 
 {
         consider_mapping_adjust();
 }
 
-
-/*
- * stack_attach: Attach a kernel stack to a thread.
- */
-void
-machine_kernel_stack_init(
-       struct thread_shuttle *thread,
-       void            (*start_pos)(thread_t))
-{
-    vm_offset_t        stack;
-    unsigned int                       *kss;
-       struct savearea                 *sv;
-
-    assert(thread->top_act->mact.pcb);
-    assert(thread->kernel_stack);
-    stack = thread->kernel_stack;
-
-#if    MACH_ASSERT
-    if (watchacts & WA_PCB)
-               printf("machine_kernel_stack_init(thr=%x,stk=%x,start_pos=%x)\n", thread,stack,start_pos);
-#endif /* MACH_ASSERT */
-       
-       kss = (unsigned int *)STACK_IKS(stack);
-       sv=(savearea *)(thread->top_act->mact.pcb);                     /* This for the sake of C */
-
-       sv->save_lr = (unsigned int) start_pos;                 /* Set up the execution address */
-       sv->save_srr0 = (unsigned int) start_pos;               /* Here too */
-       sv->save_srr1 = MSR_SUPERVISOR_INT_OFF;                         /* Set the normal running MSR */
-       sv->save_r1 = (vm_offset_t) ((int)kss - KF_SIZE);       /* Point to the top frame on the stack */
-       sv->save_xfpscrpad = 0;                                                         /* Start with a clear fpscr */
-       sv->save_xfpscr = 0;                                                            /* Start with a clear fpscr */
-
-       *((int *)sv->save_r1) = 0;                                                      /* Zero the frame backpointer */
-       thread->top_act->mact.ksp = 0;                                          /* Show that the kernel stack is in use already */
-
-}
-
 /*
  * switch_context: Switch from one thread to another, needed for
  *                switching of space
  * 
  */
 /*
  * switch_context: Switch from one thread to another, needed for
  *                switching of space
  * 
  */
-struct thread_shuttle*
-switch_context(
-       struct thread_shuttle *old,
-       void (*continuation)(void),
-       struct thread_shuttle *new)
+thread_t
+machine_switch_context(
+       thread_t                        old,
+       thread_continue_t       continuation,
+       thread_t                        new)
 {
 {
-       register thread_act_t old_act = old->top_act, new_act = new->top_act;
-       register struct thread_shuttle* retval;
+       register thread_t retval;
        pmap_t  new_pmap;
        pmap_t  new_pmap;
-#if    MACH_LDEBUG || MACH_KDB
-       log_thread_action("switch", 
-                         (long)old, 
-                         (long)new, 
-                         (long)__builtin_return_address(0));
-#endif
-       per_proc_info[cpu_number()].old_thread = old;
-       per_proc_info[cpu_number()].cpu_flags &= ~traceBE;  /* disable branch tracing if on */
-       assert(old_act->kernel_loaded ||
-              active_stacks[cpu_number()] == old_act->thread->kernel_stack);
-              
-       check_simple_locks();
+       facility_context *fowner;
+       struct per_proc_info *ppinfo;
+
+       if (old == new)
+               panic("machine_switch_context");
 
 
+       ppinfo = getPerProc();                                                          /* Get our processor block */
+
+       ppinfo->old_thread = (unsigned int)old;
+              
        /* Our context might wake up on another processor, so we must
         * not keep hot state in our FPU, it must go back to the pcb
         * so that it can be found by the other if needed
         */
        /* Our context might wake up on another processor, so we must
         * not keep hot state in our FPU, it must go back to the pcb
         * so that it can be found by the other if needed
         */
-       if(real_ncpus > 1) {    /* This is potentially slow, so only do when actually SMP */
-               fpu_save(old_act);      /* Save floating point if used */
-               vec_save(old_act);      /* Save vector if used */
+       if(real_ncpus > 1) {                                                            /* This is potentially slow, so only do when actually SMP */
+               fowner = ppinfo->FPU_owner;                                             /* Cache this because it may change */
+               if(fowner) {                                                                    /* Is there any live context? */
+                       if(fowner->facAct == old) {             /* Is it for us? */
+                               fpu_save(fowner);                                               /* Yes, save it */
+                       }
+               }
+               fowner = ppinfo->VMX_owner;                                             /* Cache this because it may change */
+               if(fowner) {                                                                    /* Is there any live context? */
+                       if(fowner->facAct == old) {             /* Is it for us? */
+                               vec_save(fowner);                                               /* Yes, save it */
+                       }
+               }
        }
 
        }
 
-#if DEBUG
-       if (watchacts & WA_PCB) {
-               printf("switch_context(0x%08x, 0x%x, 0x%08x)\n",
-                      old,continuation,new);
+       /*
+        * If old thread is running VM, save per proc userProtKey and FamVMmode spcFlags bits in the thread spcFlags
+        * This bits can be modified in the per proc without updating the thread spcFlags
+        */
+       if(old->machine.specFlags & runningVM) {
+               old->machine.specFlags &=  ~(userProtKey|FamVMmode);
+               old->machine.specFlags |= (ppinfo->spcFlags) & (userProtKey|FamVMmode);
        }
        }
-#endif /* DEBUG */
+       old->machine.specFlags &= ~OnProc;
+       new->machine.specFlags |= OnProc;
 
        /*
         * We do not have to worry about the PMAP module, so switch.
         *
 
        /*
         * We do not have to worry about the PMAP module, so switch.
         *
-        * We must not use top_act->map since this may not be the actual
+        * We must not use thread->map since this may not be the actual
         * task map, but the map being used for a klcopyin/out.
         */
 
         * task map, but the map being used for a klcopyin/out.
         */
 
-       if(new_act->mact.specFlags & runningVM) {                       /* Is the new guy running a VM? */
-               pmap_switch(new_act->mact.vmmCEntry->vmmPmap);  /* Switch to the VM's pmap */
+       if(new->machine.specFlags & runningVM) {                        /* Is the new guy running a VM? */
+               pmap_switch(new->machine.vmmCEntry->vmmPmap);   /* Switch to the VM's pmap */
+               ppinfo->VMMareaPhys = new->machine.vmmCEntry->vmmContextPhys;
+               ppinfo->VMMXAFlgs = new->machine.vmmCEntry->vmmXAFlgs;
+               ppinfo->FAMintercept = new->machine.vmmCEntry->vmmFAMintercept;
        }
        else {                                                                                          /* otherwise, we use the task's pmap */
        }
        else {                                                                                          /* otherwise, we use the task's pmap */
-               new_pmap = new_act->task->map->pmap;
-               if ((old_act->task->map->pmap != new_pmap) || (old_act->mact.specFlags & runningVM)) {
+               new_pmap = new->task->map->pmap;
+               if ((old->task->map->pmap != new_pmap) || (old->machine.specFlags & runningVM)) {
                        pmap_switch(new_pmap);                                          /* Switch if there is a change */
                }
        }
 
                        pmap_switch(new_pmap);                                          /* Switch if there is a change */
                }
        }
 
-       /* Sanity check - is the stack pointer inside the stack that
-        * we're about to switch to? Is the execution address within
-        * the kernel's VM space??
-        */
-#if 0
-       printf("************* stack=%08X; R1=%08X; LR=%08X; old=%08X; cont=%08X; new=%08X\n",
-               new->kernel_stack, new_act->mact.pcb->ss.r1,
-               new_act->mact.pcb->ss.lr, old, continuation, new);      /* (TEST/DEBUG) */
-       assert((new->kernel_stack < new_act->mact.pcb->ss.r1) &&
-              ((unsigned int)STACK_IKS(new->kernel_stack) >
-               new_act->mact.pcb->ss.r1));
-       assert(new_act->mact.pcb->ss.lr < VM_MAX_KERNEL_ADDRESS);
-#endif
-
-
-       KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED,MACH_SCHED) | DBG_FUNC_NONE,
-                    (int)old, (int)new, old->sched_pri, new->sched_pri, 0);
-
+       if(old->machine.umwSpace != invalSpace) {                       /* Does our old guy have an active window? */
+               old->machine.umwSpace |= umwSwitchAway;                 /* Show we switched away from this guy */
+               hw_blow_seg(lowGlo.lgUMWvaddr);                                 /* Blow off the first segment */
+               hw_blow_seg(lowGlo.lgUMWvaddr + 0x10000000ULL); /* Blow off the second segment */
+       }
 
        retval = Switch_context(old, continuation, new);
 
        retval = Switch_context(old, continuation, new);
-       assert(retval != (struct thread_shuttle*)NULL);
-
-       if (branch_tracing_enabled())
-         per_proc_info[cpu_number()].cpu_flags |= traceBE;  /* restore branch tracing */
+       assert(retval != NULL);
 
        /* We've returned from having switched context, so we should be
         * back in the original context.
 
        /* We've returned from having switched context, so we should be
         * back in the original context.
@@ -248,60 +208,33 @@ switch_context(
        return retval;
 }
 
        return retval;
 }
 
-/*
- * Alter the thread's state so that a following thread_exception_return
- * will make the thread return 'retval' from a syscall.
- */
-void
-thread_set_syscall_return(
-       struct thread_shuttle *thread,
-       kern_return_t   retval)
-{
-       struct ppc_saved_state *ssp = &thread->top_act->mact.pcb->ss;
-
-#if    MACH_ASSERT
-       if (watchacts & WA_PCB)
-               printf("thread_set_syscall_return(thr=%x,retval=%d)\n", thread,retval);
-#endif /* MACH_ASSERT */
-
-        ssp->r3 = retval;
-}
-
 /*
  * Initialize the machine-dependent state for a new thread.
  */
 kern_return_t
 /*
  * Initialize the machine-dependent state for a new thread.
  */
 kern_return_t
-thread_machine_create(
-                     struct thread_shuttle *thread,
-                     thread_act_t thr_act,
-                     void (*start_pos)(thread_t))
+machine_thread_create(
+       thread_t                thread,
+       task_t                  task)
 {
 {
+       struct savearea         *sv;                                                                    /* Pointer to newly allocated savearea */
 
 
-       savearea                *sv;                                                                    /* Pointer to newly allocated savearea */
-       unsigned int    *CIsTooLimited, i;
-
-
-#if    MACH_ASSERT
-    if (watchacts & WA_PCB)
-       printf("thread_machine_create(thr=%x,thr_act=%x,st=%x)\n", thread, thr_act, start_pos);
-#endif /* MACH_ASSERT */
-
-       hw_atomic_add(&saveanchor.saveneed, 4);                                 /* Account for the number of saveareas we think we "need"
+       (void)hw_atomic_add(&saveanchor.savetarget, 4); /* Account for the number of saveareas we think we "need"
                                                                                                                           for this activation */
                                                                                                                           for this activation */
-       assert(thr_act->mact.pcb == (pcb_t)0);                                  /* Make sure there was no previous savearea */
+       assert(thread->machine.pcb == (struct savearea *)0);                            /* Make sure there was no previous savearea */
        
        sv = save_alloc();                                                                              /* Go get us a savearea */
                
        
        sv = save_alloc();                                                                              /* Go get us a savearea */
                
-       bzero((char *) sv, sizeof(struct pcb));                                 /* Clear out the whole shebang */
-       
-       sv->save_act = thr_act;                                                                 /* Set who owns it */
-       sv->save_vrsave = 0;
-       thr_act->mact.pcb = (pcb_t)sv;                                                  /* Point to the save area */
-
-#if    MACH_ASSERT
-       if (watchacts & WA_PCB)
-               printf("pcb_init(%x) pcb=%x\n", thr_act, sv);
-#endif /* MACH_ASSERT */
+       bzero((char *)((unsigned int)sv + sizeof(savearea_comm)), (sizeof(struct savearea) - sizeof(savearea_comm)));   /* Clear it */
+               
+       sv->save_hdr.save_prev = 0;                                                             /* Clear the back pointer */
+       sv->save_hdr.save_flags = (sv->save_hdr.save_flags & ~SAVtype) | (SAVgeneral << SAVtypeshft);   /* Mark as in use */
+       sv->save_hdr.save_act = thread; /* Set who owns it */
+       thread->machine.pcb = sv;                                                                       /* Point to the save area */
+       thread->machine.curctx = &thread->machine.facctx;                       /* Initialize facility context */
+       thread->machine.facctx.facAct = thread;                                         /* Initialize facility context pointer to activation */
+       thread->machine.umwSpace = invalSpace;                                          /* Initialize user memory window space to invalid */
+       thread->machine.preemption_count = 0;                                           /* Initialize preemption counter */
+
        /*
         * User threads will pull their context from the pcb when first
         * returning to user mode, so fill in all the necessary values.
        /*
         * User threads will pull their context from the pcb when first
         * returning to user mode, so fill in all the necessary values.
@@ -309,14 +242,16 @@ thread_machine_create(
         * at the base of the kernel stack (see stack_attach()).
         */
 
         * at the base of the kernel stack (see stack_attach()).
         */
 
-       sv->save_srr1 = MSR_EXPORT_MASK_SET;                                    /* Set the default user MSR */
+       thread->machine.upcb = sv;                                                              /* Set user pcb */
+       sv->save_srr1 = (uint64_t)MSR_EXPORT_MASK_SET;                  /* Set the default user MSR */
+       if(task_has_64BitAddr(task)) sv->save_srr1 |= (uint64_t)MASK32(MSR_SF) << 32;   /* If 64-bit task, force 64-bit mode */
+       sv->save_fpscr = 0;                                                                             /* Clear all floating point exceptions */
+       sv->save_vrsave = 0;                                                                    /* Set the vector save state */
+       sv->save_vscr[0] = 0x00000000;                                  
+       sv->save_vscr[1] = 0x00000000;                                  
+       sv->save_vscr[2] = 0x00000000;                                  
+       sv->save_vscr[3] = 0x00010000;                                                  /* Disable java mode and clear saturated */
        
        
-       CIsTooLimited = (unsigned int *)(&sv->save_sr0);                        /* Make a pointer 'cause C can't cast on the left */
-       for(i=0; i<16; i++) {                                                                   /* Initialize all SRs */
-               CIsTooLimited[i] = SEG_REG_PROT | (i << 20) | thr_act->task->map->pmap->space;  /* Set the SR value */
-       }
-       sv->save_sr_copyin = SEG_REG_PROT | (SR_COPYIN_NUM<<20) | thr_act->task->map->pmap->space;      /* Default the copyin */
-
     return(KERN_SUCCESS);
 }
 
     return(KERN_SUCCESS);
 }
 
@@ -324,420 +259,213 @@ thread_machine_create(
  * Machine-dependent cleanup prior to destroying a thread
  */
 void
  * Machine-dependent cleanup prior to destroying a thread
  */
 void
-thread_machine_destroy( thread_t thread )
-{
-       spl_t s;
-
-       if (thread->kernel_stack) {
-               s = splsched();
-               stack_free(thread);
-               splx(s);
-       }
-}
-
-/*
- * flush out any lazily evaluated HW state in the
- * owning thread's context, before termination.
- */
-void
-thread_machine_flush( thread_act_t cur_act )
+machine_thread_destroy(
+       thread_t                thread)
 {
 {
-}
+       struct savearea *local_pcb, *ppsv;
+       savearea_vec *vsv, *vpsv;
+       savearea_fpu *fsv, *fpsv;
+       boolean_t intr;
 
 /*
 
 /*
- * Number of times we needed to swap an activation back in before
- * switching to it.
+ *     This function will release all context.
  */
  */
-int switch_act_swapins = 0;
 
 
+       machine_act_terminate(thread);                                                  /* Make sure all virtual machines are dead first */
+ 
 /*
 /*
- * machine_switch_act
  *
  *
- * Machine-dependent details of activation switching.  Called with
- * RPC locks held and preemption disabled.
+ *     Walk through and release all floating point and vector contexts. Also kill live context.
+ *
  */
  */
-void
-machine_switch_act( 
-       thread_t        thread,
-       thread_act_t    old,
-       thread_act_t    new,
-       int                             cpu)
-{
-       pmap_t          new_pmap;
 
 
-       /* Our context might wake up on another processor, so we must
-        * not keep hot state in our FPU, it must go back to the pcb
-        * so that it can be found by the other if needed
-        */
-       if(real_ncpus > 1) {    /* This is potentially slow, so only do when actually SMP */
-               fpu_save(old);          /* Save floating point if used */
-               vec_save(old);          /* Save vector if used */
-       }
+       intr = ml_set_interrupts_enabled(FALSE);                                /* Disable for interruptions */
+ 
+       toss_live_vec(thread->machine.curctx);                                  /* Dump live vectors */
 
 
-       active_stacks[cpu] = thread->kernel_stack;
+       vsv = thread->machine.curctx->VMXsave;                                  /* Get the top vector savearea */
+       
+       while(vsv) {                                                                                    /* Any VMX saved state? */
+               vpsv = vsv;                                                                                     /* Remember so we can toss this */
+               /* XXX save_prev should be a void * 4425537 */
+               vsv = CAST_DOWN(savearea_vec *, vsv->save_hdr.save_prev);  /* Get one underneath our's */
+               save_release((struct savearea *)vpsv);                                          /* Release it */
+       }
+       
+       thread->machine.curctx->VMXsave = NULL;                                 /* Kill chain */
+ 
+       toss_live_fpu(thread->machine.curctx);                                  /* Dump live float */
 
 
-       ast_context(new, cpu);
+       fsv = thread->machine.curctx->FPUsave;                                  /* Get the top float savearea */
+       
+       while(fsv) {                                                                                    /* Any float saved state? */
+               fpsv = fsv;                                                                                     /* Remember so we can toss this */
+               /* XXX save_prev should be a void * 4425537 */
+               fsv = CAST_DOWN(savearea_fpu *, fsv->save_hdr.save_prev);   /* Get one underneath our's */
+               save_release((struct savearea *)fpsv);                                          /* Release it */
+       }
+       
+       thread->machine.curctx->FPUsave = NULL;                                 /* Kill chain */
 
 
-       /* Activations might have different pmaps 
-        * (process->kernel->server, for example).
-        * Change space if needed
-        */
+/*
+ * free all regular saveareas.
+ */
 
 
-       if(new->mact.specFlags & runningVM) {                   /* Is the new guy running a VM? */
-               pmap_switch(new->mact.vmmCEntry->vmmPmap);      /* Switch to the VM's pmap */
-       }
-       else {                                                                                          /* otherwise, we use the task's pmap */
-               new_pmap = new->task->map->pmap;
-               if ((old->task->map->pmap != new_pmap)  || (old->mact.specFlags & runningVM)) {
-                       pmap_switch(new_pmap);
-               }
+       local_pcb = thread->machine.pcb;                                                                /* Get the general savearea */
+       
+       while(local_pcb) {                                                                                      /* Any float saved state? */
+               ppsv = local_pcb;                                                                                       /* Remember so we can toss this */
+               /* XXX save_prev should be a void * 4425537 */
+               local_pcb = CAST_DOWN(struct savearea *, local_pcb->save_hdr.save_prev);  /* Get one underneath our's */ 
+               save_release(ppsv);                                                                     /* Release it */
        }
        }
+       
+       (void)hw_atomic_sub(&saveanchor.savetarget, 4); /* Unaccount for the number of saveareas we think we "need" */
 
 
-}
-
-void
-pcb_user_to_kernel(thread_act_t act)
-{
+       (void) ml_set_interrupts_enabled(intr);                                 /* Restore interrupts if enabled */
 
 
-       return;                                                                                                 /* Not needed, I hope... */
 }
 
 }
 
-
 /*
  * act_machine_sv_free
 /*
  * act_machine_sv_free
- * release saveareas associated with an act. if flag is true, release
+ * release saveareas associated with a thread. if flag is true, release
  * user level savearea(s) too, else don't
  *
  * user level savearea(s) too, else don't
  *
- * this code cannot block so we call the proper save area free routine
+ * This code must run with interruptions disabled because an interrupt handler
+ * could use floating point and/or vectors.  If this happens and the thread we
+ * are blowing off owns the facility, we can deadlock.
  */
 void
  */
 void
-act_machine_sv_free(thread_act_t act)
+act_machine_sv_free(thread_t act,  __unused int flag)
 {
 {
-       register pcb_t pcb,userpcb,npcb;
-       register savearea *svp;
-       register int i;
+       struct savearea *local_pcb, *userpcb;
+       register savearea_vec *vsv, *vpst, *vsvt;
+       register savearea_fpu *fsv, *fpst, *fsvt;
+       struct savearea *svp;
+       boolean_t intr;
 
 /*
 
 /*
- *     This next bit insures that any live facility context for this thread is discarded on every processor
- *     that may have it.  We go through all per-processor blocks and zero the facility owner if
- *     it is the thread being destroyed. This needs to be done via a compare-and-swap because
- *     some other processor could change the owner while we are clearing it. It turns out that 
- *     this is the only place where we need the interlock, normal use of the owner field is cpu-local
- *     and doesn't need the interlock. Because we are called during termintation, and a thread
- *     terminates itself, the context on other processors has been saved (because we save it as
- *     part of the context switch), even if it is still considered live. Since the dead thread is 
- *     not running elsewhere, and the context is saved, any other processor looking at the owner
- *     field will not attempt to save context again, meaning that it doesn't matter if the owner
- *     changes out from under it.
+ *     This function will release all non-user state context.
  */
  
  */
  
-       /* 
-        * free VMX and FPU saveareas.  do not free user save areas.
-     * user VMX and FPU saveareas, if any, i'm told are last in
-     * the chain so we just stop if we find them
-        * we identify user VMX and FPU saveareas when we find a pcb
-        * with a save level of 0.  we identify user regular save
-        * areas when we find one with MSR_PR set
-        */
-
-       pcb = act->mact.VMX_pcb;                                                                /* Get the top vector savearea */
-       while(pcb) {                                                                                    /* Any VMX saved state? */
-               svp = (savearea *)pcb;                                                          /* save lots of casting later */
-               if (svp->save_level_vec == 0) break;   /* done when hit user if any */
-               pcb = (pcb_t)svp->save_prev_vector;                             /* Get one underneath our's */          
-               svp->save_flags &= ~SAVvmxvalid;                                                /* Clear the VMX flag */
-               if(!(svp->save_flags & SAVinuse)) {                                     /* Anyone left with this one? */                        
-
-                               save_ret(svp);                          /* release it */
-               }
-       }
-       act->mact.VMX_pcb = pcb;
-       if (act->mact.VMX_lvl != 0) {
-         for(i=0; i < real_ncpus; i++) {                                                       /* Cycle through processors */
-               (void)hw_compare_and_store((unsigned int)act, 0, &per_proc_info[i].VMX_thread); /* Clear if ours */
-         }
-       }
-
-       pcb = act->mact.FPU_pcb;                                                                /* Get the top floating point savearea */
-       while(pcb) {                                                                                    /* Any floating point saved state? */
-               svp = (savearea *)pcb;
-               if (svp->save_level_fp == 0) break;     /* done when hit user if any */
-               pcb = (pcb_t)svp->save_prev_float;                                      /* Get one underneath our's */          
-               svp->save_flags &= ~SAVfpuvalid;                                                /* Clear the floating point flag */
-               if(!(svp->save_flags & SAVinuse)) {                                     /* Anyone left with this one? */                        
-                               save_ret(svp);                                                  /* Nope, release it */
-               }
-       }
-       act->mact.FPU_pcb = pcb;
-       if (act->mact.FPU_lvl != 0) {
-         for(i=0; i < real_ncpus; i++) {                                                       /* Cycle through processors */
-               (void)hw_compare_and_store((unsigned int)act, 0, &per_proc_info[i].FPU_thread); /* Clear if ours */
-         }
-       }
-
-       /*
-        * free all regular saveareas except a user savearea, if any
-        */
-
-       pcb = act->mact.pcb;
-       userpcb = (pcb_t)0;
-       while(pcb) {
-         svp = (savearea *)pcb;
-         if ((svp->save_srr1 & MASK(MSR_PR))) {
-               assert(userpcb == (pcb_t)0);
-               userpcb = pcb;
-               svp = (savearea *)userpcb;
-               npcb = (pcb_t)svp->save_prev;
-               svp->save_prev = (struct savearea *)0;
-         } else {
-               svp->save_flags &= ~SAVattach;          /* Clear the attached flag */
-               npcb = (pcb_t)svp->save_prev;
-               if(!(svp->save_flags & SAVinuse))       /* Anyone left with this one? */
-                       save_ret(svp);
-         }
-         pcb = npcb;
-       }
-       act->mact.pcb = userpcb;
-
-}
-
-
 /*
 /*
- * act_virtual_machine_destroy:
- * Shutdown any virtual machines associated with a thread
+ *
+ *     Walk through and release all floating point and vector contexts that are not
+ *     user state.  We will also blow away live context if it belongs to non-user state.
+ *     Note that the level can not change while we are in this code.  Nor can another
+ *     context be pushed on the stack.
+ *
+ *     We do nothing here if the current level is user.  Otherwise,
+ *     the live context is cleared.  Then we find the user saved context.
+ *     Next,  we take the sync lock (to keep us from munging things in *_switch).
+ *     The level is set to 0 and all stacked context other than user is dequeued.
+ *     Then we unlock.  Next, all of the old kernel contexts are released.
+ *
  */
  */
-void
-act_virtual_machine_destroy(thread_act_t act)
-{
-       if(act->mact.bbDescAddr) {                                                              /* Check if the Blue box assist is active */
-               disable_bluebox_internal(act);                                          /* Kill off bluebox */
-       }
-       
-       if(act->mact.vmmControl) {                                                              /* Check if VMM is active */
-               vmm_tear_down_all(act);                                                         /* Kill off all VMM contexts */
-       }
-}
 
 
-/*
- * act_machine_destroy: Shutdown any state associated with a thread pcb.
- */
-void
-act_machine_destroy(thread_act_t act)
-{
-       register pcb_t  pcb, opcb;
-       int i;
+       intr = ml_set_interrupts_enabled(FALSE);                                /* Disable for interruptions */
 
 
-#if    MACH_ASSERT
-       if (watchacts & WA_PCB)
-               printf("act_machine_destroy(0x%x)\n", act);
-#endif /* MACH_ASSERT */
-
-       act_virtual_machine_destroy(act);
-
-/*
- *     This next bit insures that any live facility context for this thread is discarded on every processor
- *     that may have it.  We go through all per-processor blocks and zero the facility owner if
- *     it is the thread being destroyed. This needs to be done via a compare-and-swap because
- *     some other processor could change the owner while we are clearing it. It turns out that 
- *     this is the only place where we need the interlock, normal use of the owner field is cpu-local
- *     and doesn't need the interlock. Because we are called during termintation, and a thread
- *     terminates itself, the context on other processors has been saved (because we save it as
- *     part of the context switch), even if it is still considered live. Since the dead thread is 
- *     not running elsewhere, and the context is saved, any other processor looking at the owner
- *     field will not attempt to save context again, meaning that it doesn't matter if the owner
- *     changes out from under it.
- */
- 
-       for(i=0; i < real_ncpus; i++) {                                                 /* Cycle through processors */
-               (void)hw_compare_and_store((unsigned int)act, 0, &per_proc_info[i].FPU_thread); /* Clear if ours */
-               (void)hw_compare_and_store((unsigned int)act, 0, &per_proc_info[i].VMX_thread); /* Clear if ours */
-       }
+       if(act->machine.curctx->VMXlevel) {                                             /* Is the current level user state? */
+               
+               toss_live_vec(act->machine.curctx);                                     /* Dump live vectors if is not user */
+               
+               if(!hw_lock_to((hw_lock_t)&act->machine.curctx->VMXsync, LockTimeOut)) {        /* Get the sync lock */ 
+                       panic("act_machine_sv_free - timeout getting VMX sync lock\n"); /* Tell all and die */
+               }
        
        
-       pcb = act->mact.VMX_pcb;                                                                /* Get the top vector savearea */
-       while(pcb) {                                                                                    /* Any VMX saved state? */
-               opcb = pcb;                                                                                     /* Save current savearea address */
-               pcb = (pcb_t)(((savearea *)pcb)->save_prev_vector);     /* Get one underneath our's */          
-               ((savearea *)opcb)->save_flags &= ~SAVvmxvalid;         /* Clear the VMX flag */
+               vsv = act->machine.curctx->VMXsave;                                     /* Get the top vector savearea */
+               while(vsv && vsv->save_hdr.save_level)  /* Find user context if any */
+                       /* XXX save_prev should be a void * 4425537 */
+                       vsv = CAST_DOWN(savearea_vec *,
+                                       vsv->save_hdr.save_prev);
                
                
-               if(!(((savearea *)opcb)->save_flags & SAVinuse)) {      /* Anyone left with this one? */                        
-                       save_release((savearea *)opcb);                                 /* Nope, release it */
+               vsvt = act->machine.curctx->VMXsave;                            /* Get the top of the chain */
+               act->machine.curctx->VMXsave = vsv;                                     /* Point to the user context */
+               act->machine.curctx->VMXlevel = NULL;                                   /* Set the level to user */
+               hw_lock_unlock((hw_lock_t)&act->machine.curctx->VMXsync);       /* Unlock */
+               
+               while(vsvt) {                                                                           /* Clear any VMX saved state */
+                       if (vsvt == vsv) break;                                                 /* Done when hit user if any */
+                       vpst = vsvt;                                                                    /* Remember so we can toss this */
+                       /* XXX save_prev should be a void * 4425537 */
+                       vsvt = CAST_DOWN(savearea_vec *, vsvt->save_hdr.save_prev);     /* Get one underneath our's */          
+                       save_ret((struct savearea *)vpst);                                              /* Release it */
                }
                }
+               
        }
        }
-       act->mact.VMX_pcb = (pcb_t)0;                                                   /* Clear pointer */     
+ 
+       if(act->machine.curctx->FPUlevel) {                                             /* Is the current level user state? */
+               
+               toss_live_fpu(act->machine.curctx);                                     /* Dump live floats if is not user */
 
 
-       pcb = act->mact.FPU_pcb;                                                                /* Get the top floating point savearea */
-       while(pcb) {                                                                                    /* Any floating point saved state? */
-               opcb = pcb;                                                                                     /* Save current savearea address */
-               pcb = (pcb_t)(((savearea *)pcb)->save_prev_float);      /* Get one underneath our's */          
-               ((savearea *)opcb)->save_flags &= ~SAVfpuvalid;         /* Clear the floating point flag */
+               if(!hw_lock_to((hw_lock_t)&act->machine.curctx->FPUsync, LockTimeOut)) {        /* Get the sync lock */ 
+                       panic("act_machine_sv_free - timeout getting FPU sync lock\n"); /* Tell all and die */
+               }
                
                
-               if(!(((savearea *)opcb)->save_flags & SAVinuse)) {      /* Anyone left with this one? */                        
-                       save_release((savearea *)opcb);                                 /* Nope, release it */
+               fsv = act->machine.curctx->FPUsave;                                     /* Get the top floats savearea */
+               while(fsv && fsv->save_hdr.save_level)  /* Find user context if any */
+                       /* XXX save_prev should be a void * */
+                       fsv = CAST_DOWN(savearea_fpu *, fsv->save_hdr.save_prev);
+               
+               fsvt = act->machine.curctx->FPUsave;                            /* Get the top of the chain */
+               act->machine.curctx->FPUsave = fsv;                                     /* Point to the user context */
+               act->machine.curctx->FPUlevel = NULL;                                   /* Set the level to user */
+               hw_lock_unlock((hw_lock_t)&act->machine.curctx->FPUsync);       /* Unlock */
+               
+               while(fsvt) {                                                                           /* Clear any VMX saved state */
+                       if (fsvt == fsv) break;                                                 /* Done when hit user if any */
+                       fpst = fsvt;                                                                    /* Remember so we can toss this */
+                       /* XXX save_prev should be a void * 4425537 */
+                       fsvt = CAST_DOWN(savearea_fpu *, fsvt->save_hdr.save_prev);     /* Get one underneath our's */          
+                       save_ret((struct savearea *)fpst);                                              /* Release it */
                }
                }
-       }
-       act->mact.FPU_pcb = (pcb_t)0;                                                   /* Clear pointer */     
-
-       pcb = act->mact.pcb;                                                                    /* Get the top normal savearea */
-       act->mact.pcb = (pcb_t)0;                                                               /* Clear pointer */     
-       
-       while(pcb) {                                                                                    /* Any normal saved state left? */
-               opcb = pcb;                                                                                     /* Keep track of what we're working on */
-               pcb = (pcb_t)(((savearea *)pcb)->save_prev);            /* Get one underneath our's */
                
                
-               ((savearea *)opcb)->save_flags = 0;                                     /* Clear all flags since we release this in any case */
-               save_release((savearea *)opcb);                                         /* Release this one */
        }
 
        }
 
-       hw_atomic_sub(&saveanchor.saveneed, 4);                                 /* Unaccount for the number of saveareas we think we "need"
-                                                                                                                          for this activation */
-}
-
-kern_return_t
-act_machine_create(task_t task, thread_act_t thr_act)
-{
-       /*
-        * Clear & Init the pcb  (sets up user-mode s regs)
-        * We don't use this anymore.
-        */
+/*
+ * free all regular saveareas except a user savearea, if any
+ */
 
 
-       register pcb_t pcb;
-       register int i;
-       unsigned int *CIsTooLimited;
-       pmap_t pmap;
+       local_pcb = act->machine.pcb;                                                                   /* Get the general savearea */
+       userpcb = NULL;                                                                                 /* Assume no user context for now */
        
        
-       return KERN_SUCCESS;
-}
-
-void act_machine_init()
-{
-#if    MACH_ASSERT
-    if (watchacts & WA_PCB)
-       printf("act_machine_init()\n");
-#endif /* MACH_ASSERT */
-
-    /* Good to verify these once */
-    assert( THREAD_MACHINE_STATE_MAX <= THREAD_STATE_MAX );
-
-    assert( THREAD_STATE_MAX >= PPC_THREAD_STATE_COUNT );
-    assert( THREAD_STATE_MAX >= PPC_EXCEPTION_STATE_COUNT );
-    assert( THREAD_STATE_MAX >= PPC_FLOAT_STATE_COUNT );
-    assert( THREAD_STATE_MAX >= sizeof(struct ppc_saved_state)/sizeof(int));
+       while(local_pcb) {                                                                                      /* Any float saved state? */
+               if (local_pcb->save_srr1 & MASK(MSR_PR)) {                              /* Is this a user savearea? */
+                       userpcb = local_pcb;                                                                    /* Remember so we can toss this */
+                       break;
+               }
+               svp = local_pcb;                                                                                        /* Remember this */
+               /* XXX save_prev should be a void * 4425537 */
+               local_pcb = CAST_DOWN(struct savearea *, local_pcb->save_hdr.save_prev);  /* Get one underneath our's */ 
+               save_ret(svp);                                                                          /* Release it */
+       }
+       
+       act->machine.pcb = userpcb;                                                             /* Chain in the user if there is one, or 0 if not */
+       (void) ml_set_interrupts_enabled(intr);                                 /* Restore interrupts if enabled */
 
 
-    /*
-     * If we start using kernel activations,
-     * would normally create kernel_thread_pool here,
-     * populating it from the act_zone
-     */
 }
 
 void
 }
 
 void
-act_machine_return(int code)
+machine_act_terminate(
+       thread_t        act)
 {
 {
-    thread_act_t thr_act = current_act();
-
-#if    MACH_ASSERT
-    if (watchacts & WA_EXIT)
-       printf("act_machine_return(0x%x) cur_act=%x(%d) thr=%x(%d)\n",
-              code, thr_act, thr_act->ref_count,
-              thr_act->thread, thr_act->thread->ref_count);
-#endif /* MACH_ASSERT */
-
-
-       /*
-        * This code is called with nothing locked.
-        * It also returns with nothing locked, if it returns.
-        *
-        * This routine terminates the current thread activation.
-        * If this is the only activation associated with its
-        * thread shuttle, then the entire thread (shuttle plus
-        * activation) is terminated.
-        */
-       assert( code == KERN_TERMINATED );
-       assert( thr_act );
-
-       act_lock_thread(thr_act);
-
-#ifdef CALLOUT_RPC_MODEL
-       /*
-        * JMM - This needs to get cleaned up to work under the much simpler
-        * return (instead of callout model).
-        */
-       if (thr_act->thread->top_act != thr_act) {
-               /*
-                * this is not the top activation;
-                * if possible, we should clone the shuttle so that
-                * both the root RPC-chain and the soon-to-be-orphaned
-                * RPC-chain have shuttles
-                *
-                * JMM - Cloning is a horrible idea!  Instead we should alert
-                * the pieces upstream to return the shuttle.  We will use
-                * alerts for this.
-                */
-               act_unlock_thread(thr_act);
-               panic("act_machine_return: ORPHAN CASE NOT YET IMPLEMENTED");
+       if(act->machine.bbDescAddr) {                                                   /* Check if the Blue box assist is active */
+               disable_bluebox_internal(act);                                          /* Kill off bluebox */
        }
        }
-
-       if (thr_act->lower != THR_ACT_NULL) {
-               thread_t        cur_thread = current_thread();
-               thread_act_t    cur_act;
-               struct ipc_port *iplock;
-
-               /* terminate the entire thread (shuttle plus activation) */
-               /* terminate only this activation, send an appropriate   */
-               /* return code back to the activation that invoked us.   */
-               iplock = thr_act->pool_port;    /* remember for unlock call */
-               thr_act->lower->alerts |= SERVER_TERMINATED;
-               install_special_handler(thr_act->lower);
-               
-               /* Return to previous act with error code */
-
-               act_locked_act_reference(thr_act);      /* keep it around */
-               act_switch_swapcheck(cur_thread, (ipc_port_t)0);
-
-               (void) switch_act(THR_ACT_NULL);
-               /* assert(thr_act->ref_count == 0); */          /* XXX */
-               cur_act = cur_thread->top_act;
-               MACH_RPC_RET(cur_act) = KERN_RPC_SERVER_TERMINATED;         
-               machine_kernel_stack_init(cur_thread, mach_rpc_return_error);
-               /*
-                * The following unlocks must be done separately since fields 
-                * used by `act_unlock_thread()' have been cleared, meaning
-                * that it would not release all of the appropriate locks.
-                */
-               rpc_unlock(cur_thread);
-               if (iplock) ip_unlock(iplock);  /* must be done separately */
-               act_unlock(thr_act);
-               act_deallocate(thr_act);                /* free it */
-               Load_context(cur_thread);
-               /*NOTREACHED*/
-               
-               panic("act_machine_return: TALKING ZOMBIE! (2)");
+       
+       if(act->machine.vmmControl) {                                                   /* Check if VMM is active */
+               vmm_tear_down_all(act);                                                         /* Kill off all VMM contexts */
        }
        }
-
-#endif /* CALLOUT_RPC_MODEL */
-
-       /* This is the only activation attached to the shuttle... */
-
-       assert(thr_act->thread->top_act == thr_act);
-       act_unlock_thread(thr_act);
-       thread_terminate_self();
-
-       /*NOTREACHED*/
-       panic("act_machine_return: TALKING ZOMBIE! (1)");
 }
 
 void
 }
 
 void
-thread_machine_set_current(struct thread_shuttle *thread)
+machine_thread_terminate_self(void)
 {
 {
-    register int       my_cpu = cpu_number();
-
-    cpu_data[my_cpu].active_thread = thread;
-       
-    active_kloaded[my_cpu] = thread->top_act->kernel_loaded ? thread->top_act : THR_ACT_NULL;
+       machine_act_terminate(current_thread());
 }
 
 void
 }
 
 void
-thread_machine_init(void)
+machine_thread_init(void)
 {
 #ifdef MACHINE_STACK
 #if KERNEL_STACK_SIZE > PPC_PGBYTES
 {
 #ifdef MACHINE_STACK
 #if KERNEL_STACK_SIZE > PPC_PGBYTES
@@ -747,49 +475,17 @@ thread_machine_init(void)
 }
 
 #if MACH_ASSERT
 }
 
 #if MACH_ASSERT
-void
-dump_pcb(pcb_t pcb)
-{
-       printf("pcb @ %8.8x:\n", pcb);
-#if DEBUG
-       regDump(&pcb->ss);
-#endif /* DEBUG */
-}
-
 void
 dump_thread(thread_t th)
 {
 void
 dump_thread(thread_t th)
 {
-       printf(" thread @ 0x%x:\n", th);
+       printf(" thread @ %p:\n", th);
 }
 }
+#endif /* MACH_ASSERT */
 
 
-int
-    dump_act(thread_act_t thr_act)
+user_addr_t 
+get_useraddr(void)
 {
 {
-    if (!thr_act)
-       return(0);
-
-    printf("thr_act(0x%x)(%d): thread=%x(%d) task=%x(%d)\n",
-          thr_act, thr_act->ref_count,
-          thr_act->thread, thr_act->thread ? thr_act->thread->ref_count:0,
-          thr_act->task,   thr_act->task   ? thr_act->task->ref_count : 0);
-
-    printf("\talerts=%x mask=%x susp=%x active=%x hi=%x lo=%x\n",
-          thr_act->alerts, thr_act->alert_mask,
-          thr_act->suspend_count, thr_act->active,
-          thr_act->higher, thr_act->lower);
-
-    return((int)thr_act);
-}
-
-#endif
-
-unsigned int 
-get_useraddr()
-{
-
-       thread_act_t thr_act = current_act();
-
-       return(thr_act->mact.pcb->ss.srr0);
+       return(current_thread()->machine.upcb->save_srr0);
 }
 
 /*
 }
 
 /*
@@ -797,14 +493,16 @@ get_useraddr()
  */
 
 vm_offset_t
  */
 
 vm_offset_t
-stack_detach(thread_t thread)
+machine_stack_detach(
+       thread_t                thread)
 {
   vm_offset_t stack;
 
 {
   vm_offset_t stack;
 
-               KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_DETACH),
-                       thread, thread->priority,
-                       thread->sched_pri, 0,
-                       0);
+  KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_DETACH),
+                                                                                       thread, thread->priority,
+                                                                                       thread->sched_pri, 0, 0);
+
+  act_machine_sv_free(thread, 0);      /* XXX flag == 0 OK? */
 
   stack = thread->kernel_stack;
   thread->kernel_stack = 0;
 
   stack = thread->kernel_stack;
   thread->kernel_stack = 0;
@@ -824,18 +522,16 @@ stack_detach(thread_t thread)
  */
 
 void
  */
 
 void
-stack_attach(struct thread_shuttle *thread,
-            vm_offset_t stack,
-            void (*start_pos)(thread_t))
+machine_stack_attach(
+       thread_t                thread,
+       vm_offset_t             stack)
 {
 {
-  thread_act_t thr_act;
   unsigned int *kss;
   struct savearea *sv;
 
         KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_ATTACH),
             thread, thread->priority,
   unsigned int *kss;
   struct savearea *sv;
 
         KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_ATTACH),
             thread, thread->priority,
-            thread->sched_pri, start_pos,
-            0);
+            thread->sched_pri, 0, 0);
 
   assert(stack);
   kss = (unsigned int *)STACK_IKS(stack);
 
   assert(stack);
   kss = (unsigned int *)STACK_IKS(stack);
@@ -843,24 +539,22 @@ stack_attach(struct thread_shuttle *thread,
 
   /* during initialization we sometimes do not have an
      activation. in that case do not do anything */
 
   /* during initialization we sometimes do not have an
      activation. in that case do not do anything */
-  if ((thr_act = thread->top_act) != 0) {
-    sv = save_get();  /* cannot block */
-    //    bzero((char *) sv, sizeof(struct pcb));
-    sv->save_act = thr_act;
-       sv->save_prev = (struct savearea *)thr_act->mact.pcb;
-    thr_act->mact.pcb = (pcb_t)sv;
-
-    sv->save_srr0 = (unsigned int) start_pos;
-    /* sv->save_r3 = ARG ? */
-    sv->save_r1 = (vm_offset_t)((int)kss - KF_SIZE);
-       sv->save_srr1 = MSR_SUPERVISOR_INT_OFF;
-       sv->save_xfpscrpad = 0;                                         /* Start with a clear fpscr */
-       sv->save_xfpscr = 0;                                            /* Start with a clear fpscr */
-    *((int *)sv->save_r1) = 0;
-    thr_act->mact.ksp = 0;                           
-  }
-
-  return;
+  sv = save_get();  /* cannot block */
+  sv->save_hdr.save_flags = (sv->save_hdr.save_flags & ~SAVtype) | (SAVgeneral << SAVtypeshft);        /* Mark as in use */
+  sv->save_hdr.save_act = thread;
+  sv->save_hdr.save_prev = (addr64_t)((uintptr_t)thread->machine.pcb);
+  thread->machine.pcb = sv;
+
+  sv->save_srr0 = (unsigned int)thread_continue;
+  /* sv->save_r3 = ARG ? */
+  sv->save_r1 = (vm_offset_t)((int)kss - KF_SIZE);
+  sv->save_srr1 = MSR_SUPERVISOR_INT_OFF;
+  sv->save_fpscr = 0;                                                                  /* Clear all floating point exceptions */
+  sv->save_vrsave = 0;                                                         /* Set the vector save state */
+  sv->save_vscr[3] = 0x00010000;                                               /* Supress java mode */
+  *(CAST_DOWN(int *, sv->save_r1)) = 0;
+
+  thread->machine.ksp = 0;                           
 }
 
 /*
 }
 
 /*
@@ -868,93 +562,111 @@ stack_attach(struct thread_shuttle *thread,
  */
 
 void
  */
 
 void
-stack_handoff(thread_t old,
-             thread_t new)
+machine_stack_handoff(
+       thread_t                old,
+       thread_t                new)
 {
 
 {
 
-  vm_offset_t stack;
-  pmap_t new_pmap;
-
-  assert(new->top_act);
-  assert(old->top_act);
-
-  stack = stack_detach(old);
-  new->kernel_stack = stack;
-
-  per_proc_info[cpu_number()].cpu_flags &= ~traceBE;
+       vm_offset_t stack;
+       pmap_t new_pmap;
+       facility_context *fowner;
+       mapping_t *mp;
+       struct per_proc_info *ppinfo;
+       
+       assert(new);
+       assert(old);
 
 
-#if NCPUS > 1
-  if (real_ncpus > 1) {
-       fpu_save(old->top_act);
-       vec_save(old->top_act);
-  }
-#endif
+       if (old == new)
+               panic("machine_stack_handoff");
+       
+       stack = machine_stack_detach(old);
+       new->kernel_stack = stack;
+       if (stack == old->reserved_stack) {
+               assert(new->reserved_stack);
+               old->reserved_stack = new->reserved_stack;
+               new->reserved_stack = stack;
+       }
 
 
-  KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_HANDOFF) | DBG_FUNC_NONE,
-                    (int)old, (int)new, old->sched_pri, new->sched_pri, 0);
+       ppinfo = getPerProc();                                                          /* Get our processor block */
 
 
+       if(real_ncpus > 1) {                                                            /* This is potentially slow, so only do when actually SMP */
+               fowner = ppinfo->FPU_owner;                                             /* Cache this because it may change */
+               if(fowner) {                                                                    /* Is there any live context? */
+                       if(fowner->facAct == old) {             /* Is it for us? */
+                               fpu_save(fowner);                                               /* Yes, save it */
+                       }
+               }
+               fowner = ppinfo->VMX_owner;                                             /* Cache this because it may change */
+               if(fowner) {                                                                    /* Is there any live context? */
+                       if(fowner->facAct == old) {             /* Is it for us? */
+                               vec_save(fowner);                                               /* Yes, save it */
+                       }
+               }
+       }
 
 
-       if(new->top_act->mact.specFlags & runningVM) {  /* Is the new guy running a VM? */
-               pmap_switch(new->top_act->mact.vmmCEntry->vmmPmap);     /* Switch to the VM's pmap */
+       /*
+        * If old thread is running VM, save per proc userProtKey and FamVMmode spcFlags bits in the thread spcFlags
+        * This bits can be modified in the per proc without updating the thread spcFlags
+        */
+       if(old->machine.specFlags & runningVM) {                        /* Is the current thread running a VM? */
+               old->machine.specFlags &= ~(userProtKey|FamVMmode);
+               old->machine.specFlags |= (ppinfo->spcFlags) & (userProtKey|FamVMmode);
+       }
+       old->machine.specFlags &= ~OnProc;
+       new->machine.specFlags |= OnProc;
+
+       if(new->machine.specFlags & runningVM) {        /* Is the new guy running a VM? */
+               pmap_switch(new->machine.vmmCEntry->vmmPmap);   /* Switch to the VM's pmap */
+               ppinfo->VMMareaPhys = new->machine.vmmCEntry->vmmContextPhys;
+               ppinfo->VMMXAFlgs = new->machine.vmmCEntry->vmmXAFlgs;
+               ppinfo->FAMintercept = new->machine.vmmCEntry->vmmFAMintercept;
        }
        else {                                                                                  /* otherwise, we use the task's pmap */
        }
        else {                                                                                  /* otherwise, we use the task's pmap */
-               new_pmap = new->top_act->task->map->pmap;
-               if ((old->top_act->task->map->pmap != new_pmap) || (old->top_act->mact.specFlags & runningVM)) {
+               new_pmap = new->task->map->pmap;
+               if ((old->task->map->pmap != new_pmap) || (old->machine.specFlags & runningVM)) {
                        pmap_switch(new_pmap);
                }
        }
 
                        pmap_switch(new_pmap);
                }
        }
 
-  thread_machine_set_current(new);
-  active_stacks[cpu_number()] = new->kernel_stack;
-  per_proc_info[cpu_number()].Uassist = new->top_act->mact.cthread_self;
-#if 1
-  per_proc_info[cpu_number()].ppbbTaskEnv = new->top_act->mact.bbTaskEnv;
-  per_proc_info[cpu_number()].spcFlags = new->top_act->mact.specFlags;
-#endif
-  if (branch_tracing_enabled()) 
-    per_proc_info[cpu_number()].cpu_flags |= traceBE;
-    
-  if(trcWork.traceMask) dbgTrace(0x12345678, (unsigned int)old->top_act, (unsigned int)new->top_act);  /* Cut trace entry if tracing */    
+       machine_set_current_thread(new);
+       ppinfo->Uassist = new->machine.cthread_self;
+
+       ppinfo->ppbbTaskEnv = new->machine.bbTaskEnv;
+       ppinfo->spcFlags = new->machine.specFlags;
+       
+       old->machine.umwSpace |= umwSwitchAway;                 /* Show we switched away from this guy */
+       mp = (mapping_t *)&ppinfo->ppUMWmp;
+       mp->mpSpace = invalSpace;                                               /* Since we can't handoff in the middle of copy in/out, just invalidate */
+
+       if(trcWork.traceMask) dbgTrace(0x9903, (unsigned int)old, (unsigned int)new, 0, 0);     /* Cut trace entry if tracing */    
     
   return;
 }
 
     
   return;
 }
 
+void Call_continuation(thread_continue_t, void *, wait_result_t, vm_offset_t);
+
 /*
  * clean and initialize the current kernel stack and go to
  * the given continuation routine
  */
 
 void
 /*
  * clean and initialize the current kernel stack and go to
  * the given continuation routine
  */
 
 void
-call_continuation(void (*continuation)(void) )
-{
-
-  unsigned int *kss;
-  vm_offset_t tsp;
-
-  assert(current_thread()->kernel_stack);
-  kss = (unsigned int *)STACK_IKS(current_thread()->kernel_stack);
-  assert(continuation);
-
-  tsp = (vm_offset_t)((int)kss - KF_SIZE);
-  assert(tsp);
-  *((int *)tsp) = 0;
-
-  Call_continuation(continuation, tsp);
-  
-  return;
-}
-
-void
-thread_swapin_mach_alloc(thread_t thread)
+call_continuation(
+       thread_continue_t       continuation,
+       void                            *parameter,
+       wait_result_t           wresult)
 {
 {
-    struct savearea *sv;
+       thread_t                self = current_thread();
+       unsigned int    *kss;
+       vm_offset_t             tsp;
 
 
-       assert(thread->top_act->mact.pcb == 0);
+       assert(self->kernel_stack);
+       kss = (unsigned int *)STACK_IKS(self->kernel_stack);
+       assert(continuation);
 
 
-    sv = save_alloc();
-       assert(sv);
-       //    bzero((char *) sv, sizeof(struct pcb));
-    sv->save_act = thread->top_act;
-    thread->top_act->mact.pcb = (pcb_t)sv;
+       tsp = (vm_offset_t)((int)kss - KF_SIZE);
+       assert(tsp);
+       *((int *)tsp) = 0;
 
 
+       Call_continuation(continuation, parameter, wresult, tsp);
 }
 }
mirror of XNU