KSE Milestone 2

Note ALL MODULES MUST BE RECOMPILED
make the kernel aware that there are smaller units of scheduling than the
process. (but only allow one thread per process at this time).
This is functionally equivalent to teh previousl -current except
that there is a thread associated with each process.

Sorry john! (your next MFC will be a doosie!)

Reviewed by: peter@freebsd.org, dillon@freebsd.org

X-MFC after:    ha ha ha ha

1 files changed, 79 insertions, 71 deletions

diff --git a/sys/alpha/alpha/trap.c b/sys/alpha/alpha/trap.c
index 9b7d8f4..726615a 100644
--- a/sys/alpha/alpha/trap.c
+++ b/sys/alpha/alpha/trap.c
@@ -81,8 +81,8 @@ unsigned long	Gfloat_reg_cvt __P((unsigned long));
 #endif
 
 int		unaligned_fixup __P((unsigned long, unsigned long,
-		    unsigned long, struct proc *));
-int		handle_opdec(struct proc *p, u_int64_t *ucodep);
+		    unsigned long, struct thread *));
+int		handle_opdec(struct thread *td, u_int64_t *ucodep);
 
 static void printtrap __P((const unsigned long, const unsigned long,
       const unsigned long, const unsigned long, struct trapframe *, int, int));
@@ -256,6 +256,7 @@ trap(a0, a1, a2, entry, framep)
 	const unsigned long a0, a1, a2, entry;
 	struct trapframe *framep;
 {
+	register struct thread *td;
 	register struct proc *p;
 	register int i;
 	u_int64_t ucode;
@@ -272,11 +273,12 @@ trap(a0, a1, a2, entry, framep)
 	s = critical_enter();
 #endif
 	globalp = (struct globaldata *) alpha_pal_rdval();
-	p = curproc;
+	td = curthread;
 #ifdef SMP
-	p->p_md.md_kernnest++;
+	td->td_md.md_kernnest++;
 	critical_exit(s);
 #endif
+	p = td->td_proc;
 
 	/*
 	GIANT_REQUIRED;
@@ -289,15 +291,15 @@ trap(a0, a1, a2, entry, framep)
 	CTR5(KTR_TRAP, "%s trap: pid %d, (%lx, %lx, %lx)",
 	    user ? "user" : "kernel", p->p_pid, a0, a1, a2);
 	if (user)  {
-		sticks = p->p_sticks;
-		p->p_frame = framep;
+		sticks = td->td_kse->ke_sticks;
+		td->td_frame = framep;
 	} else {
 		sticks = 0;		/* XXX bogus -Wuninitialized warning */
 	}
 
 #ifdef DIAGNOSTIC
 	if (user)
-		alpha_fpstate_check(p);
+		alpha_fpstate_check(td);
 #endif
 
 	switch (entry) {
@@ -309,7 +311,7 @@ trap(a0, a1, a2, entry, framep)
 		 */
 		if (user) {
 			mtx_lock(&Giant);
-			if ((i = unaligned_fixup(a0, a1, a2, p)) == 0) {
+			if ((i = unaligned_fixup(a0, a1, a2, td)) == 0) {
 				mtx_unlock(&Giant);
 				goto out;
 			}
@@ -339,7 +341,7 @@ trap(a0, a1, a2, entry, framep)
 		if (user) {
 			mtx_lock(&Giant);
 			if (a0 & EXCSUM_SWC)
-				if (fp_software_completion(a1, p)) {
+				if (fp_software_completion(a1, td)) {
 					mtx_unlock(&Giant);
 					goto out;
 				}
@@ -391,10 +393,10 @@ trap(a0, a1, a2, entry, framep)
 			/* FALLTHROUTH */
 		case ALPHA_IF_CODE_BPT:
 		case ALPHA_IF_CODE_BUGCHK:
-			if (p->p_md.md_flags & (MDP_STEP1|MDP_STEP2)) {
+			if (td->td_md.md_flags & (MDP_STEP1|MDP_STEP2)) {
 				mtx_lock(&Giant);
-				ptrace_clear_single_step(p);
-				p->p_frame->tf_regs[FRAME_PC] -= 4;
+				ptrace_clear_single_step(td);
+				td->td_frame->tf_regs[FRAME_PC] -= 4;
 				mtx_unlock(&Giant);
 			}
 			ucode = a0;		/* trap type */
@@ -402,23 +404,23 @@ trap(a0, a1, a2, entry, framep)
 			break;
 
 		case ALPHA_IF_CODE_OPDEC:
-			i = handle_opdec(p, &ucode);
+			i = handle_opdec(td, &ucode);
 			if (i == 0)
 				goto out;
 			break;
 
 		case ALPHA_IF_CODE_FEN:
 			/*
-			 * on exit from the kernel, if proc == fpcurproc,
+			 * on exit from the kernel, if thread == fpcurthread,
 			 * FP is enabled.
 			 */
-			if (PCPU_GET(fpcurproc) == p) {
-				printf("trap: fp disabled for fpcurproc == %p",
-				    p);
+			if (PCPU_GET(fpcurthread) == td) {
+				printf("trap: fp disabled for fpcurthread == %p",
+				    td);
 				goto dopanic;
 			}
 	
-			alpha_fpstate_switch(p);
+			alpha_fpstate_switch(td);
 			goto out;
 
 		default:
@@ -432,7 +434,7 @@ trap(a0, a1, a2, entry, framep)
 		case ALPHA_MMCSR_FOR:
 		case ALPHA_MMCSR_FOE:
 		case ALPHA_MMCSR_FOW:
-			pmap_emulate_reference(p, a0, user,
+			pmap_emulate_reference(p->p_vmspace, a0, user,
 			    a1 == ALPHA_MMCSR_FOW);
 			goto out;
 
@@ -453,13 +455,13 @@ trap(a0, a1, a2, entry, framep)
 			 * when they are running.
 			 */
 			if (!user &&
-			    p != NULL &&
-			    p->p_addr->u_pcb.pcb_onfault ==
+			    td != NULL &&
+			    td->td_pcb->pcb_onfault ==
 			      (unsigned long)fswintrberr &&
-			    p->p_addr->u_pcb.pcb_accessaddr == a0) {
+			    td->td_pcb->pcb_accessaddr == a0) {
 				framep->tf_regs[FRAME_PC] =
-				    p->p_addr->u_pcb.pcb_onfault;
-				p->p_addr->u_pcb.pcb_onfault = 0;
+				    td->td_pcb->pcb_onfault;
+				td->td_pcb->pcb_onfault = 0;
 				goto out;
 			}
 
@@ -479,8 +481,8 @@ trap(a0, a1, a2, entry, framep)
 			 */
 			if (!user 
 			    && ((a0 >= VM_MIN_KERNEL_ADDRESS) 
-				|| (p == NULL) 
-				|| (p->p_addr->u_pcb.pcb_onfault == 0))) {
+				|| (td == NULL) 
+				|| (td->td_pcb->pcb_onfault == 0))) {
 				if (a0 >= trunc_page(PS_STRINGS
 						     - szsigcode
 						     - SPARE_USRSPACE)
@@ -578,11 +580,11 @@ trap(a0, a1, a2, entry, framep)
 			mtx_unlock(&Giant);
 			if (!user) {
 				/* Check for copyin/copyout fault */
-				if (p != NULL &&
-				    p->p_addr->u_pcb.pcb_onfault != 0) {
+				if (td != NULL &&
+				    td->td_pcb->pcb_onfault != 0) {
 					framep->tf_regs[FRAME_PC] =
-					    p->p_addr->u_pcb.pcb_onfault;
-					p->p_addr->u_pcb.pcb_onfault = 0;
+					    td->td_pcb->pcb_onfault;
+					td->td_pcb->pcb_onfault = 0;
 					goto out;
 				}
 				goto dopanic;
@@ -615,7 +617,7 @@ trap(a0, a1, a2, entry, framep)
 out:
 	if (user) {
 		framep->tf_regs[FRAME_SP] = alpha_pal_rdusp();
-		userret(p, framep, sticks);
+		userret(td, framep, sticks);
 		if (mtx_owned(&Giant))
 			mtx_unlock(&Giant);
 	}
@@ -649,6 +651,7 @@ syscall(code, framep)
 	struct trapframe *framep;
 {
 	struct sysent *callp;
+	struct thread *td;
 	struct proc *p;
 	int error = 0;
 	u_int64_t opc;
@@ -666,11 +669,12 @@ syscall(code, framep)
 	s = critical_enter();
 #endif
 	globalp = (struct globaldata *) alpha_pal_rdval();
-	p = curproc;
+	td = curthread;
 #ifdef SMP
-	p->p_md.md_kernnest++;
+	td->td_md.md_kernnest++;
 	critical_exit(s);
 #endif
+	p = td->td_proc;
 
 	framep->tf_regs[FRAME_TRAPARG_A0] = 0;
 	framep->tf_regs[FRAME_TRAPARG_A1] = 0;
@@ -681,9 +685,9 @@ syscall(code, framep)
 #endif
 
 	cnt.v_syscall++;
-	p->p_frame = framep;
+	td->td_frame = framep;
 	opc = framep->tf_regs[FRAME_PC] - 4;
-	sticks = p->p_sticks;
+	sticks = td->td_kse->ke_sticks;
 
 #ifdef DIAGNOSTIC
 	alpha_fpstate_check(p);
@@ -750,19 +754,19 @@ syscall(code, framep)
 	}
 #endif
 	if (error == 0) {
-		p->p_retval[0] = 0;
-		p->p_retval[1] = 0;
+		td->td_retval[0] = 0;
+		td->td_retval[1] = 0;
 
 		STOPEVENT(p, S_SCE, (callp->sy_narg & SYF_ARGMASK));
 
-		error = (*callp->sy_call)(p, args + hidden);
+		error = (*callp->sy_call)(td, args + hidden);
 	}
 
 
 	switch (error) {
 	case 0:
-		framep->tf_regs[FRAME_V0] = p->p_retval[0];
-		framep->tf_regs[FRAME_A4] = p->p_retval[1];
+		framep->tf_regs[FRAME_V0] = td->td_retval[0];
+		framep->tf_regs[FRAME_A4] = td->td_retval[1];
 		framep->tf_regs[FRAME_A3] = 0;
 		break;
 	case ERESTART:
@@ -782,10 +786,10 @@ syscall(code, framep)
 		break;
 	}
 
-	userret(p, framep, sticks);
+	userret(td, framep, sticks);
 #ifdef KTRACE
 	if (KTRPOINT(p, KTR_SYSRET)) {
-		ktrsysret(p->p_tracep, code, error, p->p_retval[0]);
+		ktrsysret(p->p_tracep, code, error, td->td_retval[0]);
 	}
 #endif
 	
@@ -805,7 +809,7 @@ syscall(code, framep)
 	STOPEVENT(p, S_SCX, code);
 
 #ifdef WITNESS
-	if (witness_list(p)) {
+	if (witness_list(td)) {
 		panic("system call %s returning with mutex(s) held\n",
 		    syscallnames[code]);
 	}
@@ -829,23 +833,23 @@ const static int reg_to_framereg[32] = {
 	FRAME_AT,	FRAME_GP,	FRAME_SP,	-1,
 };
 
-#define	irp(p, reg)							\
+#define	irp(td, reg)							\
 	((reg_to_framereg[(reg)] == -1) ? NULL :			\
-	    &(p)->p_frame->tf_regs[reg_to_framereg[(reg)]])
+	    &(td)->td_frame->tf_regs[reg_to_framereg[(reg)]])
 
-#define	frp(p, reg)							\
-	(&(p)->p_addr->u_pcb.pcb_fp.fpr_regs[(reg)])
+#define	frp(td, reg)							\
+	(&(td)->td_pcb->pcb_fp.fpr_regs[(reg)])
 
 #define	unaligned_load(storage, ptrf, mod)				\
 	if (copyin((caddr_t)va, &(storage), sizeof (storage)) == 0 &&	\
-	    (regptr = ptrf(p, reg)) != NULL)				\
+	    (regptr = ptrf(td, reg)) != NULL)				\
 		signal = 0;						\
 	else								\
 		break;							\
 	*regptr = mod (storage);
 
 #define	unaligned_store(storage, ptrf, mod)				\
-	if ((regptr = ptrf(p, reg)) == NULL)				\
+	if ((regptr = ptrf(td, reg)) == NULL)				\
 		(storage) = 0;						\
 	else								\
 		(storage) = mod (*regptr);				\
@@ -861,11 +865,11 @@ const static int reg_to_framereg[32] = {
 	unaligned_store(storage, irp, )
 
 #define	unaligned_load_floating(storage, mod)				\
-	alpha_fpstate_save(p, 1);					\
+	alpha_fpstate_save(td, 1);					\
 	unaligned_load(storage, frp, mod)
 
 #define	unaligned_store_floating(storage, mod)				\
-	alpha_fpstate_save(p, 0);					\
+	alpha_fpstate_save(td, 0);					\
 	unaligned_store(storage, frp, mod)
 
 unsigned long
@@ -988,13 +992,14 @@ extern int	alpha_unaligned_print, alpha_unaligned_fix;
 extern int	alpha_unaligned_sigbus;
 
 int
-unaligned_fixup(va, opcode, reg, p)
+unaligned_fixup(va, opcode, reg, td)
 	unsigned long va, opcode, reg;
-	struct proc *p;
+	struct thread *td;
 {
 	int doprint, dofix, dosigbus;
 	int signal, size;
 	const char *type;
+	struct proc *p;
 	unsigned long *regptr, longdata, uac;
 	int intdata;		/* signed to get extension when storing */
 	struct {
@@ -1024,10 +1029,13 @@ unaligned_fixup(va, opcode, reg, p)
 	 *
 	 */
 
-	if (p)
-		uac = p->p_md.md_flags & MDP_UAC_MASK;
-	else
+	if (td) {
+		uac = td->td_md.md_flags & MDP_UAC_MASK;
+		p = td->td_proc;
+	} else {
 		uac = 0;
+		p = NULL;
+	}
 
 	doprint = alpha_unaligned_print && !(uac & MDP_UAC_NOPRINT);
 	dofix = alpha_unaligned_fix && !(uac & MDP_UAC_NOFIX);
@@ -1061,8 +1069,8 @@ unaligned_fixup(va, opcode, reg, p)
 	if (doprint) {
 		uprintf(
 		"pid %d (%s): unaligned access: va=0x%lx pc=0x%lx ra=0x%lx op=",
-		    p->p_pid, p->p_comm, va, p->p_frame->tf_regs[FRAME_PC],
-		    p->p_frame->tf_regs[FRAME_RA]);
+		    p->p_pid, p->p_comm, va, td->td_frame->tf_regs[FRAME_PC],
+		    td->td_frame->tf_regs[FRAME_RA]);
 		uprintf(type,opcode);
 		uprintf("\n");
 	}
@@ -1165,8 +1173,8 @@ out:
  * and fills in *ucodep with the code to be delivered.
  */
 int
-handle_opdec(p, ucodep)
-	struct proc *p;
+handle_opdec(td, ucodep)
+	struct thread *td;
 	u_int64_t *ucodep;
 {
 	alpha_instruction inst;
@@ -1179,9 +1187,9 @@ handle_opdec(p, ucodep)
 	 * This keeps us from having to check for it in lots of places
 	 * later.
 	 */
-	p->p_frame->tf_regs[FRAME_SP] = alpha_pal_rdusp();
+	td->td_frame->tf_regs[FRAME_SP] = alpha_pal_rdusp();
 
-	inst_pc = memaddr = p->p_frame->tf_regs[FRAME_PC] - 4;
+	inst_pc = memaddr = td->td_frame->tf_regs[FRAME_PC] - 4;
 	if (copyin((caddr_t)inst_pc, &inst, sizeof (inst)) != 0) {
 		/*
 		 * really, this should never happen, but in case it
@@ -1196,21 +1204,21 @@ handle_opdec(p, ucodep)
 	case op_ldwu:
 	case op_stw:
 	case op_stb:
-		regptr = irp(p, inst.mem_format.rs);
+		regptr = irp(td, inst.mem_format.rs);
 		if (regptr != NULL)
 			memaddr = *regptr;
 		else
 			memaddr = 0;
 		memaddr += inst.mem_format.displacement;
 
-		regptr = irp(p, inst.mem_format.rd);
+		regptr = irp(td, inst.mem_format.rd);
 
 		if (inst.mem_format.opcode == op_ldwu ||
 		    inst.mem_format.opcode == op_stw) {
 			if (memaddr & 0x01) {
 				sig = unaligned_fixup(memaddr,
 				    inst.mem_format.opcode,
-				    inst.mem_format.rd, p);
+				    inst.mem_format.rd, td);
 				if (sig)
 					goto unaligned_fixup_sig;
 				break;
@@ -1260,11 +1268,11 @@ handle_opdec(p, ucodep)
 			} else {
 				if (inst.operate_reg_format.sbz != 0)
 					goto sigill;
-				regptr = irp(p, inst.operate_reg_format.rt);
+				regptr = irp(td, inst.operate_reg_format.rt);
 				b = (regptr != NULL) ? *regptr : 0;
 			}
 
-			regptr = irp(p, inst.operate_generic_format.rc);
+			regptr = irp(td, inst.operate_generic_format.rc);
 			if (regptr != NULL)
 				*regptr = b;
 			break;
@@ -1278,11 +1286,11 @@ handle_opdec(p, ucodep)
 			} else {
 				if (inst.operate_reg_format.sbz != 0)
 					goto sigill;
-				regptr = irp(p, inst.operate_reg_format.rt);
+				regptr = irp(td, inst.operate_reg_format.rt);
 				w = (regptr != NULL) ? *regptr : 0;
 			}
 
-			regptr = irp(p, inst.operate_generic_format.rc);
+			regptr = irp(td, inst.operate_generic_format.rc);
 			if (regptr != NULL)
 				*regptr = w;
 			break;
@@ -1298,7 +1306,7 @@ handle_opdec(p, ucodep)
 	 * nothing will have been successfully modified so we don't
 	 * have to write it out.
 	 */
-	alpha_pal_wrusp(p->p_frame->tf_regs[FRAME_SP]);
+	alpha_pal_wrusp(td->td_frame->tf_regs[FRAME_SP]);
 
 	return (0);
 
@@ -1308,7 +1316,7 @@ sigill:
 
 sigsegv:
 	sig = SIGSEGV;
-	p->p_frame->tf_regs[FRAME_PC] = inst_pc;	/* re-run instr. */
+	td->td_frame->tf_regs[FRAME_PC] = inst_pc;	/* re-run instr. */
 unaligned_fixup_sig:
 	*ucodep = memaddr;				/* faulting address */
 	return (sig);