/* * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * * 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. * * 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, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. * * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* * @OSF_COPYRIGHT@ * */ #include #include #include #include #include #include #include #include #include #include #include typedef unsigned int fixpt_t; /* XXX not self contained */ #include /* USRSTACK, etc. */ #include extern unsigned int killprint; extern double FloatInit; extern unsigned long QNaNbarbarian[4]; kern_return_t thread_userstack( thread_t, int, thread_state_t, unsigned int, mach_vm_offset_t *, int * ); kern_return_t thread_entrypoint( thread_t, int, thread_state_t, unsigned int, mach_vm_offset_t * ); unsigned int get_msr_exportmask(void); unsigned int get_msr_nbits(void); unsigned int get_msr_rbits(void); void ppc_checkthreadstate(void *, int); void thread_set_child(thread_t child, int pid); void thread_set_parent(thread_t parent, int pid); void thread_set_cthreadself(thread_t thread, uint64_t pself, int isLP64); /* * Maps state flavor to number of words in the state: */ /* __private_extern__ */ unsigned int _MachineStateCount[] = { /* FLAVOR_LIST */ 0, PPC_THREAD_STATE_COUNT, PPC_FLOAT_STATE_COUNT, PPC_EXCEPTION_STATE_COUNT, PPC_VECTOR_STATE_COUNT, PPC_THREAD_STATE64_COUNT, PPC_EXCEPTION_STATE64_COUNT, }; /* * thread_getstatus: * * Get the status of the specified thread. */ kern_return_t machine_thread_get_state( thread_t thread, thread_flavor_t flavor, thread_state_t tstate, mach_msg_type_number_t *count) { register struct savearea *sv; /* Pointer to the context savearea */ register savearea_fpu *fsv; register savearea_vec *vsv; struct savearea *genuser; int i, j; unsigned int vrvalidwrk; register struct ppc_thread_state *ts; register struct ppc_thread_state64 *xts; register struct ppc_exception_state *es; register struct ppc_exception_state64 *xes; register struct ppc_float_state *fs; register struct ppc_vector_state *vs; genuser = find_user_regs(thread); switch (flavor) { case THREAD_STATE_FLAVOR_LIST: if (*count < 6) { return (KERN_INVALID_ARGUMENT); } tstate[0] = PPC_THREAD_STATE; tstate[1] = PPC_FLOAT_STATE; tstate[2] = PPC_EXCEPTION_STATE; tstate[3] = PPC_VECTOR_STATE; tstate[4] = PPC_THREAD_STATE64; tstate[5] = PPC_EXCEPTION_STATE64; *count = 6; return KERN_SUCCESS; case PPC_THREAD_STATE: if (*count < PPC_THREAD_STATE_COUNT) { /* Is the count ok? */ return KERN_INVALID_ARGUMENT; } ts = (struct ppc_thread_state *) tstate; sv = genuser; /* Copy this over */ if(sv) { /* Is there a save area yet? */ ts->r0 = (unsigned int)sv->save_r0; ts->r1 = (unsigned int)sv->save_r1; ts->r2 = (unsigned int)sv->save_r2; ts->r3 = (unsigned int)sv->save_r3; ts->r4 = (unsigned int)sv->save_r4; ts->r5 = (unsigned int)sv->save_r5; ts->r6 = (unsigned int)sv->save_r6; ts->r7 = (unsigned int)sv->save_r7; ts->r8 = (unsigned int)sv->save_r8; ts->r9 = (unsigned int)sv->save_r9; ts->r10 = (unsigned int)sv->save_r10; ts->r11 = (unsigned int)sv->save_r11; ts->r12 = (unsigned int)sv->save_r12; ts->r13 = (unsigned int)sv->save_r13; ts->r14 = (unsigned int)sv->save_r14; ts->r15 = (unsigned int)sv->save_r15; ts->r16 = (unsigned int)sv->save_r16; ts->r17 = (unsigned int)sv->save_r17; ts->r18 = (unsigned int)sv->save_r18; ts->r19 = (unsigned int)sv->save_r19; ts->r20 = (unsigned int)sv->save_r20; ts->r21 = (unsigned int)sv->save_r21; ts->r22 = (unsigned int)sv->save_r22; ts->r23 = (unsigned int)sv->save_r23; ts->r24 = (unsigned int)sv->save_r24; ts->r25 = (unsigned int)sv->save_r25; ts->r26 = (unsigned int)sv->save_r26; ts->r27 = (unsigned int)sv->save_r27; ts->r28 = (unsigned int)sv->save_r28; ts->r29 = (unsigned int)sv->save_r29; ts->r30 = (unsigned int)sv->save_r30; ts->r31 = (unsigned int)sv->save_r31; ts->cr = (unsigned int)sv->save_cr; ts->xer = (unsigned int)sv->save_xer; ts->lr = (unsigned int)sv->save_lr; ts->ctr = (unsigned int)sv->save_ctr; ts->srr0 = (unsigned int)sv->save_srr0; ts->srr1 = (unsigned int)sv->save_srr1; ts->mq = 0; /* MQ register (601 only) */ ts->vrsave = (unsigned int)sv->save_vrsave; /* VRSAVE register (Altivec only) */ } else { /* No user state yet. Save seemingly random values. */ for(i=0; i < 32; i+=2) { /* Fill up with defaults */ ((unsigned int *)&ts->r0)[i] = ((unsigned int *)&FloatInit)[0]; ((unsigned int *)&ts->r0)[i+1] = ((unsigned int *)&FloatInit)[1]; } ts->cr = 0; ts->xer = 0; ts->lr = ((unsigned int *)&FloatInit)[0]; ts->ctr = ((unsigned int *)&FloatInit)[1]; ts->srr0 = ((unsigned int *)&FloatInit)[0]; ts->srr1 = MSR_EXPORT_MASK_SET; ts->mq = 0; ts->vrsave = 0; /* VRSAVE register (Altivec only) */ } *count = PPC_THREAD_STATE_COUNT; /* Pass back the amount we actually copied */ return KERN_SUCCESS; case PPC_THREAD_STATE64: if (*count < PPC_THREAD_STATE64_COUNT) { /* Is the count ok? */ return KERN_INVALID_ARGUMENT; } xts = (struct ppc_thread_state64 *) tstate; sv = genuser; /* Copy this over */ if(sv) { /* Is there a save area yet? */ xts->r0 = sv->save_r0; xts->r1 = sv->save_r1; xts->r2 = sv->save_r2; xts->r3 = sv->save_r3; xts->r4 = sv->save_r4; xts->r5 = sv->save_r5; xts->r6 = sv->save_r6; xts->r7 = sv->save_r7; xts->r8 = sv->save_r8; xts->r9 = sv->save_r9; xts->r10 = sv->save_r10; xts->r11 = sv->save_r11; xts->r12 = sv->save_r12; xts->r13 = sv->save_r13; xts->r14 = sv->save_r14; xts->r15 = sv->save_r15; xts->r16 = sv->save_r16; xts->r17 = sv->save_r17; xts->r18 = sv->save_r18; xts->r19 = sv->save_r19; xts->r20 = sv->save_r20; xts->r21 = sv->save_r21; xts->r22 = sv->save_r22; xts->r23 = sv->save_r23; xts->r24 = sv->save_r24; xts->r25 = sv->save_r25; xts->r26 = sv->save_r26; xts->r27 = sv->save_r27; xts->r28 = sv->save_r28; xts->r29 = sv->save_r29; xts->r30 = sv->save_r30; xts->r31 = sv->save_r31; xts->cr = sv->save_cr; xts->xer = sv->save_xer; xts->lr = sv->save_lr; xts->ctr = sv->save_ctr; xts->srr0 = sv->save_srr0; xts->srr1 = sv->save_srr1; xts->vrsave = sv->save_vrsave; /* VRSAVE register (Altivec only) */ } else { /* No user state yet. Save seemingly random values. */ for(i=0; i < 32; i++) { /* Fill up with defaults */ ((unsigned long long *)&xts->r0)[i] = ((unsigned long long *)&FloatInit)[0]; } xts->cr = 0; xts->xer = 0; xts->lr = ((unsigned long long *)&FloatInit)[0]; xts->ctr = ((unsigned long long *)&FloatInit)[0]; xts->srr0 = ((unsigned long long *)&FloatInit)[0]; xts->srr1 = MSR_EXPORT_MASK_SET; if(task_has_64BitAddr(thread->task)) xts->srr1 |= (uint64_t)MASK32(MSR_SF) << 32; /* If 64-bit task, force 64-bit mode */ xts->vrsave = 0; /* VRSAVE register (Altivec only) */ } *count = PPC_THREAD_STATE64_COUNT; /* Pass back the amount we actually copied */ return KERN_SUCCESS; case PPC_EXCEPTION_STATE: if (*count < PPC_EXCEPTION_STATE_COUNT) { return KERN_INVALID_ARGUMENT; } es = (struct ppc_exception_state *) tstate; sv = genuser; /* Copy this over */ if(sv) { /* See if valid state yet */ es->dar = (unsigned int)sv->save_dar; es->dsisr = sv->save_dsisr; es->exception = sv->save_exception; } else { /* Nope, not yet */ es->dar = 0; es->dsisr = 0; es->exception = ((unsigned int *)&FloatInit)[0]; } *count = PPC_EXCEPTION_STATE_COUNT; return KERN_SUCCESS; case PPC_EXCEPTION_STATE64: if (*count < PPC_EXCEPTION_STATE64_COUNT) { return KERN_INVALID_ARGUMENT; } xes = (struct ppc_exception_state64 *) tstate; sv = genuser; /* Copy this over */ if(sv) { /* See if valid state yet */ xes->dar = sv->save_dar; xes->dsisr = sv->save_dsisr; xes->exception = sv->save_exception; } else { /* Nope, not yet */ xes->dar = 0; xes->dsisr = 0; xes->exception = ((unsigned int *)&FloatInit)[0]; } *count = PPC_EXCEPTION_STATE64_COUNT; return KERN_SUCCESS; case PPC_FLOAT_STATE: if (*count < PPC_FLOAT_STATE_COUNT) { return KERN_INVALID_ARGUMENT; } fpu_save(thread->machine.curctx); /* Just in case it's live, save it */ fs = (struct ppc_float_state *) tstate; /* Point to destination */ fsv = find_user_fpu(thread); /* Get the user's fpu savearea */ if(fsv) { /* See if we have any */ bcopy((char *)&fsv->save_fp0, (char *)fs, 32*8); /* 32 registers */ fs->fpscr_pad = 0; /* Be clean and tidy */ if(genuser) fs->fpscr = genuser->save_fpscr; /* Set the fpscr value to general */ else fs->fpscr = 0; /* If no user, initialize this */ } else { /* No floating point yet */ for(i=0; i < 32; i++) { /* Initialize floating points */ fs->fpregs[i] = FloatInit; /* Initial value */ } fs->fpscr_pad = 0; /* Initial value */ fs->fpscr = 0; /* Initial value */ } *count = PPC_FLOAT_STATE_COUNT; return KERN_SUCCESS; case PPC_VECTOR_STATE: if (*count < PPC_VECTOR_STATE_COUNT) { return KERN_INVALID_ARGUMENT; } vec_save(thread->machine.curctx); /* Just in case it's live, save it */ vs = (struct ppc_vector_state *) tstate; /* Point to destination */ vsv = find_user_vec(thread); /* Find the vector savearea */ if(vsv) { /* See if we have any */ vrvalidwrk = vsv->save_vrvalid; /* Get the valid flags */ vs->save_vrvalid = vsv->save_vrvalid; /* Set the valid flags */ if(genuser) for(j=0; j < 4; j++) vs->save_vscr[j] = genuser->save_vscr[j]; /* Set value for vscr */ else { vs->save_vscr[0] = 0; /* Set an initial value if no general user yet */ vs->save_vscr[1] = 0; vs->save_vscr[2] = 0; vs->save_vscr[3] = 0x00010000; /* Always start with Java mode off */ } for(i=0; i < 32; i++) { /* Copy the saved registers and invalidate the others */ for(j=0; j < 4; j++) { if(vrvalidwrk & 0x80000000) (vs->save_vr)[i][j] = ((unsigned int *)&(vsv->save_vr0))[(i * 4) + j]; /* We have this register saved */ else vs->save_vr[i][j] = QNaNbarbarian[j]; /* Set invalid value */ } vrvalidwrk = vrvalidwrk << 1; /* Shift over to the next */ } } else { /* No vector yet */ for(i=0; i < 32; i++) { /* Initialize vector registers */ for(j=0; j < 4; j++) vs->save_vr[i][j] = QNaNbarbarian[j]; /* Initial value */ } if(genuser) for(j=0; j < 4; j++) vs->save_vscr[j] = genuser->save_vscr[j]; /* Set value for vscr */ else { vs->save_vscr[0] = 0; /* Set an initial value if no general user yet */ vs->save_vscr[1] = 0; vs->save_vscr[2] = 0; vs->save_vscr[3] = 0x00010000; /* Always start with Java mode off */ } vs->save_vrvalid = 0; /* Clear the valid flags */ } for (i=0; i < 4; i++) vs->save_pad5[i] = 0; /* Clear cruft */ for (i=0; i < 7; i++) vs->save_pad6[i] = 0; /* Clear cruft */ *count = PPC_VECTOR_STATE_COUNT; return KERN_SUCCESS; default: return KERN_INVALID_ARGUMENT; } } /* Close cousin of machine_thread_get_state(). * This function is currently incomplete since we don't really need vector * or FP for the core dump (the save area can be accessed directly if the * user is so inclined). Also the function name is something of a misnomer, * see the comment above find_kern_regs(). */ kern_return_t machine_thread_get_kern_state( thread_t thread, thread_flavor_t flavor, thread_state_t tstate, mach_msg_type_number_t *count) { register struct savearea *sv; /* Pointer to the context savearea */ struct savearea *genkern; int i; register struct ppc_thread_state *ts; register struct ppc_thread_state64 *xts; register struct ppc_exception_state *es; register struct ppc_exception_state64 *xes; genkern = find_kern_regs(thread); switch (flavor) { case THREAD_STATE_FLAVOR_LIST: if (*count < 6) { return (KERN_INVALID_ARGUMENT); } tstate[0] = PPC_THREAD_STATE; tstate[1] = PPC_FLOAT_STATE; tstate[2] = PPC_EXCEPTION_STATE; tstate[3] = PPC_VECTOR_STATE; tstate[4] = PPC_THREAD_STATE64; tstate[5] = PPC_EXCEPTION_STATE64; *count = 6; return KERN_SUCCESS; case PPC_THREAD_STATE: if (*count < PPC_THREAD_STATE_COUNT) { /* Is the count ok? */ return KERN_INVALID_ARGUMENT; } ts = (struct ppc_thread_state *) tstate; sv = genkern; /* Copy this over */ if(sv) { /* Is there a save area yet? */ ts->r0 = (unsigned int)sv->save_r0; ts->r1 = (unsigned int)sv->save_r1; ts->r2 = (unsigned int)sv->save_r2; ts->r3 = (unsigned int)sv->save_r3; ts->r4 = (unsigned int)sv->save_r4; ts->r5 = (unsigned int)sv->save_r5; ts->r6 = (unsigned int)sv->save_r6; ts->r7 = (unsigned int)sv->save_r7; ts->r8 = (unsigned int)sv->save_r8; ts->r9 = (unsigned int)sv->save_r9; ts->r10 = (unsigned int)sv->save_r10; ts->r11 = (unsigned int)sv->save_r11; ts->r12 = (unsigned int)sv->save_r12; ts->r13 = (unsigned int)sv->save_r13; ts->r14 = (unsigned int)sv->save_r14; ts->r15 = (unsigned int)sv->save_r15; ts->r16 = (unsigned int)sv->save_r16; ts->r17 = (unsigned int)sv->save_r17; ts->r18 = (unsigned int)sv->save_r18; ts->r19 = (unsigned int)sv->save_r19; ts->r20 = (unsigned int)sv->save_r20; ts->r21 = (unsigned int)sv->save_r21; ts->r22 = (unsigned int)sv->save_r22; ts->r23 = (unsigned int)sv->save_r23; ts->r24 = (unsigned int)sv->save_r24; ts->r25 = (unsigned int)sv->save_r25; ts->r26 = (unsigned int)sv->save_r26; ts->r27 = (unsigned int)sv->save_r27; ts->r28 = (unsigned int)sv->save_r28; ts->r29 = (unsigned int)sv->save_r29; ts->r30 = (unsigned int)sv->save_r30; ts->r31 = (unsigned int)sv->save_r31; ts->cr = (unsigned int)sv->save_cr; ts->xer = (unsigned int)sv->save_xer; ts->lr = (unsigned int)sv->save_lr; ts->ctr = (unsigned int)sv->save_ctr; ts->srr0 = (unsigned int)sv->save_srr0; ts->srr1 = (unsigned int)sv->save_srr1; ts->mq = 0; /* MQ register (601 only) */ ts->vrsave = (unsigned int)sv->save_vrsave; /* VRSAVE register (Altivec only) */ } else { /* No state yet. Save seemingly random values. */ for(i=0; i < 32; i+=2) { /* Fill up with defaults */ ((unsigned int *)&ts->r0)[i] = ((unsigned int *)&FloatInit)[0]; ((unsigned int *)&ts->r0)[i+1] = ((unsigned int *)&FloatInit)[1]; } ts->cr = 0; ts->xer = 0; ts->lr = ((unsigned int *)&FloatInit)[0]; ts->ctr = ((unsigned int *)&FloatInit)[1]; ts->srr0 = ((unsigned int *)&FloatInit)[0]; ts->srr1 = MSR_EXPORT_MASK_SET; ts->mq = 0; ts->vrsave = 0; /* VRSAVE register (Altivec only) */ } *count = PPC_THREAD_STATE_COUNT; /* Pass back the amount we actually copied */ return KERN_SUCCESS; case PPC_THREAD_STATE64: if (*count < PPC_THREAD_STATE64_COUNT) { /* Is the count ok? */ return KERN_INVALID_ARGUMENT; } xts = (struct ppc_thread_state64 *) tstate; sv = genkern; /* Copy this over */ if(sv) { /* Is there a save area yet? */ xts->r0 = sv->save_r0; xts->r1 = sv->save_r1; xts->r2 = sv->save_r2; xts->r3 = sv->save_r3; xts->r4 = sv->save_r4; xts->r5 = sv->save_r5; xts->r6 = sv->save_r6; xts->r7 = sv->save_r7; xts->r8 = sv->save_r8; xts->r9 = sv->save_r9; xts->r10 = sv->save_r10; xts->r11 = sv->save_r11; xts->r12 = sv->save_r12; xts->r13 = sv->save_r13; xts->r14 = sv->save_r14; xts->r15 = sv->save_r15; xts->r16 = sv->save_r16; xts->r17 = sv->save_r17; xts->r18 = sv->save_r18; xts->r19 = sv->save_r19; xts->r20 = sv->save_r20; xts->r21 = sv->save_r21; xts->r22 = sv->save_r22; xts->r23 = sv->save_r23; xts->r24 = sv->save_r24; xts->r25 = sv->save_r25; xts->r26 = sv->save_r26; xts->r27 = sv->save_r27; xts->r28 = sv->save_r28; xts->r29 = sv->save_r29; xts->r30 = sv->save_r30; xts->r31 = sv->save_r31; xts->cr = sv->save_cr; xts->xer = sv->save_xer; xts->lr = sv->save_lr; xts->ctr = sv->save_ctr; xts->srr0 = sv->save_srr0; xts->srr1 = sv->save_srr1; xts->vrsave = sv->save_vrsave; /* VRSAVE register (Altivec only) */ } else { /* No user state yet. Save seemingly random values. */ for(i=0; i < 32; i++) { /* Fill up with defaults */ ((unsigned long long *)&xts->r0)[i] = ((unsigned long long *)&FloatInit)[0]; } xts->cr = 0; xts->xer = 0; xts->lr = ((unsigned long long *)&FloatInit)[0]; xts->ctr = ((unsigned long long *)&FloatInit)[0]; xts->srr0 = ((unsigned long long *)&FloatInit)[0]; xts->srr1 = MSR_EXPORT_MASK_SET; xts->vrsave = 0; /* VRSAVE register (Altivec only) */ } *count = PPC_THREAD_STATE64_COUNT; /* Pass back the amount we actually copied */ return KERN_SUCCESS; case PPC_EXCEPTION_STATE: if (*count < PPC_EXCEPTION_STATE_COUNT) { return KERN_INVALID_ARGUMENT; } es = (struct ppc_exception_state *) tstate; sv = genkern; /* Copy this over */ if(sv) { /* See if valid state yet */ es->dar = (unsigned int)sv->save_dar; es->dsisr = sv->save_dsisr; es->exception = sv->save_exception; } else { /* Nope, not yet */ es->dar = 0; es->dsisr = 0; es->exception = ((unsigned int *)&FloatInit)[0]; } *count = PPC_EXCEPTION_STATE_COUNT; return KERN_SUCCESS; case PPC_EXCEPTION_STATE64: if (*count < PPC_EXCEPTION_STATE64_COUNT) { return KERN_INVALID_ARGUMENT; } xes = (struct ppc_exception_state64 *) tstate; sv = genkern; /* Copy this over */ if(sv) { /* See if valid state yet */ xes->dar = sv->save_dar; xes->dsisr = sv->save_dsisr; xes->exception = sv->save_exception; } else { /* Nope, not yet */ xes->dar = 0; xes->dsisr = 0; xes->exception = ((unsigned int *)&FloatInit)[0]; } *count = PPC_EXCEPTION_STATE64_COUNT; return KERN_SUCCESS; default: return KERN_INVALID_ARGUMENT; } } /* * thread_setstatus: * * Set the status of the specified thread. */ kern_return_t machine_thread_set_state( thread_t thread, thread_flavor_t flavor, thread_state_t tstate, mach_msg_type_number_t count) { struct savearea *genuser; savearea_fpu *fsv, *fsvn, *fsvo; savearea_vec *vsv, *vsvn, *vsvo; unsigned int i; unsigned int clgn; register struct ppc_thread_state *ts; register struct ppc_thread_state64 *xts; register struct ppc_exception_state *es; register struct ppc_exception_state *xes; register struct ppc_float_state *fs; register struct ppc_vector_state *vs; // dbgTrace((unsigned int)thr_act, (unsigned int)0 /*sv: was never set*/, flavor); /* (TEST/DEBUG) */ clgn = count; /* Get the count */ switch (flavor) { /* Validate the count before we do anything else */ case PPC_THREAD_STATE: if (clgn < PPC_THREAD_STATE_COUNT) { /* Is it too short? */ return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */ } break; case PPC_THREAD_STATE64: if (clgn < PPC_THREAD_STATE64_COUNT) { /* Is it too short? */ return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */ } break; case PPC_EXCEPTION_STATE: if (clgn < PPC_EXCEPTION_STATE_COUNT) { /* Is it too short? */ return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */ } case PPC_EXCEPTION_STATE64: if (clgn < PPC_EXCEPTION_STATE64_COUNT) { /* Is it too short? */ return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */ } break; case PPC_FLOAT_STATE: if (clgn < PPC_FLOAT_STATE_COUNT) { /* Is it too short? */ return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */ } break; case PPC_VECTOR_STATE: if (clgn < PPC_VECTOR_STATE_COUNT) { /* Is it too short? */ return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */ } break; default: return KERN_INVALID_ARGUMENT; } genuser = get_user_regs(thread); /* Find or allocate and initialize one */ switch (flavor) { case PPC_THREAD_STATE: ts = (struct ppc_thread_state *)tstate; genuser->save_r0 = (uint64_t)ts->r0; genuser->save_r1 = (uint64_t)ts->r1; genuser->save_r2 = (uint64_t)ts->r2; genuser->save_r3 = (uint64_t)ts->r3; genuser->save_r4 = (uint64_t)ts->r4; genuser->save_r5 = (uint64_t)ts->r5; genuser->save_r6 = (uint64_t)ts->r6; genuser->save_r7 = (uint64_t)ts->r7; genuser->save_r8 = (uint64_t)ts->r8; genuser->save_r9 = (uint64_t)ts->r9; genuser->save_r10 = (uint64_t)ts->r10; genuser->save_r11 = (uint64_t)ts->r11; genuser->save_r12 = (uint64_t)ts->r12; genuser->save_r13 = (uint64_t)ts->r13; genuser->save_r14 = (uint64_t)ts->r14; genuser->save_r15 = (uint64_t)ts->r15; genuser->save_r16 = (uint64_t)ts->r16; genuser->save_r17 = (uint64_t)ts->r17; genuser->save_r18 = (uint64_t)ts->r18; genuser->save_r19 = (uint64_t)ts->r19; genuser->save_r20 = (uint64_t)ts->r20; genuser->save_r21 = (uint64_t)ts->r21; genuser->save_r22 = (uint64_t)ts->r22; genuser->save_r23 = (uint64_t)ts->r23; genuser->save_r24 = (uint64_t)ts->r24; genuser->save_r25 = (uint64_t)ts->r25; genuser->save_r26 = (uint64_t)ts->r26; genuser->save_r27 = (uint64_t)ts->r27; genuser->save_r28 = (uint64_t)ts->r28; genuser->save_r29 = (uint64_t)ts->r29; genuser->save_r30 = (uint64_t)ts->r30; genuser->save_r31 = (uint64_t)ts->r31; genuser->save_cr = ts->cr; genuser->save_xer = (uint64_t)ts->xer; genuser->save_lr = (uint64_t)ts->lr; genuser->save_ctr = (uint64_t)ts->ctr; genuser->save_srr0 = (uint64_t)ts->srr0; genuser->save_vrsave = ts->vrsave; /* VRSAVE register (Altivec only) */ genuser->save_srr1 = MSR_PREPARE_FOR_IMPORT(genuser->save_srr1, ts->srr1); /* Set the bits we can change */ genuser->save_srr1 |= MSR_EXPORT_MASK_SET; genuser->save_srr1 &= ~(MASK(MSR_FP) | MASK(MSR_VEC)); /* Make sure we don't enable the floating point unit */ if(task_has_64BitAddr(thread->task)) genuser->save_srr1 |= (uint64_t)MASK32(MSR_SF) << 32; /* If 64-bit task, force 64-bit mode */ else genuser->save_srr1 &= ~((uint64_t)MASK32(MSR_SF) << 32); /* else 32-bit mode */ return KERN_SUCCESS; case PPC_THREAD_STATE64: xts = (struct ppc_thread_state64 *)tstate; genuser->save_r0 = xts->r0; genuser->save_r1 = xts->r1; genuser->save_r2 = xts->r2; genuser->save_r3 = xts->r3; genuser->save_r4 = xts->r4; genuser->save_r5 = xts->r5; genuser->save_r6 = xts->r6; genuser->save_r7 = xts->r7; genuser->save_r8 = xts->r8; genuser->save_r9 = xts->r9; genuser->save_r10 = xts->r10; genuser->save_r11 = xts->r11; genuser->save_r12 = xts->r12; genuser->save_r13 = xts->r13; genuser->save_r14 = xts->r14; genuser->save_r15 = xts->r15; genuser->save_r16 = xts->r16; genuser->save_r17 = xts->r17; genuser->save_r18 = xts->r18; genuser->save_r19 = xts->r19; genuser->save_r20 = xts->r20; genuser->save_r21 = xts->r21; genuser->save_r22 = xts->r22; genuser->save_r23 = xts->r23; genuser->save_r24 = xts->r24; genuser->save_r25 = xts->r25; genuser->save_r26 = xts->r26; genuser->save_r27 = xts->r27; genuser->save_r28 = xts->r28; genuser->save_r29 = xts->r29; genuser->save_r30 = xts->r30; genuser->save_r31 = xts->r31; genuser->save_cr = xts->cr; genuser->save_xer = xts->xer; genuser->save_lr = xts->lr; genuser->save_ctr = xts->ctr; genuser->save_srr0 = xts->srr0; genuser->save_vrsave = xts->vrsave; /* VRSAVE register (Altivec only) */ genuser->save_srr1 = MSR_PREPARE_FOR_IMPORT(genuser->save_srr1, xts->srr1); /* Set the bits we can change */ genuser->save_srr1 |= MSR_EXPORT_MASK_SET; genuser->save_srr1 &= ~(MASK(MSR_FP) | MASK(MSR_VEC)); /* Make sure we don't enable the floating point unit */ if(task_has_64BitAddr(thread->task)) genuser->save_srr1 |= (uint64_t)MASK32(MSR_SF) << 32; /* If 64-bit task, force 64-bit mode */ else genuser->save_srr1 &= ~((uint64_t)MASK32(MSR_SF) << 32); /* else 32-bit mode */ return KERN_SUCCESS; case PPC_EXCEPTION_STATE: es = (struct ppc_exception_state *) tstate; genuser->save_dar = (uint64_t)es->dar; genuser->save_dsisr = es->dsisr; genuser->save_exception = es->exception; return KERN_SUCCESS; /* * It's pretty worthless to try to change this stuff, but we'll do it anyway. */ case PPC_EXCEPTION_STATE64: xes = (struct ppc_exception_state *) tstate; genuser->save_dar = xes->dar; genuser->save_dsisr = xes->dsisr; genuser->save_exception = xes->exception; return KERN_SUCCESS; case PPC_FLOAT_STATE: toss_live_fpu(thread->machine.curctx); /* Toss my floating point if live anywhere */ fsv = find_user_fpu(thread); /* Get the user's floating point context */ if(!fsv) { /* Do we have one yet? */ fsv = (savearea_fpu *)save_alloc(); /* If we still don't have one, get a new one */ fsv->save_hdr.save_flags = (fsv->save_hdr.save_flags & ~SAVtype) | (SAVfloat << SAVtypeshft); /* Mark as in use as float */ fsv->save_hdr.save_act = thread; fsv->save_hdr.save_prev = 0; /* Mark no more */ fsv->save_hdr.save_level = 0; /* Mark user state */ if(!thread->machine.curctx->FPUsave) thread->machine.curctx->FPUsave = fsv; /* If no floating point, chain us first */ else { fsvn = fsvo = thread->machine.curctx->FPUsave; /* Remember first one */ while (fsvn) { /* Go until we hit the end */ fsvo = fsvn; /* Remember the previous one */ fsvn = CAST_DOWN(savearea_fpu *, fsvo->save_hdr.save_prev); /* Skip on to the next */ } fsvo->save_hdr.save_prev = (addr64_t)((uintptr_t)fsv); /* Queue us on in */ } } fs = (struct ppc_float_state *) tstate; /* Point to source */ bcopy((char *)fs, (char *)&fsv->save_fp0, 32*8); /* Move in the 32 registers */ genuser->save_fpscr = fs->fpscr; /* Copy the fpscr value to normal */ return KERN_SUCCESS; case PPC_VECTOR_STATE: toss_live_vec(thread->machine.curctx); /* Toss my vector if live anywhere */ vsv = find_user_vec(thread); /* Get the user's vector context */ if(!vsv) { /* Do we have one yet? */ vsv = (savearea_vec *)save_alloc(); /* If we still don't have one, get a new one */ vsv->save_hdr.save_flags = (vsv->save_hdr.save_flags & ~SAVtype) | (SAVvector << SAVtypeshft); /* Mark as in use as vector */ vsv->save_hdr.save_act = thread; vsv->save_hdr.save_prev = 0; /* Mark no more */ vsv->save_hdr.save_level = 0; /* Mark user state */ if(!thread->machine.curctx->VMXsave) thread->machine.curctx->VMXsave = vsv; /* If no vector, chain us first */ else { vsvn = vsvo = thread->machine.curctx->VMXsave; /* Remember first one */ while (vsvn) { /* Go until we hit the end */ vsvo = vsvn; /* Remember the previous one */ vsvn = CAST_DOWN(savearea_vec *, vsvo->save_hdr.save_prev); /* Skip on to the next */ } vsvo->save_hdr.save_prev = (addr64_t)((uintptr_t)vsv); /* Queue us on in */ } } vs = (struct ppc_vector_state *) tstate; /* Point to source */ bcopy((char *)vs, (char *)&vsv->save_vr0, 32*16); /* 32 registers plus status and validity and pad */ vsv->save_vrvalid = vs->save_vrvalid; /* Set validity bits */ for(i = 0; i < 4; i++) genuser->save_vscr[i] = vs->save_vscr[i]; /* Set value for vscr */ return KERN_SUCCESS; default: return KERN_INVALID_ARGUMENT; } } void thread_set_wq_state64(thread_t thread, thread_state_t tstate) { struct ppc_thread_state64 *ts; struct savearea *genuser; thread_t curth = current_thread(); genuser = get_user_regs(thread); /* Find or allocate and initialize one */ ts = (struct ppc_thread_state64 *)tstate; if (curth != thread) thread_lock(thread); genuser->save_r1 = ts->r1; genuser->save_r3 = ts->r3; genuser->save_r4 = ts->r4; genuser->save_r5 = ts->r5; genuser->save_r6 = ts->r6; genuser->save_r7 = ts->r7; genuser->save_r8 = ts->r8; genuser->save_srr0 = ts->srr0; genuser->save_srr1 = (uint64_t)MSR_EXPORT_MASK_SET; if (task_has_64BitAddr(thread->task)) genuser->save_srr1 |= (uint64_t)MASK32(MSR_SF) << 32; /* If 64-bit task, force 64-bit mode */ if (curth != thread) thread_unlock(thread); } /* * This is where registers that are not normally specified by the mach-o * file on an execve should be nullified, perhaps to avoid a covert channel. * We've never bothered to clear FPRs or VRs, but it is important to clear * the FPSCR, which is kept in the general state but not set by the general * flavor (ie, PPC_THREAD_STATE or PPC_THREAD_STATE64.) */ kern_return_t machine_thread_state_initialize( thread_t thread) { struct savearea *sv; sv = get_user_regs(thread); /* Find or allocate and initialize one */ 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 */ return KERN_SUCCESS; } /* * Duplicates the context of one thread into a new one. * The new thread is assumed to be new and have no user state contexts except maybe a general one. * We also assume that the old thread can't be running anywhere. * * We're only going to be duplicating user context here. That means that we will have to * eliminate any floating point or vector kernel contexts and carry across the user state ones. */ kern_return_t machine_thread_dup( thread_t self, thread_t target) { struct savearea *sv, *osv; savearea_fpu *fsv, *fsvn; savearea_vec *vsv, *vsvn; fpu_save(self->machine.curctx); /* Make certain floating point state is all saved */ vec_save(self->machine.curctx); /* Make certain the vector state is all saved */ sv = get_user_regs(target); /* Allocate and initialze context in the new activation */ osv = find_user_regs(self); /* Find the original context */ if(!osv) return (KERN_FAILURE); bcopy((char *)((unsigned int)osv + sizeof(savearea_comm)), /* Copy everything but the headers */ (char *)((unsigned int)sv + sizeof(savearea_comm)), sizeof(struct savearea) - sizeof(savearea_comm)); sv->save_srr1 &= (uint64_t)(~(MASK(MSR_FP) | MASK(MSR_VEC))); /* Make certain that floating point and vector are turned off */ fsv = find_user_fpu(self); /* Get any user floating point */ target->machine.curctx->FPUsave = NULL; /* Assume no floating point */ if(fsv) { /* Did we find one? */ fsvn = (savearea_fpu *)save_alloc(); /* If we still don't have one, get a new one */ fsvn->save_hdr.save_flags = (fsvn->save_hdr.save_flags & ~SAVtype) | (SAVfloat << SAVtypeshft); /* Mark as in use as float */ fsvn->save_hdr.save_act = target; fsvn->save_hdr.save_prev = 0; /* Mark no more */ fsvn->save_hdr.save_level = 0; /* Mark user state */ target->machine.curctx->FPUsave = fsvn; /* Chain in the floating point */ bcopy((char *)((unsigned int)fsv + sizeof(savearea_comm)), /* Copy everything but the headers */ (char *)((unsigned int)fsvn + sizeof(savearea_comm)), sizeof(struct savearea) - sizeof(savearea_comm)); } vsv = find_user_vec(self); /* Get any user vector */ target->machine.curctx->VMXsave = NULL; /* Assume no vector */ if(vsv) { /* Did we find one? */ vsvn = (savearea_vec *)save_alloc(); /* If we still don't have one, get a new one */ vsvn->save_hdr.save_flags = (vsvn->save_hdr.save_flags & ~SAVtype) | (SAVvector << SAVtypeshft); /* Mark as in use as float */ vsvn->save_hdr.save_act = target; vsvn->save_hdr.save_prev = 0; /* Mark no more */ vsvn->save_hdr.save_level = 0; /* Mark user state */ target->machine.curctx->VMXsave = vsvn; /* Chain in the floating point */ bcopy((char *)((unsigned int)vsv + sizeof(savearea_comm)), /* Copy everything but the headers */ (char *)((unsigned int)vsvn + sizeof(savearea_comm)), sizeof(struct savearea) - sizeof(savearea_comm)); } return (KERN_SUCCESS); } /* * Initializes a fresh set of user state values. If there is no user state context, * one is created. Floats and VMX are not created. * * We only set initial values if there was no context found. */ struct savearea * get_user_regs( thread_t thread) { struct savearea *sv, *osv; unsigned int i; if (thread->machine.upcb) return thread->machine.upcb; sv = thread->machine.pcb; /* Get the top savearea on the stack */ osv = NULL; /* Set no user savearea yet */ while(sv) { /* Find the user context */ osv = sv; /* Save the last one */ sv = CAST_DOWN(struct savearea *, sv->save_hdr.save_prev); /* Get the previous context */ } sv = save_alloc(); /* Get one */ sv->save_hdr.save_flags = (sv->save_hdr.save_flags & ~SAVtype) | (SAVgeneral << SAVtypeshft); /* Mark as in use as general */ sv->save_hdr.save_act = thread; sv->save_hdr.save_prev = 0; /* Mark no more */ sv->save_hdr.save_level = 0; /* Mark user state */ if(osv) { /* Did we already have one? */ osv->save_hdr.save_prev = (addr64_t)((uintptr_t)sv); /* Chain us on the end */ } else { /* We are the first */ thread->machine.pcb = sv; /* Put it there */ } thread->machine.upcb = sv; /* Set user pcb */ for(i=0; i < 32; i+=2) { /* Fill up with defaults */ ((unsigned int *)&sv->save_r0)[i] = ((unsigned int *)&FloatInit)[0]; ((unsigned int *)&sv->save_r0)[i+1] = ((unsigned int *)&FloatInit)[1]; } sv->save_cr = 0; sv->save_xer = 0; sv->save_lr = (uint64_t)FloatInit; sv->save_ctr = (uint64_t)FloatInit; sv->save_srr0 = (uint64_t)FloatInit; sv->save_srr1 = (uint64_t)MSR_EXPORT_MASK_SET; if(task_has_64BitAddr(thread->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 */ return sv; /* Bye bye... */ } /* * Find the user state context. If there is no user state context, * we just return a 0. */ struct savearea * find_user_regs( thread_t thread) { return thread->machine.upcb; } /* The name of this call is something of a misnomer since the mact.pcb can * contain chained saveareas, but it will do for now.. */ struct savearea * find_kern_regs( thread_t thread) { return thread->machine.pcb; } /* * Find the user state floating point context. If there is no user state context, * we just return a 0. */ savearea_fpu * find_user_fpu( thread_t thread) { savearea_fpu *fsv; boolean_t intr; intr = ml_set_interrupts_enabled(FALSE); fsv = thread->machine.curctx->FPUsave; /* Get the start of the floating point chain */ while(fsv) { /* Look until the end or we find it */ if(!(fsv->save_hdr.save_level)) break; /* Is the the user state stuff? (the level is 0 if so) */ fsv = CAST_DOWN(savearea_fpu *, fsv->save_hdr.save_prev); /* Try the previous one */ } (void) ml_set_interrupts_enabled(intr); return fsv; /* Bye bye... */ } /* * Find the user state vector context. If there is no user state context, * we just return a 0. */ savearea_vec * find_user_vec( thread_t thread) { savearea_vec *vsv; boolean_t intr; intr = ml_set_interrupts_enabled(FALSE); vsv = thread->machine.curctx->VMXsave; /* Get the start of the vector chain */ while(vsv) { /* Look until the end or we find it */ if(!(vsv->save_hdr.save_level)) break; /* Is the the user state stuff? (the level is 0 if so) */ vsv = CAST_DOWN(savearea_vec *, vsv->save_hdr.save_prev); /* Try the previous one */ } (void) ml_set_interrupts_enabled(intr); return vsv; /* Bye bye... */ } /* * Find the user state vector context for the current thread. If there is no user state context, * we just return a 0. */ savearea_vec *find_user_vec_curr(void) { savearea_vec *vsv; thread_t thread = current_thread(); boolean_t intr; vec_save(thread->machine.curctx); /* Force save if live */ intr = ml_set_interrupts_enabled(FALSE); vsv = thread->machine.curctx->VMXsave; /* Get the start of the vector chain */ while(vsv) { /* Look until the end or we find it */ if(!(vsv->save_hdr.save_level)) break; /* Is the the user state stuff? (the level is 0 if so) */ vsv = CAST_DOWN(savearea_vec *, vsv->save_hdr.save_prev); /* Try the previous one */ } (void) ml_set_interrupts_enabled(intr); return vsv; /* Bye bye... */ } /* * thread_userstack: * * Return the user stack pointer from the machine * dependent thread state info. */ kern_return_t thread_userstack( __unused thread_t thread, int flavor, thread_state_t tstate, unsigned int count, mach_vm_offset_t *user_stack, int *customstack ) { /* * Set a default. */ switch (flavor) { case PPC_THREAD_STATE: { struct ppc_thread_state *state; if (count < PPC_THREAD_STATE_COUNT) return (KERN_INVALID_ARGUMENT); state = (struct ppc_thread_state *) tstate; /* * If a valid user stack is specified, use it. */ if (state->r1) { *user_stack = CAST_USER_ADDR_T(state->r1); if (customstack) *customstack = 1; } else { *user_stack = CAST_USER_ADDR_T(USRSTACK); if (customstack) *customstack = 0; } } break; case PPC_THREAD_STATE64: { struct ppc_thread_state64 *state64; if (count < PPC_THREAD_STATE64_COUNT) return (KERN_INVALID_ARGUMENT); state64 = (struct ppc_thread_state64 *)tstate; /* * If a valid user stack is specified, use it. */ if (state64->r1 != MACH_VM_MIN_ADDRESS) { *user_stack = state64->r1; if (customstack) *customstack = 1; } else { *user_stack = USRSTACK64; if (customstack) *customstack = 0; } } break; default : return (KERN_INVALID_ARGUMENT); } return (KERN_SUCCESS); } /* * thread_setuserstack: * * Sets the user stack pointer into the machine * dependent thread state info. */ void thread_setuserstack(thread_t thread, mach_vm_address_t user_stack) { struct savearea *sv; sv = get_user_regs(thread); /* Get the user state registers */ sv->save_r1 = user_stack; return; } void thread_set_cthreadself(thread_t thread, uint64_t pself, int isLP64) { struct savearea *sv; if (isLP64 == 0) { thread->machine.cthread_self = pself; } else { sv = get_user_regs(thread); /* Get the user state registers */ thread->machine.cthread_self = pself; sv->save_r13 = pself; } } /* * thread_adjuserstack: * * Returns the adjusted user stack pointer from the machine * dependent thread state info. Usef for small (<2G) deltas. */ uint64_t thread_adjuserstack(thread_t thread, int adjust) { struct savearea *sv; sv = get_user_regs(thread); /* Get the user state registers */ sv->save_r1 += adjust; /* Adjust the stack */ return sv->save_r1; /* Return the adjusted stack */ } kern_return_t thread_setsinglestep(thread_t thread, int on) { struct savearea *sv; sv = get_user_regs(thread); /* Get the user state registers */ if (on) sv->save_srr1 |= MASK(MSR_SE); else sv->save_srr1 &= ~MASK(MSR_SE); return (KERN_SUCCESS); } /* * thread_setentrypoint: * * Sets the user PC into the machine * dependent thread state info. */ void thread_setentrypoint(thread_t thread, uint64_t entry) { struct savearea *sv; sv = get_user_regs(thread); /* Get the user state registers */ sv->save_srr0 = entry; } kern_return_t thread_entrypoint( __unused thread_t thread, int flavor, thread_state_t tstate, unsigned int count, mach_vm_offset_t *entry_point ) { #if 0 /* Silly code: "if *entry_point is 0, make it 0" */ /* * Set a default. */ if (*entry_point == 0ULL) *entry_point = MACH_VM_MIN_ADDRESS; #endif switch (flavor) { case PPC_THREAD_STATE: { struct ppc_thread_state *state; if (count < PPC_THREAD_STATE_COUNT) return (KERN_INVALID_ARGUMENT); state = (struct ppc_thread_state *) tstate; /* * If a valid entry point is specified, use it. */ if (state->srr0) { *entry_point = CAST_USER_ADDR_T(state->srr0); } else { *entry_point = CAST_USER_ADDR_T(VM_MIN_ADDRESS); } } break; case PPC_THREAD_STATE64: { struct ppc_thread_state64 *state64; if (count < PPC_THREAD_STATE_COUNT) return (KERN_INVALID_ARGUMENT); state64 = (struct ppc_thread_state64 *)tstate; /* * If a valid entry point is specified, use it. */ if (state64->srr0) { *entry_point = state64->srr0; } else { *entry_point = MACH_VM_MIN_ADDRESS; } } break; default: return (KERN_INVALID_ARGUMENT); } return (KERN_SUCCESS); } unsigned int get_msr_exportmask(void) { return (MSR_EXPORT_MASK_SET); } unsigned int get_msr_nbits(void) { return (MASK(MSR_POW)|MASK(MSR_ILE)|MASK(MSR_IP)|MASK(MSR_LE)); } unsigned int get_msr_rbits(void) { return (MASK(MSR_PR)|MASK(MSR_ME)|MASK(MSR_IR)|MASK(MSR_DR)|MASK(MSR_EE)); } void ppc_checkthreadstate(void * tsptr, int flavor) { if (flavor == PPC_THREAD_STATE64) { struct ppc_thread_state64 *ts64 =(struct ppc_thread_state64 *)tsptr; /* Make sure naughty bits are off and necessary bits are on */ ts64->srr1 &= ~(MASK(MSR_POW)|MASK(MSR_ILE)|MASK(MSR_IP)|MASK(MSR_LE)); ts64->srr1 |= (MASK(MSR_PR)|MASK(MSR_ME)|MASK(MSR_IR)|MASK(MSR_DR)|MASK(MSR_EE)); } else { struct ppc_thread_state *ts =(struct ppc_thread_state *)tsptr; /* Make sure naughty bits are off and necessary bits are on */ ts->srr1 &= ~(MASK(MSR_POW)|MASK(MSR_ILE)|MASK(MSR_IP)|MASK(MSR_LE)); ts->srr1 |= (MASK(MSR_PR)|MASK(MSR_ME)|MASK(MSR_IR)|MASK(MSR_DR)|MASK(MSR_EE)); } return; } void thread_set_child( thread_t child, int pid) { struct savearea *child_state; child_state = get_user_regs(child); child_state->save_r3 = (uint_t)pid; child_state->save_r4 = 1ULL; } void thread_set_parent( thread_t parent, int pid) { struct savearea *parent_state; parent_state = get_user_regs(parent); parent_state->save_r3 = (uint64_t)pid; parent_state->save_r4 = 0; } /* * Saves the complete context (general, floating point, and vector) of the current activation. * We will collect everything into an opaque block of 1 to 3 saveareas and pass back a * pointer to that. * * The savearea is made to look like it belongs to the source activation. This needs to * be adjusted when these contexts are attached to a new activation. * */ void *act_thread_csave(void) { struct savearea *sv, *osv; savearea_fpu *fsv, *ofsv; savearea_vec *vsv, *ovsv; thread_t thread; thread = current_thread(); fpu_save(thread->machine.curctx); /* Make certain floating point state is all saved */ vec_save(thread->machine.curctx); /* Make certain the vector state is all saved */ osv = find_user_regs(thread); /* Get our savearea */ if(!osv) { panic("act_thread_csave: attempting to preserve the context of an activation with none (%p)\n", thread); } sv = save_alloc(); /* Get a fresh save area to save into */ sv->save_hdr.save_flags = (sv->save_hdr.save_flags & ~SAVtype) | (SAVgeneral << SAVtypeshft); /* Mark as in use as general */ sv->save_hdr.save_act = thread; sv->save_hdr.save_prev = 0; /* Mark no more */ sv->save_hdr.save_level = 0; /* Mark user state */ bcopy((char *)((unsigned int)osv + sizeof(savearea_comm)), /* Copy everything but the headers */ (char *)((unsigned int)sv + sizeof(savearea_comm)), sizeof(struct savearea) - sizeof(savearea_comm)); sv->save_srr1 &= (uint64_t)(~(MASK(MSR_FP) | MASK(MSR_VEC))); /* Make certain that floating point and vector are turned off */ sv->save_hdr.save_misc2 = 0xDEBB1ED0; /* Eye catcher for debug */ sv->save_hdr.save_misc3 = 0xE5DA11A5; /* Eye catcher for debug */ ofsv = find_user_fpu(thread); /* Get any user floating point */ sv->save_hdr.save_misc0 = 0; /* Assume no floating point */ if(ofsv) { /* Did we find one? */ fsv = (savearea_fpu *)save_alloc(); /* If we still don't have one, get a new one */ fsv->save_hdr.save_flags = (fsv->save_hdr.save_flags & ~SAVtype) | (SAVfloat << SAVtypeshft); /* Mark as in use as float */ fsv->save_hdr.save_act = thread; fsv->save_hdr.save_prev = 0; /* Mark no more */ fsv->save_hdr.save_level = 0; /* Mark user state */ fsv->save_hdr.save_misc2 = 0xDEBB1ED0; /* Eye catcher for debug */ fsv->save_hdr.save_misc3 = 0xE5DA11A5; /* Eye catcher for debug */ sv->save_hdr.save_misc0 = (uint64_t)((uintptr_t)fsv); /* Remember this one */ bcopy((char *)((unsigned int)ofsv + sizeof(savearea_comm)), /* Copy everything but the headers */ (char *)((unsigned int)fsv + sizeof(savearea_comm)), sizeof(struct savearea) - sizeof(savearea_comm)); } ovsv = find_user_vec(thread); /* Get any user vector */ sv->save_hdr.save_misc1 = 0; /* Assume no vector */ if(ovsv) { /* Did we find one? */ vsv = (savearea_vec *)save_alloc(); /* If we still don't have one, get a new one */ vsv->save_hdr.save_flags = (vsv->save_hdr.save_flags & ~SAVtype) | (SAVvector << SAVtypeshft); /* Mark as in use as float */ vsv->save_hdr.save_act = thread; vsv->save_hdr.save_prev = 0; /* Mark no more */ vsv->save_hdr.save_level = 0; /* Mark user state */ vsv->save_hdr.save_misc2 = 0xDEBB1ED0; /* Eye catcher for debug */ vsv->save_hdr.save_misc3 = 0xE5DA11A5; /* Eye catcher for debug */ sv->save_hdr.save_misc1 = (uint64_t)((uintptr_t)vsv); /* Chain in the floating point */ bcopy((char *)((unsigned int)ovsv + sizeof(savearea_comm)), /* Copy everything but the headers */ (char *)((unsigned int)vsv + sizeof(savearea_comm)), sizeof(struct savearea) - sizeof(savearea_comm)); } return (void *)sv; /* Bye bye... */ } /* * Attaches saved user state context to an activation. We will replace any * user state context with what is passed in. The saved context consists of a * savearea that was setup by * We will collect everything into one savearea and pass that back. * * The savearea is made to look like it belongs to the source activation. This needs to * be adjusted when these contexts are attached to a new activation. * */ void act_thread_catt(void *ctx) { struct savearea *sv, *osv, *psv; savearea_fpu *fsv, *ofsv, *pfsv; savearea_vec *vsv, *ovsv, *pvsv; unsigned int spc; thread_t thread; sv = (struct savearea *)ctx; /* Make this easier for C */ fsv = CAST_DOWN(savearea_fpu *, sv->save_hdr.save_misc0); /* Get a possible floating point savearea */ vsv = CAST_DOWN(savearea_vec *, sv->save_hdr.save_misc1); /* Get a possible vector savearea */ if((sv->save_hdr.save_misc2 != 0xDEBB1ED0) || (sv->save_hdr.save_misc3 != 0xE5DA11A5)) { /* See if valid savearea */ panic("act_thread_catt: attempt to attach invalid general context savearea - %p\n", sv); /* Die */ } if(fsv && ((fsv->save_hdr.save_misc2 != 0xDEBB1ED0) || (fsv->save_hdr.save_misc3 != 0xE5DA11A5))) { /* See if valid savearea */ panic("act_thread_catt: attempt to attach invalid float context savearea - %p\n", fsv); /* Die */ } if(vsv && ((vsv->save_hdr.save_misc2 != 0xDEBB1ED0) || (vsv->save_hdr.save_misc3 != 0xE5DA11A5))) { /* See if valid savearea */ panic("act_thread_catt: attempt to attach invalid vector context savearea - %p\n", vsv); /* Die */ } thread = current_thread(); act_machine_sv_free(thread, 0); /* Blow away any current kernel FP or vector. We do not support those across a vfork */ toss_live_fpu(thread->machine.curctx); /* Toss my floating point if live anywhere */ toss_live_vec(thread->machine.curctx); /* Toss my vector if live anywhere */ sv->save_hdr.save_misc2 = 0; /* Eye catcher for debug */ sv->save_hdr.save_misc3 = 0; /* Eye catcher for debug */ sv->save_hdr.save_act = thread; spc = (unsigned int)thread->map->pmap->space; /* Get the space we're in */ osv = thread->machine.pcb; /* Get the top general savearea */ psv = NULL; while(osv) { /* Any saved state? */ if(osv->save_srr1 & MASK(MSR_PR)) break; /* Leave if this is user state */ psv = osv; /* Save previous savearea address */ osv = CAST_DOWN(struct savearea *, osv->save_hdr.save_prev); /* Get one underneath our's */ } if(osv) { /* Did we find one? */ if(psv) psv->save_hdr.save_prev = 0; /* Yes, clear pointer to it (it should always be last) or */ else thread->machine.pcb = NULL; /* to the start if the only one */ save_release(osv); /* Nope, release it */ } if(psv) psv->save_hdr.save_prev = (addr64_t)((uintptr_t)sv); /* Chain us to the end or */ else thread->machine.pcb = (pcb_t)sv; /* to the start if the only one */ thread->machine.upcb = (pcb_t)sv; /* Set the user pcb */ ovsv = thread->machine.curctx->VMXsave; /* Get the top vector savearea */ pvsv = NULL; while(ovsv) { /* Any VMX saved state? */ if(!(ovsv->save_hdr.save_level)) break; /* Leave if this is user state */ pvsv = ovsv; /* Save previous savearea address */ ovsv = CAST_DOWN(savearea_vec *, ovsv->save_hdr.save_prev); /* Get one underneath our's */ } if(ovsv) { /* Did we find one? */ if(pvsv) pvsv->save_hdr.save_prev = 0; /* Yes, clear pointer to it (it should always be last) or */ else thread->machine.curctx->VMXsave = NULL; /* to the start if the only one */ save_release((struct savearea *)ovsv); /* Nope, release it */ } if(vsv) { /* Are we sticking any vector on this one? */ if(pvsv) pvsv->save_hdr.save_prev = (addr64_t)((uintptr_t)vsv); /* Yes, chain us to the end or */ else { thread->machine.curctx->VMXsave = vsv; /* to the start if the only one */ thread->machine.curctx->VMXlevel = NULL; /* Insure that we don't have a leftover level */ } vsv->save_hdr.save_misc2 = 0; /* Eye catcher for debug */ vsv->save_hdr.save_misc3 = 0; /* Eye catcher for debug */ vsv->save_hdr.save_act = thread; } ofsv = thread->machine.curctx->FPUsave; /* Get the top float savearea */ pfsv = NULL; while(ofsv) { /* Any float saved state? */ if(!(ofsv->save_hdr.save_level)) break; /* Leave if this is user state */ pfsv = ofsv; /* Save previous savearea address */ ofsv = CAST_DOWN(savearea_fpu *, ofsv->save_hdr.save_prev); /* Get one underneath our's */ } if(ofsv) { /* Did we find one? */ if(pfsv) pfsv->save_hdr.save_prev = 0; /* Yes, clear pointer to it (it should always be last) or */ else thread->machine.curctx->FPUsave = NULL; /* to the start if the only one */ save_release((struct savearea *)ofsv); /* Nope, release it */ } if(fsv) { /* Are we sticking any vector on this one? */ if(pfsv) pfsv->save_hdr.save_prev = (addr64_t)((uintptr_t)fsv); /* Yes, chain us to the end or */ else { thread->machine.curctx->FPUsave = fsv; /* to the start if the only one */ thread->machine.curctx->FPUlevel = NULL; /* Insure that we don't have a leftover level */ } fsv->save_hdr.save_misc2 = 0; /* Eye catcher for debug */ fsv->save_hdr.save_misc3 = 0; /* Eye catcher for debug */ fsv->save_hdr.save_act = thread; } } /* * Releases saved context. We need this because the saved context is opague. * be adjusted when these contexts are attached to a new activation. * */ void act_thread_cfree(void *ctx) { struct savearea *sv; savearea_fpu *fsv; savearea_vec *vsv; sv = (struct savearea *)ctx; /* Make this easier for C */ fsv = CAST_DOWN(savearea_fpu *, sv->save_hdr.save_misc0); /* Get a possible floating point savearea */ vsv = CAST_DOWN(savearea_vec *, sv->save_hdr.save_misc1); /* Get a possible vector savearea */ if((sv->save_hdr.save_misc2 != 0xDEBB1ED0) || (sv->save_hdr.save_misc3 != 0xE5DA11A5)) { /* See if valid savearea */ panic("act_thread_cfree: attempt to detatch invalid general context savearea - %p\n", sv); /* Die */ } save_release(sv); /* Toss the general savearea */ if(fsv) { /* See if there is any saved floating point */ if((fsv->save_hdr.save_misc2 != 0xDEBB1ED0) || (fsv->save_hdr.save_misc3 != 0xE5DA11A5)) { /* See if valid savearea */ panic("act_thread_cfree: attempt to detatch invalid float context savearea - %p\n", fsv); /* Die */ } save_release((struct savearea *)fsv); /* Toss saved context */ } if(vsv) { /* See if there is any saved floating point */ if((vsv->save_hdr.save_misc2 != 0xDEBB1ED0) || (vsv->save_hdr.save_misc3 != 0xE5DA11A5)) { /* See if valid savearea */ panic("act_thread_cfree: attempt to detatch invalid vector context savearea - %p\n", vsv); /* Die */ } save_release((struct savearea *)vsv); /* Toss saved context */ } return; } /* * thread_enable_fpe: * * enables or disables floating point exceptions for the thread. * returns old state */ int thread_enable_fpe( thread_t thread, int onoff) { struct savearea *sv; uint64_t oldmsr; sv = find_user_regs(thread); /* Find the user registers */ if(!sv) sv = get_user_regs(thread); /* Didn't find any, allocate and initialize one */ oldmsr = sv->save_srr1; /* Get the old msr */ if(onoff) sv->save_srr1 = oldmsr | (uint64_t)(MASK(MSR_FE0) | MASK(MSR_FE1)); /* Flip on precise FP exceptions */ else sv->save_srr1 = oldmsr & (uint64_t)(~(MASK(MSR_FE0) | MASK(MSR_FE1))); /* Flip on precise FP exceptions */ return ((oldmsr & (MASK(MSR_FE0) | MASK(MSR_FE1))) != 0); /* Return if it was enabled or not */ }