X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/765c9de3b4af7c2078d16a03812ae2c7c2b24938..4a3eedf9ecc9bbe3f3a5c6ce5e53ad199d639d32:/osfmk/ppc/pcb.c?ds=inline diff --git a/osfmk/ppc/pcb.c b/osfmk/ppc/pcb.c index 475c97637..38569fc94 100644 --- 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, - * 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@ @@ -44,38 +50,44 @@ * Utah $Hdr: pcb.c 1.23 92/06/27$ */ -#include #include #include + +#include +#include + +#include #include #include -#include -#include -#include -#include +#include #include +#include +#include + +#include +#include +#include -#include #include -#include +#include #include #include -#include #include #include #include #include #include #include -#include +#include #include #include +#include +#include #include -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! @@ -90,156 +102,104 @@ int vec_trap_count = 0; 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() +consider_machine_collect(void) { /* - * none currently available + * XXX none currently available */ - return; } void -consider_machine_adjust() +consider_machine_adjust(void) { 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 * */ -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; -#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 */ - 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 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. */ - 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 */ - 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 */ } } - /* 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); - 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. @@ -248,60 +208,33 @@ switch_context( 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 -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 */ - 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 */ - 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. @@ -309,14 +242,16 @@ thread_machine_create( * 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); } @@ -324,420 +259,213 @@ thread_machine_create( * 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 - * 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 * - * 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 -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 -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 -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 -thread_machine_init(void) +machine_thread_init(void) { #ifdef MACHINE_STACK #if KERNEL_STACK_SIZE > PPC_PGBYTES @@ -747,49 +475,17 @@ thread_machine_init(void) } #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) { - 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 -stack_detach(thread_t thread) +machine_stack_detach( + thread_t thread) { 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; @@ -824,18 +522,16 @@ stack_detach(thread_t thread) */ 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, - thread->sched_pri, start_pos, - 0); + thread->sched_pri, 0, 0); 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 */ - 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 -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 */ - 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); } } - 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; } +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 -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); }