git.saurik.com Git - apple/xnu.git/blame_incremental

... / ...

Commit	Line	Data
	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*
	25	*/
	26
	27	#include <kern/thread.h>
	28	#include <kern/thread_act.h>
	29	#include <kern/misc_protos.h>
	30	#include <mach/ppc/thread_status.h>
	31	#include <ppc/proc_reg.h>
	32	#include <ppc/exception.h>
	33	#include <ppc/fpu_protos.h>
	34	#include <ppc/misc_protos.h>
	35	#include <ppc/savearea.h>
	36	#include <ppc/thread_act.h>
	37	#include <ppc/Firmware.h>
	38
	39	#include <vm/vm_map.h>
	40
	41	extern unsigned int killprint;
	42	extern double FloatInit;
	43	extern unsigned long QNaNbarbarian[4];
	44	extern void thread_bootstrap_return(void);
	45
	46
	47	struct ppc_saved_state * get_user_regs(thread_act_t);
	48
	49	#define USRSTACK 0xc0000000
	50
	51	kern_return_t
	52	thread_userstack(
	53	thread_t,
	54	int,
	55	thread_state_t,
	56	unsigned int,
	57	vm_offset_t *
	58	);
	59
	60	kern_return_t
	61	thread_entrypoint(
	62	thread_t,
	63	int,
	64	thread_state_t,
	65	unsigned int,
	66	vm_offset_t *
	67	);
	68
	69	unsigned int get_msr_exportmask(void);
	70	unsigned int get_msr_nbits(void);
	71	unsigned int get_msr_rbits(void);
	72	void thread_set_child(thread_act_t child, int pid);
	73
	74	/*
	75	* Maps state flavor to number of words in the state:
	76	*/
	77	unsigned int state_count[] = {
	78	/* FLAVOR_LIST */ 0,
	79	PPC_THREAD_STATE_COUNT,
	80	PPC_FLOAT_STATE_COUNT,
	81	PPC_EXCEPTION_STATE_COUNT,
	82	};
	83
	84	/*
	85	* thread_getstatus:
	86	*
	87	* Get the status of the specified thread.
	88	*/
	89
	90	kern_return_t
	91	act_machine_get_state(
	92	thread_act_t thr_act,
	93	thread_flavor_t flavor,
	94	thread_state_t tstate,
	95	mach_msg_type_number_t *count)
	96	{
	97
	98	register struct savearea sv; / Pointer to the context savearea */
	99	int i, j;
	100	unsigned int vrvalidwrk;
	101
	102	register struct ppc_thread_state *ts;
	103	register struct ppc_exception_state *es;
	104	register struct ppc_float_state *fs;
	105	register struct ppc_vector_state *vs;
	106
	107	#if MACH_ASSERT
	108	if (watchacts & WA_STATE)
	109	printf("act_%x act_machine_get_state(thr_act=%x,flav=%x,st=%x,cnt@%x=%x)\n",
	110	current_act(), thr_act, flavor, tstate,
	111	count, (count ? *count : 0));
	112	#endif /* MACH_ASSERT */
	113
	114
	115	switch (flavor) {
	116
	117	case THREAD_STATE_FLAVOR_LIST:
	118
	119	if (*count < 3) {
	120	return (KERN_INVALID_ARGUMENT);
	121	}
	122
	123	tstate[0] = PPC_THREAD_STATE;
	124	tstate[1] = PPC_FLOAT_STATE;
	125	tstate[2] = PPC_EXCEPTION_STATE;
	126	*count = 3;
	127
	128	return KERN_SUCCESS;
	129
	130	case PPC_THREAD_STATE:
	131
	132	if (count < PPC_THREAD_STATE_COUNT) { / Is the count ok? */
	133	return KERN_INVALID_ARGUMENT;
	134	}
	135
	136	ts = (struct ppc_thread_state *) tstate;
	137
	138	sv = (savearea )(thr_act->mact.pcb); / Start with the normal savearea */
	139	while(sv) { /* Find the user context */
	140	if(sv->save_srr1 & MASK(MSR_PR)) { /* Are we looking at the user context? */
	141	break; /* Outta here */
	142	}
	143	sv = sv->save_prev; /* Back chain */
	144	}
	145
	146	if(sv) { /* Is there a save area yet? */
	147	ts->r0 = sv->save_r0;
	148	ts->r1 = sv->save_r1;
	149	ts->r2 = sv->save_r2;
	150	ts->r3 = sv->save_r3;
	151	ts->r4 = sv->save_r4;
	152	ts->r5 = sv->save_r5;
	153	ts->r6 = sv->save_r6;
	154	ts->r7 = sv->save_r7;
	155	ts->r8 = sv->save_r8;
	156	ts->r9 = sv->save_r9;
	157	ts->r10 = sv->save_r10;
	158	ts->r11 = sv->save_r11;
	159	ts->r12 = sv->save_r12;
	160	ts->r13 = sv->save_r13;
	161	ts->r14 = sv->save_r14;
	162	ts->r15 = sv->save_r15;
	163	ts->r16 = sv->save_r16;
	164	ts->r17 = sv->save_r17;
	165	ts->r18 = sv->save_r18;
	166	ts->r19 = sv->save_r19;
	167	ts->r20 = sv->save_r20;
	168	ts->r21 = sv->save_r21;
	169	ts->r22 = sv->save_r22;
	170	ts->r23 = sv->save_r23;
	171	ts->r24 = sv->save_r24;
	172	ts->r25 = sv->save_r25;
	173	ts->r26 = sv->save_r26;
	174	ts->r27 = sv->save_r27;
	175	ts->r28 = sv->save_r28;
	176	ts->r29 = sv->save_r29;
	177	ts->r30 = sv->save_r30;
	178	ts->r31 = sv->save_r31;
	179	ts->cr = sv->save_cr;
	180	ts->xer = sv->save_xer;
	181	ts->lr = sv->save_lr;
	182	ts->ctr = sv->save_ctr;
	183	ts->srr0 = sv->save_srr0;
	184	ts->srr1 = sv->save_srr1;
	185	ts->mq = sv->save_mq; /* MQ register (601 only) */
	186	ts->vrsave = sv->save_vrsave; /* VRSAVE register (Altivec only) */
	187	}
	188	else { /* No user state yet. Save seemingly random values. */
	189
	190	for(i=0; i < 32; i+=2) { /* Fill up with defaults */
	191	((unsigned int )&ts->r0)[i] = ((unsigned int )&FloatInit)[0];
	192	((unsigned int )&ts->r0)[i+1] = ((unsigned int )&FloatInit)[1];
	193	}
	194	ts->cr = 0;
	195	ts->xer = 0;
	196	ts->lr = ((unsigned int *)&FloatInit)[0];
	197	ts->ctr = ((unsigned int *)&FloatInit)[1];
	198	ts->srr0 = ((unsigned int *)&FloatInit)[0];
	199	ts->srr1 = MSR_EXPORT_MASK_SET;
	200	ts->mq = 0;
	201	ts->vrsave = 0; /* VRSAVE register (Altivec only) */
	202	}
	203
	204	count = PPC_THREAD_STATE_COUNT; / Pass back the amount we actually copied */
	205	return KERN_SUCCESS;
	206
	207	case PPC_EXCEPTION_STATE:
	208
	209	if (*count < PPC_EXCEPTION_STATE_COUNT) {
	210	return KERN_INVALID_ARGUMENT;
	211	}
	212
	213	es = (struct ppc_exception_state *) tstate;
	214
	215	sv = (savearea )(thr_act->mact.pcb); / Start with the normal savearea */
	216	while(sv) { /* Find the user context */
	217	if(sv->save_srr1 & MASK(MSR_PR)) { /* Are we looking at the user context? */
	218	break; /* Outta here */
	219	}
	220	sv = sv->save_prev; /* Back chain */
	221	}
	222
	223	if(sv) { /* See if valid state yet */
	224	es->dar = sv->save_dar;
	225	es->dsisr = sv->save_dsisr;
	226	es->exception = sv->save_exception;
	227	}
	228	else { /* Nope, not yet */
	229	es->dar = 0;
	230	es->dsisr = 0;
	231	es->exception = ((unsigned int *)&FloatInit)[0];
	232	}
	233
	234	*count = PPC_EXCEPTION_STATE_COUNT;
	235	return KERN_SUCCESS;
	236
	237	case PPC_FLOAT_STATE:
	238
	239	if (*count < PPC_FLOAT_STATE_COUNT) {
	240	return KERN_INVALID_ARGUMENT;
	241	}
	242
	243	fpu_save(); /* Just in case it's live, save it */
	244
	245	fs = (struct ppc_float_state ) tstate; / Point to destination */
	246
	247	sv = (savearea )(thr_act->mact.FPU_pcb); / Start with the top FPU savearea */
	248	while(sv) { /* Find the user context */
	249	if(!sv->save_level_fp) { /* Are we looking at the user context? */
	250	break; /* Outta here */
	251	}
	252	sv = sv->save_prev_float; /* Back chain */
	253	}
	254
	255	if(sv) { /* See if we have any */
	256	bcopy((char )&sv->save_fp0, (char )fs, 338); / 32 registers plus status and pad */
	257	}
	258	else { /* No floating point yet */
	259
	260	for(i=0; i < 32; i++) { /* Initialize floating points */
	261	fs->fpregs[i] = FloatInit; /* Initial value */
	262	}
	263	fs->fpscr_pad = 0; /* Initial value */
	264	fs->fpscr = 0; /* Initial value */
	265	}
	266
	267	*count = PPC_FLOAT_STATE_COUNT;
	268
	269	return KERN_SUCCESS;
	270
	271	case PPC_VECTOR_STATE:
	272
	273	if (*count < PPC_VECTOR_STATE_COUNT) {
	274	return KERN_INVALID_ARGUMENT;
	275	}
	276
	277	vec_save(); /* Just in case it's live, save it */
	278
	279	vs = (struct ppc_vector_state ) tstate; / Point to destination */
	280
	281	sv = (savearea )(thr_act->mact.VMX_pcb); / Start with the top FPU savearea */
	282	while(sv) { /* Find the user context */
	283	if(!sv->save_level_vec) { /* Are we looking at the user context? */
	284	break; /* Outta here */
	285	}
	286	sv = sv->save_prev_vector; /* Back chain */
	287	}
	288
	289	if(sv) { /* See if we have any */
	290
	291	vrvalidwrk = sv->save_vrvalid; /* Get the valid flags */
	292	vs->save_vrvalid = sv->save_vrvalid; /* Set the valid flags */
	293	for(j=0; j < 4; j++) vs->save_vscr[j] = sv->save_vscr[j]; /* Set value for vscr */
	294
	295	for(i=0; i < 32; i++) { /* Copy the saved registers and invalidate the others */
	296	for(j=0; j < 4; j++) {
	297	if(vrvalidwrk & 0x80000000) (vs->save_vr)[i][j] =
	298	((unsigned int )&(sv->save_vr0))[(i 4) + j]; /* We have this register saved */
	299	else vs->save_vr[i][j] = QNaNbarbarian[j]; /* Set invalid value */
	300	}
	301	vrvalidwrk = vrvalidwrk << 1; /* Shift over to the next */
	302	}
	303	}
	304	else { /* No vector yet */
	305
	306	for(i=0; i < 32; i++) { /* Initialize vector registers */
	307	for(j=0; j < 4; j++) vs->save_vr[i][j] = QNaNbarbarian[j]; /* Initial value */
	308	}
	309	for(j=0; j < 4; j++) vs->save_vscr[j] = 0; /* Initial value */
	310	vs->save_vrvalid = 0; /* Clear the valid flags */
	311	}
	312
	313	for (i=0; i < 4; i++) vs->save_pad5[i] = 0; /* Clear cruft */
	314	for (i=0; i < 7; i++) vs->save_pad6[i] = 0; /* Clear cruft */
	315
	316	*count = PPC_VECTOR_STATE_COUNT;
	317	return KERN_SUCCESS;
	318
	319	default:
	320	return KERN_INVALID_ARGUMENT;
	321	}
	322	}
	323
	324
	325	/*
	326	* thread_setstatus:
	327	*
	328	* Set the status of the specified thread.
	329	*/
	330	kern_return_t
	331	act_machine_set_state(
	332	thread_act_t thr_act,
	333	thread_flavor_t flavor,
	334	thread_state_t tstate,
	335	mach_msg_type_number_t count)
	336	{
	337
	338	savearea sv, osv, usv, ssv;
	339	unsigned int spc, i, *srs, isnew, clgn;
	340	register struct ppc_thread_state *ts;
	341	register struct ppc_exception_state *es;
	342	register struct ppc_float_state *fs;
	343	register struct ppc_vector_state *vs;
	344	spl_t spl;
	345
	346	int kernel_act = thr_act->kernel_loading \|\| thr_act->kernel_loaded;
	347
	348	#if MACH_ASSERT
	349	if (watchacts & WA_STATE)
	350	printf("act_%x act_machine_set_state(thr_act=%x,flav=%x,st=%x,cnt=%x)\n",
	351	current_act(), thr_act, flavor, tstate, count);
	352	#endif /* MACH_ASSERT */
	353
	354	// dbgTrace((unsigned int)thr_act, (unsigned int)sv, flavor); /* (TEST/DEBUG) */
	355
	356	clgn = count; /* Get the count */
	357
	358	switch (flavor) { /* Validate the count before we do anything else */
	359	case PPC_THREAD_STATE:
	360
	361	if (clgn < PPC_THREAD_STATE_COUNT) { /* Is it too short? */
	362	return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */
	363	}
	364
	365	if(clgn > PPC_THREAD_STATE_COUNT) clgn = PPC_THREAD_STATE_COUNT; /* If too long, pin it at max */
	366	break;
	367
	368	case PPC_EXCEPTION_STATE:
	369
	370	if (clgn < PPC_EXCEPTION_STATE_COUNT) { /* Is it too short? */
	371	return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */
	372	}
	373
	374	if(clgn > PPC_EXCEPTION_STATE_COUNT) clgn = PPC_EXCEPTION_STATE_COUNT; /* If too long, pin it at max */
	375	break;
	376
	377	case PPC_FLOAT_STATE:
	378
	379	if (clgn < PPC_FLOAT_STATE_COUNT) { /* Is it too short? */
	380	return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */
	381	}
	382
	383	if(clgn > PPC_FLOAT_STATE_COUNT) clgn = PPC_FLOAT_STATE_COUNT; /* If too long, pin it at max */
	384	break;
	385
	386
	387	case PPC_VECTOR_STATE:
	388
	389	if (clgn < PPC_VECTOR_STATE_COUNT) { /* Is it too short? */
	390	return KERN_INVALID_ARGUMENT; /* Yeah, just leave... */
	391	}
	392
	393	if(clgn > PPC_VECTOR_STATE_COUNT) clgn = PPC_VECTOR_STATE_COUNT; /* If too long, pin it at max */
	394	break;
	395
	396	default:
	397	return KERN_INVALID_ARGUMENT;
	398	}
	399
	400	isnew = 0; /* Remember when we make a new one */
	401
	402	switch (flavor) {
	403
	404	case PPC_THREAD_STATE:
	405	case PPC_EXCEPTION_STATE:
	406
	407	ts = (struct ppc_thread_state *)tstate;
	408
	409	sv = (savearea )thr_act->mact.pcb; / Get the top savearea on the stack */
	410	osv = 0; /* Set no user savearea yet */
	411
	412	while(sv) { /* Find the user context */
	413	if(sv->save_srr1 & MASK(MSR_PR)) { /* Are we looking at the user context? */
	414	break; /* Outta here */
	415	}
	416	osv = sv; /* Save the last one */
	417	sv = sv->save_prev; /* Get the previous context */
	418	}
	419
	420	if(!sv) { /* We didn't find a user context so allocate and initialize one */
	421	isnew = 1; /* Remember we made a new one */
	422	sv = save_alloc(); /* Get one */
	423	sv->save_act = thr_act; /* Point to the activation */
	424	sv->save_flags \|= SAVattach; /* Say that it is in use */
	425	sv->save_srr1 = MSR_EXPORT_MASK_SET & ~MASK(MSR_PR); /* Assume kernel state */
	426	sv->save_xfpscrpad = 0; /* Start with a clear fpscr */
	427	sv->save_xfpscr = 0; /* Start with a clear fpscr */
	428
	429	spc = (unsigned int)thr_act->map->pmap->space; /* Get the space we're in */
	430
	431	srs = (unsigned int )&sv->save_sr0; / Point to the SRs */
	432	for(i=0; i < 16; i++) { /* Fill in the SRs for the new context */
	433	srs[i] = SEG_REG_PROT \| (i<<20) \| spc; /* Set the SR */
	434	}
	435
	436	sv->save_sr_copyin = SEG_REG_PROT \| (SR_COPYIN_NUM<<20) \| spc; /* Make sure the copyin is set */
	437
	438	if(osv) { /* Did we already have one? */
	439	osv->save_prev = sv; /* Chain us on the end */
	440	}
	441	else { /* We are the first */
	442	thr_act->mact.pcb = (pcb_t)sv; /* Put it there */
	443	}
	444	sv->save_prev = 0; /* Properly terminate the chain */
	445
	446	}
	447
	448	if(flavor == PPC_THREAD_STATE) { /* Are we updating plain state? */
	449
	450	sv->save_r0 = ts->r0;
	451	sv->save_r1 = ts->r1;
	452	sv->save_r2 = ts->r2;
	453	sv->save_r3 = ts->r3;
	454	sv->save_r4 = ts->r4;
	455	sv->save_r5 = ts->r5;
	456	sv->save_r6 = ts->r6;
	457	sv->save_r7 = ts->r7;
	458	sv->save_r8 = ts->r8;
	459	sv->save_r9 = ts->r9;
	460	sv->save_r10 = ts->r10;
	461	sv->save_r11 = ts->r11;
	462	sv->save_r12 = ts->r12;
	463	sv->save_r13 = ts->r13;
	464	sv->save_r14 = ts->r14;
	465	sv->save_r15 = ts->r15;
	466	sv->save_r16 = ts->r16;
	467	sv->save_r17 = ts->r17;
	468	sv->save_r18 = ts->r18;
	469	sv->save_r19 = ts->r19;
	470	sv->save_r20 = ts->r20;
	471	sv->save_r21 = ts->r21;
	472	sv->save_r22 = ts->r22;
	473	sv->save_r23 = ts->r23;
	474	sv->save_r24 = ts->r24;
	475	sv->save_r25 = ts->r25;
	476	sv->save_r26 = ts->r26;
	477	sv->save_r27 = ts->r27;
	478	sv->save_r28 = ts->r28;
	479	sv->save_r29 = ts->r29;
	480	sv->save_r30 = ts->r30;
	481	sv->save_r31 = ts->r31;
	482
	483	sv->save_cr = ts->cr;
	484	sv->save_xer = ts->xer;
	485	sv->save_lr = ts->lr;
	486	sv->save_ctr = ts->ctr;
	487	sv->save_srr0 = ts->srr0;
	488	sv->save_mq = ts->mq;
	489	sv->save_vrsave = ts->vrsave; /* VRSAVE register (Altivec only) */
	490
	491	sv->save_srr1 = MSR_PREPARE_FOR_IMPORT(sv->save_srr1, ts->srr1); /* Set the bits we can change */
	492
	493	if(!kernel_act) sv->save_srr1 \|= MSR_EXPORT_MASK_SET; /* If not a kernel guy, force the magic bits on */
	494
	495	sv->save_srr1 &= ~(MASK(MSR_FP) \| MASK(MSR_FP)); /* Make sure we don't enable the floating point unit */
	496
	497	if(isnew) { /* Is it a new one? */
	498	sv->save_dar = 0; /* Yes, these need initialization also */
	499	sv->save_dsisr = 0;
	500	sv->save_exception = 0;
	501	}
	502
	503	return KERN_SUCCESS;
	504	}
	505	else { /* This must be exception state */
	506	if(isnew) /* If new, we need to initialize the normal registers */
	507	for(i=0; i < 32; i+=2) { /* Fill up with defaults */
	508	((unsigned int )&sv->save_r0)[i] = ((unsigned int )&FloatInit)[0];
	509	((unsigned int )&sv->save_r0)[i+1] = ((unsigned int )&FloatInit)[1];
	510	}
	511	sv->save_cr = 0;
	512	sv->save_xer = 0;
	513	sv->save_lr = ((unsigned int *)&FloatInit)[0];
	514	sv->save_ctr = ((unsigned int *)&FloatInit)[1];
	515	sv->save_srr0 = ((unsigned int *)&FloatInit)[0];
	516	sv->save_srr1 = MSR_EXPORT_MASK_SET;
	517	sv->save_mq = 0;
	518	sv->save_vrsave = 0; /* VRSAVE register (Altivec only) */
	519	}
	520
	521	es = (struct ppc_exception_state *) tstate;
	522
	523	sv->save_dar = es->dar;
	524	sv->save_dsisr = es->dsisr;
	525	sv->save_exception = es->exception;
	526
	527	return KERN_SUCCESS;
	528
	529	case PPC_FLOAT_STATE:
	530
	531	spl = splhigh(); /* Don't bother me while I'm zapping the owner stuff */
	532
	533	if (per_proc_info[cpu_number()].FPU_thread == (unsigned int)thr_act) /* If we own the FPU, and */
	534	if(!thr_act->mact.FPU_lvl) per_proc_info[cpu_number()].FPU_thread = 0; /* it's user level, say we don't own it any more */
	535
	536	splx(spl); /* Restore the interrupt level */
	537
	538	sv = (savearea )thr_act->mact.FPU_pcb; / Get the top savearea on the stack */
	539	osv = 0; /* Set no user savearea yet */
	540
	541	while(sv) { /* Find the user context */
	542	if(!(sv->save_level_fp)) { /* Are we looking at the user context? */
	543	break; /* Outta here */
	544	}
	545	osv = sv; /* Save the last one */
	546	sv = sv->save_prev_float; /* Get the previous context */
	547	}
	548
	549	if(!sv) { /* We didn't find a user context so allocate and initialize one */
	550
	551	sv = (savearea )thr_act->mact.pcb; / Point to the top savearea on the normal stack */
	552
	553	while(sv) { /* Have we hit the end? */
	554	if(!(sv->save_flags & SAVfpuvalid)) break; /* Is floating point in use here? */
	555	sv = sv->save_prev; /* Back chain */
	556	}
	557
	558	if(!sv) { /* If there wasn't one on the normal chain, check vector */
	559	sv = (savearea )thr_act->mact.VMX_pcb; / Point to the top savearea on the vector stack */
	560	while(sv) { /* Have we hit the end? */
	561	if(!(sv->save_flags & SAVfpuvalid)) break; /* Is floating point in use here? */
	562	sv = sv->save_prev_vector; /* Back chain */
	563	}
	564	}
	565
	566	if(!sv) { /* Do we have one yet? */
	567	sv = save_alloc(); /* If we still don't have one, get a new one */
	568	sv->save_act = thr_act; /* Point to the activation */
	569
	570	spc=(unsigned int)thr_act->map->pmap->space; /* Get the space we're in */
	571
	572	srs=(unsigned int )&sv->save_sr0; / Point to the SRs */
	573	for(i=0; i < 16; i++) { /* Fill in the SRs for the new context */
	574	srs[i] = SEG_REG_PROT \| (i<<20) \| spc; /* Set the SR */
	575	}
	576
	577	sv->save_sr_copyin = SEG_REG_PROT \| (SR_COPYIN_NUM<<20) \| spc; /* Make sure the copyin is set */
	578	}
	579
	580	if(osv) { /* Did we already have one? */
	581	osv->save_prev_float = sv; /* Chain us on the end */
	582	}
	583	else { /* We are the first */
	584	thr_act->mact.FPU_pcb = (pcb_t)sv; /* Put it there */
	585	}
	586	sv->save_prev_float = 0; /* Properly terminate the chain */
	587	sv->save_level_fp = 0; /* Make sure we are for the user level */
	588	sv->save_flags \|= SAVfpuvalid; /* Say that it is in use by floating point */
	589	}
	590
	591	fs = (struct ppc_float_state ) tstate; / Point to source */
	592
	593
	594	bcopy((char )fs, (char )&sv->save_fp0, clgn4); / 32 registers plus status and pad */
	595
	596	usv = find_user_regs(thr_act); /* Find the user registers */
	597	if(!usv) usv = get_user_regs(thr_act); /* Didn't find any, allocate and initialize one */
	598
	599	usv->save_xfpscrpad = sv->save_fpscr_pad; /* Copy the pad value to normal */
	600	usv->save_xfpscr = sv->save_fpscr; /* Copy the fpscr value to normal */
	601
	602
	603	return KERN_SUCCESS;
	604
	605
	606	case PPC_VECTOR_STATE:
	607
	608	spl = splhigh(); /* Don't bother me while I'm zapping the owner stuff */
	609
	610	if (per_proc_info[cpu_number()].VMX_thread == (unsigned int)thr_act) /* If we own the vector, and */
	611	if(!thr_act->mact.VMX_lvl) per_proc_info[cpu_number()].VMX_thread = 0; /* it's user level, say we don't own it any more */
	612
	613	splx(spl); /* Restore the interrupt level */
	614
	615	sv = (savearea )thr_act->mact.VMX_pcb; / Get the top savearea on the stack */
	616	osv = 0; /* Set no user savearea yet */
	617
	618	while(sv) { /* Find the user context */
	619	if(!(sv->save_level_vec)) { /* Are we looking at the user context? */
	620	break; /* Outta here */
	621	}
	622	osv = sv; /* Save the last one */
	623	sv = sv->save_prev_vector; /* Get the previous context */
	624	}
	625
	626	if(!sv) { /* We didn't find a user context so allocate and initialize one */
	627
	628	sv = (savearea )thr_act->mact.pcb; / Point to the top savearea on the normal stack */
	629
	630	while(sv) { /* Have we hit the end? */
	631	if(!(sv->save_flags & SAVvmxvalid)) break; /* Is vector in use here? */
	632	sv = sv->save_prev; /* Back chain */
	633	}
	634
	635	if(!sv) { /* If there wasn't one on the normal chain, check vector */
	636	sv = (savearea )thr_act->mact.FPU_pcb; / Point to the top savearea on the FPU stack */
	637	while(sv) { /* Have we hit the end? */
	638	if(!(sv->save_flags & SAVvmxvalid)) break; /* Is vector in use here? */
	639	sv = sv->save_prev_float; /* Get the previous context */
	640	}
	641	}
	642
	643	if(!sv) { /* Do we have one yet? */
	644	sv = save_alloc(); /* If we still don't have one, get a new one */
	645	sv->save_act = thr_act; /* Point to the activation */
	646
	647	spc=(unsigned int)thr_act->map->pmap->space; /* Get the space we're in */
	648
	649	srs=(unsigned int )&sv->save_sr0; / Point to the SRs */
	650	for(i=0; i < 16; i++) { /* Fill in the SRs for the new context */
	651	srs[i] = SEG_REG_PROT \| (i<<20) \| spc; /* Set the SR */
	652	}
	653
	654	sv->save_sr_copyin = SEG_REG_PROT \| (SR_COPYIN_NUM<<20) \| spc; /* Make sure the copyin is set */
	655	}
	656
	657	if(osv) { /* Did we already have one? */
	658	osv->save_prev_vector = sv; /* Chain us on the end */
	659	}
	660	else { /* We are the first */
	661	thr_act->mact.VMX_pcb = (pcb_t)sv; /* Put it there */
	662	}
	663	sv->save_prev_vector = 0; /* Properly terminate the chain */
	664	sv->save_level_vec = 0; /* Make sure we are for the user level */
	665	sv->save_flags \|= SAVvmxvalid; /* Say that it is in use by vector */
	666	}
	667
	668
	669	vs = (struct ppc_vector_state ) tstate; / Point to source */
	670
	671	bcopy((char )vs, (char )&sv->save_vr0, clgn4); / 32 registers plus status and validity and pad */
	672
	673	return KERN_SUCCESS;
	674
	675
	676	default:
	677	return KERN_INVALID_ARGUMENT;
	678	}
	679	}
	680
	681	/*
	682	* Duplicates the context of one thread into a new one.
	683	* The new thread is assumed to be new and have no user state contexts.
	684	* We also assume that the old thread can't be running anywhere.
	685	*
	686	* We're only going to be duplicating user context here. That means that we will have to
	687	* eliminate any floating point or vector kernel contexts and carry across the user state ones.
	688	* We will optimize and cram all states into one savearea. Actually that will be the easiest thing
	689	* to do.
	690	*/
	691
	692	void act_thread_dup(thread_act_t old, thread_act_t new) {
	693
	694	savearea sv, osv, *fsv;
	695	unsigned int spc, i, *srs;
	696
	697	fpu_save(); /* Make certain floating point state is all saved */
	698	vec_save(); /* Make certain the vector state is all saved */
	699
	700	osv = (savearea )new->mact.pcb; / Get the top savearea on the stack */
	701	sv = 0; /* Set no new user savearea yet */
	702
	703	while(osv) { /* Find the user context */
	704	if(osv->save_srr1 & MASK(MSR_PR)) { /* Are we looking at the user context? */
	705	sv=osv; /* Say which to use */
	706	break; /* Outta here */
	707	}
	708	osv=osv->save_prev; /* Get the previous context */
	709	}
	710
	711	if(!sv) { /* We didn't find a user context so allocate and initialize one */
	712	osv = (savearea )new->mact.pcb; / Point to the top savearea on the stack */
	713	sv = save_alloc(); /* Get one */
	714	sv->save_flags \|= SAVattach; /* Say that it is in use */
	715	sv->save_act = new; /* Point to the activation */
	716
	717	spc=(unsigned int)new->map->pmap->space; /* Get the space we're in */
	718
	719	srs=(unsigned int )&sv->save_sr0; / Point to the SRs */
	720	for(i=0; i < 16; i++) { /* Fill in the SRs for the new context */
	721	srs[i] = SEG_REG_PROT \| (i<<20) \| spc; /* Set the SR */
	722	}
	723
	724	sv->save_sr_copyin = SEG_REG_PROT \| (SR_COPYIN_NUM<<20) \| spc; /* Make sure the copyin is set */
	725
	726	if(osv) { /* Did we already have one? */
	727	sv->save_prev = osv->save_prev; /* Move the back chain of the top savearea */
	728	osv->save_prev = sv; /* Chain us just after it */
	729	}
	730	else { /* We are the first */
	731	new->mact.pcb = (pcb_t)sv; /* Make it the active one */
	732	}
	733
	734	}
	735
	736	osv = (savearea )(old->mact.pcb); / Start with the normal savearea */
	737	while(osv) { /* Find the user context */
	738	if(osv->save_srr1 & MASK(MSR_PR)) { /* Are we looking at the user context? */
	739	break; /* Outta here */
	740	}
	741	osv = osv->save_prev; /* Back chain */
	742	}
	743
	744	bcopy((char )&osv->save_srr0, (char )&sv->save_srr0, sizeof(struct ppc_thread_state)); /* Copy in normal state stuff */
	745
	746	sv->save_xfpscrpad = osv->save_xfpscrpad; /* Copy the pad value to old */
	747	sv->save_xfpscr = osv->save_xfpscr; /* Copy the fpscr value to old */
	748
	749	new->mact.FPU_pcb = (pcb_t)0 ; /* Initialize floating point savearea */
	750	new->mact.FPU_lvl = (pcb_t)0 ; /* Initialize floating point level */
	751	new->mact.FPU_cpu = 0 ; /* Initialize last used cpu (FP not live, so this doesn't really matter) */
	752	new->mact.VMX_pcb = (pcb_t)0 ; /* Initialize vector savearea */
	753	new->mact.VMX_lvl = (pcb_t)0 ; /* Initialize vector level */
	754	new->mact.VMX_cpu = 0 ; /* Initialize last used cpu (vector not live, so this doesn't reall matter) */
	755
	756	sv->save_prev_float = (savearea )0; / Clear the back chain */
	757	sv->save_prev_vector = (savearea )0; / Clear the back chain */
	758
	759	sv->save_srr1 &= ~(MASK(MSR_FP) \| MASK(MSR_VEC)); /* Make certain that floating point and vector are turned off */
	760
	761	fsv = (savearea )old->mact.FPU_pcb; / Get the start of the floating point chain */
	762	while(fsv) { /* Look until the end or we find it */
	763	if(!(fsv->save_level_fp)) { /* Is the the user state stuff? (the level is 0 if so) */
	764	sv->save_flags \|= SAVfpuvalid; /* Show we have it */
	765	bcopy((char )&osv->save_fp0, (char )&sv->save_fp0, sizeof(struct ppc_float_state)); /* Copy in floating point state stuff */
	766	new->mact.FPU_pcb = (pcb_t)sv; /* Make it the active one */
	767	break; /* Done, everything else is all set up... */
	768	}
	769	fsv = fsv->save_prev_float; /* Try the previous one */
	770	}
	771
	772	fsv = (savearea )old->mact.VMX_pcb; / Get the start of the vector chain */
	773	while(fsv) { /* Look until the end or we find it */
	774	if(!(fsv->save_level_vec)) { /* Is the the user state stuff? (the level is 0 if so) */
	775	sv->save_flags \|= SAVvmxvalid; /* Show we have it */
	776	bcopy((char )&osv->save_vr0, (char )&sv->save_vr0, sizeof(struct ppc_vector_state)); /* Copy in Altivec state stuff */
	777	new->mact.VMX_pcb = (pcb_t)sv; /* Make it the active one */
	778	break; /* Done, everything else is all set up... */
	779	}
	780	fsv = fsv->save_prev_vector; /* Try the previous one */
	781	}
	782
	783	return; /* Bye bye... */
	784	}
	785
	786	/*
	787	* Initializes a fresh set of user state values. If there is no user state context,
	788	* one is created. Floats and VMX are not created. We set initial values for everything.
	789	*/
	790
	791	struct ppc_saved_state * get_user_regs(thread_act_t act) {
	792
	793	savearea sv, osv;
	794	unsigned int spc, i, *srs;
	795
	796	sv = (savearea )act->mact.pcb; / Get the top savearea on the stack */
	797	osv = 0; /* Set no user savearea yet */
	798
	799	while(sv) { /* Find the user context */
	800	if(sv->save_srr1 & MASK(MSR_PR)) { /* Are we looking at the user context? */
	801	break; /* Outta here */
	802	}
	803	osv = sv; /* Save the last one */
	804	sv = sv->save_prev; /* Get the previous context */
	805	}
	806
	807	if(!sv) { /* We didn't find a user context so allocate and initialize one */
	808	sv = save_alloc(); /* Get one */
	809	sv->save_flags \|= SAVattach; /* Say that it is in use */
	810	sv->save_act = act; /* Point to the activation */
	811
	812	if(osv) { /* Did we already have one? */
	813	osv->save_prev = sv; /* Chain us on the end */
	814	}
	815	else { /* We are the first */
	816	act->mact.pcb = (pcb_t)sv; /* Put it there */
	817	}
	818	sv->save_prev = 0; /* Properly terminate the chain */
	819	}
	820
	821	for(i=0; i < 32; i+=2) { /* Fill up with defaults */
	822	((unsigned int )&sv->save_r0)[i] = ((unsigned int )&FloatInit)[0];
	823	((unsigned int )&sv->save_r0)[i+1] = ((unsigned int )&FloatInit)[1];
	824	}
	825	sv->save_cr = 0;
	826	sv->save_xer = 0;
	827	sv->save_lr = ((unsigned int *)&FloatInit)[0];
	828	sv->save_ctr = ((unsigned int *)&FloatInit)[1];
	829	sv->save_srr0 = ((unsigned int *)&FloatInit)[0];
	830	sv->save_srr1 = MSR_EXPORT_MASK_SET;
	831	sv->save_mq = 0;
	832	sv->save_vrsave = 0; /* VRSAVE register (Altivec only) */
	833	sv->save_xfpscrpad = 0; /* Start with a clear fpscr */
	834	sv->save_xfpscr = 0; /* Start with a clear fpscr */
	835
	836	spc=(unsigned int)act->map->pmap->space; /* Get the space we're in */
	837
	838	srs=(unsigned int )&sv->save_sr0; / Point to the SRs */
	839	for(i=0; i < 16; i++) { /* Fill in the SRs for the new context */
	840	srs[i] = SEG_REG_PROT \| (i<<20) \| spc; /* Set the SR */
	841	}
	842
	843	sv->save_sr_copyin = SEG_REG_PROT \| (SR_COPYIN_NUM<<20) \| spc; /* Make sure the copyin is set */
	844
	845	return (struct ppc_saved_state )sv; / Bye bye... */
	846	}
	847
	848	/*
	849	* Find the user state context. If there is no user state context,
	850	* we just return a 0.
	851	*/
	852
	853	struct ppc_saved_state * find_user_regs(thread_act_t act) {
	854
	855	savearea *sv;
	856
	857	sv = (savearea )act->mact.pcb; / Get the top savearea on the stack */
	858
	859	while(sv) { /* Find the user context */
	860	if(sv->save_srr1 & MASK(MSR_PR)) { /* Are we looking at the user context? */
	861	break; /* Outta here */
	862	}
	863	sv = sv->save_prev; /* Get the previous context */
	864	}
	865
	866	return (struct ppc_saved_state )sv; / Bye bye... */
	867	}
	868
	869	/*
	870	* Find the user state floating pointcontext. If there is no user state context,
	871	* we just return a 0.
	872	*/
	873
	874	struct ppc_float_state * find_user_fpu(thread_act_t act) {
	875
	876	savearea *fsv;
	877
	878	fsv = (savearea )act->mact.FPU_pcb; / Get the start of the floating point chain */
	879	while(fsv) { /* Look until the end or we find it */
	880	if(!(fsv->save_level_fp)) break; /* Is the the user state stuff? (the level is 0 if so) */
	881	fsv = fsv->save_prev_float; /* Try the previous one */
	882	}
	883
	884	return (struct ppc_float_state )&(fsv->save_fp0); / Bye bye... */
	885	}
	886
	887	/*
	888	* thread_userstack:
	889	*
	890	* Return the user stack pointer from the machine
	891	* dependent thread state info.
	892	*/
	893	kern_return_t
	894	thread_userstack(
	895	thread_t thread,
	896	int flavor,
	897	thread_state_t tstate,
	898	unsigned int count,
	899	vm_offset_t *user_stack
	900	)
	901	{
	902	struct ppc_thread_state *state;
	903
	904	/*
	905	* Set a default.
	906	*/
	907	if (*user_stack == 0)
	908	*user_stack = USRSTACK;
	909
	910	switch (flavor) {
	911	case PPC_THREAD_STATE:
	912	if (count < PPC_THREAD_STATE_COUNT)
	913	return (KERN_INVALID_ARGUMENT);
	914
	915	state = (struct ppc_thread_state *) tstate;
	916
	917	/*
	918	* If a valid user stack is specified, use it.
	919	*/
	920	*user_stack = state->r1 ? state->r1: USRSTACK;
	921	break;
	922	default :
	923	return (KERN_INVALID_ARGUMENT);
	924	}
	925
	926	return (KERN_SUCCESS);
	927	}
	928
	929	kern_return_t
	930	thread_entrypoint(
	931	thread_t thread,
	932	int flavor,
	933	thread_state_t tstate,
	934	unsigned int count,
	935	vm_offset_t *entry_point
	936	)
	937	{
	938	struct ppc_thread_state *state;
	939
	940	/*
	941	* Set a default.
	942	*/
	943	if (*entry_point == 0)
	944	*entry_point = VM_MIN_ADDRESS;
	945
	946	switch (flavor) {
	947
	948	case PPC_THREAD_STATE:
	949	if (count < PPC_THREAD_STATE_COUNT)
	950	return (KERN_INVALID_ARGUMENT);
	951
	952	state = (struct ppc_thread_state *) tstate;
	953
	954	/*
	955	* If a valid entry point is specified, use it.
	956	*/
	957	*entry_point = state->srr0 ? state->srr0: VM_MIN_ADDRESS;
	958	break;
	959	default:
	960	return (KERN_INVALID_ARGUMENT);
	961	}
	962
	963	return (KERN_SUCCESS);
	964	}
	965
	966	unsigned int get_msr_exportmask(void)
	967	{
	968	return (MSR_EXPORT_MASK_SET);
	969	}
	970
	971	unsigned int get_msr_nbits(void)
	972	{
	973	return (MASK(MSR_POW)\|MASK(MSR_ILE)\|MASK(MSR_IP)\|MASK(MSR_LE));
	974	}
	975	unsigned int get_msr_rbits(void)
	976	{
	977	return (MASK(MSR_PR)\|MASK(MSR_ME)\|MASK(MSR_IR)\|MASK(MSR_DR)\|MASK(MSR_EE));
	978	}
	979
	980	void thread_set_child(thread_act_t child, int pid)
	981	{
	982	struct ppc_saved_state *child_state;
	983
	984	child_state = find_user_regs(child);
	985
	986	child_state->r3 = pid;
	987	child_state->r4 = 1;
	988	}