diff options
Diffstat (limited to 'sys/alpha')
34 files changed, 913 insertions, 698 deletions
diff --git a/sys/alpha/alpha/db_interface.c b/sys/alpha/alpha/db_interface.c index 6a566e3..49463c7 100644 --- a/sys/alpha/alpha/db_interface.c +++ b/sys/alpha/alpha/db_interface.c @@ -592,23 +592,26 @@ DB_SHOW_COMMAND(pcpu, db_show_pcpu) db_printf("cpuid = %d\n", gd->gd_cpuid); db_printf("ipis = %lx\n", gd->gd_pending_ipis); db_printf("next ASN = %d\n", gd->gd_next_asn); - db_printf("curproc = "); - if (gd->gd_curproc != NULL) - db_printf("%p: pid %d \"%s\"\n", gd->gd_curproc, - gd->gd_curproc->p_pid, gd->gd_curproc->p_comm); + db_printf("curthread = "); + if (gd->gd_curthread != NULL) + db_printf("%p: pid %d \"%s\"\n", gd->gd_curthread, + gd->gd_curthread->td_proc->p_pid, + gd->gd_curthread->td_proc->p_comm); else db_printf("none\n"); db_printf("curpcb = %p\n", gd->gd_curpcb); - db_printf("fpcurproc = "); - if (gd->gd_fpcurproc != NULL) - db_printf("%p: pid %d \"%s\"\n", gd->gd_fpcurproc, - gd->gd_fpcurproc->p_pid, gd->gd_fpcurproc->p_comm); + db_printf("fpcurthread = "); + if (gd->gd_fpcurthread != NULL) + db_printf("%p: pid %d \"%s\"\n", gd->gd_fpcurthread, + gd->gd_fpcurthread->td_proc->p_pid, + gd->gd_fpcurthread->td_proc->p_comm); else db_printf("none\n"); - db_printf("idleproc = "); - if (gd->gd_idleproc != NULL) - db_printf("%p: pid %d \"%s\"\n", gd->gd_idleproc, - gd->gd_idleproc->p_pid, gd->gd_idleproc->p_comm); + db_printf("idlethread = "); + if (gd->gd_idlethread != NULL) + db_printf("%p: pid %d \"%s\"\n", gd->gd_idlethread, + gd->gd_idlethread->td_proc->p_pid, + gd->gd_idlethread->td_proc->p_comm); else db_printf("none\n"); diff --git a/sys/alpha/alpha/db_trace.c b/sys/alpha/alpha/db_trace.c index c743926..f99e5a0 100644 --- a/sys/alpha/alpha/db_trace.c +++ b/sys/alpha/alpha/db_trace.c @@ -212,6 +212,7 @@ db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count, char *m boolean_t ra_from_pcb; u_long last_ipl = ~0L; struct proc *p = NULL; + struct thread *td = NULL; boolean_t have_trapframe = FALSE; pid_t pid; @@ -219,7 +220,8 @@ db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count, char *m count = 65535; if (!have_addr) { - p = curproc; + td = curthread; + p = td->td_proc; addr = DDB_REGS->tf_regs[FRAME_SP] - FRAME_SIZE * 8; tf = (struct trapframe *)addr; have_trapframe = 1; @@ -231,8 +233,9 @@ db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count, char *m * The pcb for curproc is not valid at this point, * so fall back to the default case. */ - if (pid == curproc->p_pid) { - p = curproc; + if (pid == curthread->td_proc->p_pid) { + td = curthread; + p = td->td_proc; addr = DDB_REGS->tf_regs[FRAME_SP] - FRAME_SIZE * 8; tf = (struct trapframe *)addr; have_trapframe = 1; @@ -251,7 +254,7 @@ db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count, char *m db_printf("pid %d swapped out\n", pid); return; } - pcbp = &p->p_addr->u_pcb; + pcbp = p->p_thread.td_pcb; /* XXXKSE */ addr = (db_expr_t)pcbp->pcb_hw.apcb_ksp; callpc = pcbp->pcb_context[7]; frame = addr; diff --git a/sys/alpha/alpha/exception.s b/sys/alpha/alpha/exception.s index c7119b0..31637b4 100644 --- a/sys/alpha/alpha/exception.s +++ b/sys/alpha/alpha/exception.s @@ -139,17 +139,17 @@ beq t1, exception_return /* set the hae register if this process has specified a value */ - ldq s0, GD_CURPROC(globalp) - ldq t1, P_MD_FLAGS(s0) + ldq s0, GD_CURTHREAD(globalp) + ldq t1, TD_MD_FLAGS(s0) and t1, MDP_HAEUSED beq t1, 3f - ldq a0, P_MD_HAE(s0) + ldq a0, TD_MD_HAE(s0) ldq pv, chipset + CHIPSET_WRITE_HAE CALL((pv)) 3: #ifdef SMP /* leave the kernel */ - stl zero, P_MD_KERNNEST(s0) + stl zero, TD_MD_KERNNEST(s0) #endif /* restore the registers, and return */ @@ -255,9 +255,9 @@ LEAF(exception_return, 1) /* XXX should be NESTED */ br pv, Ler1 Ler1: LDGP(pv) - ldq s0, GD_CURPROC(globalp) /* save curproc in s0 */ + ldq s0, GD_CURTHREAD(globalp) /* save curthread in s0 */ #ifdef SMP - ldl s1, P_MD_KERNNEST(s0) + ldl s1, TD_MD_KERNNEST(s0) subl s1, 1, s1 /* decrement nesting level */ #endif @@ -280,16 +280,16 @@ Lkernelret: Lrestoreregs: /* set the hae register if this process has specified a value */ - ldq t1, P_MD_FLAGS(s0) + ldq t1, TD_MD_FLAGS(s0) and t1, MDP_HAEUSED beq t1, Lnohae - ldq a0, P_MD_HAE(t0) + ldq a0, TD_MD_HAE(t0) ldq pv, chipset + CHIPSET_WRITE_HAE CALL((pv)) Lnohae: #ifdef SMP /* leave the kernel */ - stl s1, P_MD_KERNNEST(s0) + stl s1, TD_MD_KERNNEST(s0) #endif /* restore the registers, and return */ diff --git a/sys/alpha/alpha/fp_emulate.c b/sys/alpha/alpha/fp_emulate.c index 20f64d6..bf5eef7 100644 --- a/sys/alpha/alpha/fp_emulate.c +++ b/sys/alpha/alpha/fp_emulate.c @@ -221,10 +221,10 @@ static fp_register_t fp_cvtql(union alpha_instruction ins, return ret; } -static int fp_emulate(union alpha_instruction ins, struct proc *p) +static int fp_emulate(union alpha_instruction ins, struct thread *td) { - u_int64_t control = p->p_addr->u_pcb.pcb_fp_control; - struct fpreg *fpregs = &p->p_addr->u_pcb.pcb_fp; + u_int64_t control = td->td_pcb->pcb_fp_control; + struct fpreg *fpregs = &td->td_pcb->pcb_fp; static fp_opcode_handler *ops[16] = { fp_add, /* 0 */ fp_sub, /* 1 */ @@ -261,7 +261,7 @@ static int fp_emulate(union alpha_instruction ins, struct proc *p) * them. We are potentially going to modify the fp state, so * cancel fpcurproc too. */ - alpha_fpstate_save(p, 1); + alpha_fpstate_save(td, 1); /* * Decode and execute the instruction. @@ -288,7 +288,7 @@ static int fp_emulate(union alpha_instruction ins, struct proc *p) /* Record the exception in the software control word. */ control |= (status >> IEEE_STATUS_TO_FPCR_SHIFT); - p->p_addr->u_pcb.pcb_fp_control = control; + td->td_pcb->pcb_fp_control = control; /* Regenerate the control register */ fpcr = fpregs->fpr_cr & FPCR_DYN_MASK; @@ -323,9 +323,9 @@ static int fp_emulate(union alpha_instruction ins, struct proc *p) * emulating it in software. Return non-zero if the completion was * successful, otherwise zero. */ -int fp_software_completion(u_int64_t regmask, struct proc *p) +int fp_software_completion(u_int64_t regmask, struct thread *td) { - struct trapframe *frame = p->p_frame; + struct trapframe *frame = td->td_frame; u_int64_t pc = frame->tf_regs[FRAME_PC]; int error; @@ -394,7 +394,7 @@ int fp_software_completion(u_int64_t regmask, struct proc *p) * instructions in the trap shadow, so this * must be the one which generated the trap. */ - if (fp_emulate(ins, p)) { + if (fp_emulate(ins, td)) { /* * Restore pc to the first instruction * in the trap shadow. diff --git a/sys/alpha/alpha/genassym.c b/sys/alpha/alpha/genassym.c index 03990ea..d520b52 100644 --- a/sys/alpha/alpha/genassym.c +++ b/sys/alpha/alpha/genassym.c @@ -68,8 +68,8 @@ #include <nfs/nfs.h> #include <nfs/nfsdiskless.h> -ASSYM(GD_CURPROC, offsetof(struct globaldata, gd_curproc)); -ASSYM(GD_FPCURPROC, offsetof(struct globaldata, gd_fpcurproc)); +ASSYM(GD_CURTHREAD, offsetof(struct globaldata, gd_curthread)); +ASSYM(GD_FPCURTHREAD, offsetof(struct globaldata, gd_fpcurthread)); ASSYM(GD_CURPCB, offsetof(struct globaldata, gd_curpcb)); ASSYM(GD_SWITCHTIME, offsetof(struct globaldata, gd_switchtime)); ASSYM(GD_CPUID, offsetof(struct globaldata, gd_cpuid)); @@ -80,12 +80,15 @@ ASSYM(MTX_RECURSE, offsetof(struct mtx, mtx_recurse)); ASSYM(MTX_SAVECRIT, offsetof(struct mtx, mtx_savecrit)); ASSYM(MTX_UNOWNED, MTX_UNOWNED); -ASSYM(P_ADDR, offsetof(struct proc, p_addr)); -ASSYM(P_MD_FLAGS, offsetof(struct proc, p_md.md_flags)); -ASSYM(P_MD_PCBPADDR, offsetof(struct proc, p_md.md_pcbpaddr)); -ASSYM(P_MD_HAE, offsetof(struct proc, p_md.md_hae)); +ASSYM(TD_PCB, offsetof(struct thread, td_pcb)); +ASSYM(TD_KSE, offsetof(struct thread, td_kse)); +ASSYM(TD_PROC, offsetof(struct thread, td_proc)); + +ASSYM(TD_MD_FLAGS, offsetof(struct thread, td_md.md_flags)); +ASSYM(TD_MD_PCBPADDR, offsetof(struct thread, td_md.md_pcbpaddr)); +ASSYM(TD_MD_HAE, offsetof(struct thread, td_md.md_hae)); #ifdef SMP -ASSYM(P_MD_KERNNEST, offsetof(struct proc, p_md.md_kernnest)); +ASSYM(TD_MD_KERNNEST, offsetof(struct thread, td_md.md_kernnest)); #endif ASSYM(MDP_HAEUSED, MDP_HAEUSED); @@ -95,10 +98,9 @@ ASSYM(VM_MAXUSER_ADDRESS, VM_MAXUSER_ADDRESS); ASSYM(PTLEV1I, PTLEV1I); ASSYM(PTESIZE, PTESIZE); -ASSYM(U_PCB_ONFAULT, offsetof(struct user, u_pcb.pcb_onfault)); -ASSYM(U_PCB_HWPCB_KSP, offsetof(struct user, u_pcb.pcb_hw.apcb_ksp)); -ASSYM(U_PCB_CONTEXT, offsetof(struct user, u_pcb.pcb_context)); - +ASSYM(PCB_ONFAULT, offsetof(struct pcb, pcb_onfault)); +ASSYM(PCB_HWPCB_KSP, offsetof(struct pcb, pcb_hw.apcb_ksp)); +ASSYM(PCB_CONTEXT, offsetof(struct pcb, pcb_context)); ASSYM(PCB_HW, offsetof(struct pcb, pcb_hw)); ASSYM(FPREG_FPR_REGS, offsetof(struct fpreg, fpr_regs)); diff --git a/sys/alpha/alpha/interrupt.c b/sys/alpha/alpha/interrupt.c index 489c948..0bdd6c5 100644 --- a/sys/alpha/alpha/interrupt.c +++ b/sys/alpha/alpha/interrupt.c @@ -90,7 +90,7 @@ interrupt(a0, a1, a2, framep) unsigned long a0, a1, a2; struct trapframe *framep; { - struct proc *p; + struct thread *td; #ifdef SMP critical_t s; #endif @@ -102,19 +102,21 @@ interrupt(a0, a1, a2, 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 - atomic_add_int(&p->p_intr_nesting_level, 1); + atomic_add_int(&td->td_intr_nesting_level, 1); +#ifndef KSTACK_GUARD #ifndef SMP { - if ((caddr_t) framep < (caddr_t) p->p_addr + 1024) { + if ((caddr_t) framep < (caddr_t) td->td_pcb + 1024) { panic("possible stack overflow\n"); } } #endif +#endif framep->tf_regs[FRAME_TRAPARG_A0] = a0; framep->tf_regs[FRAME_TRAPARG_A1] = a1; @@ -161,7 +163,7 @@ interrupt(a0, a1, a2, framep) a0, a1, a2); /* NOTREACHED */ } - atomic_subtract_int(&p->p_intr_nesting_level, 1); + atomic_subtract_int(&td->td_intr_nesting_level, 1); } void @@ -472,7 +474,7 @@ alpha_clock_interrupt(struct trapframe *framep) #ifdef SMP } else { mtx_lock_spin(&sched_lock); - hardclock_process(curproc, TRAPF_USERMODE(framep)); + hardclock_process(curthread, TRAPF_USERMODE(framep)); if ((schedclk2 & 0x7) == 0) statclock_process(curproc, TRAPF_PC(framep), TRAPF_USERMODE(framep)); diff --git a/sys/alpha/alpha/locore.s b/sys/alpha/alpha/locore.s index f054408..adb481f 100644 --- a/sys/alpha/alpha/locore.s +++ b/sys/alpha/alpha/locore.s @@ -114,10 +114,10 @@ mov v0, globalp /* - * Switch to proc0's PCB, which is at U_PCB off of proc0paddr. + * Switch to proc0's PCB. */ - lda t0,proc0 /* get phys addr of pcb */ - ldq a0,P_MD_PCBPADDR(t0) + ldq t0,thread0 /* get phys addr of pcb */ + ldq a0,TD_MD_PCBPADDR(t0) SWITCH_CONTEXT /* @@ -308,12 +308,6 @@ LEAF(restorefpstate, 1) RET END(restorefpstate) - .data - EXPORT(proc0paddr) - .quad 0 - - .text - /* XXX: make systat/vmstat happy */ .data EXPORT(intrnames) diff --git a/sys/alpha/alpha/machdep.c b/sys/alpha/alpha/machdep.c index 04aa677..10754d3 100644 --- a/sys/alpha/alpha/machdep.c +++ b/sys/alpha/alpha/machdep.c @@ -156,7 +156,8 @@ struct bootinfo_kernel bootinfo; struct mtx sched_lock; struct mtx Giant; -struct user *proc0paddr; +struct user *proc0uarea; +vm_offset_t proc0kstack; char machine[] = "alpha"; SYSCTL_STRING(_hw, HW_MACHINE, machine, CTLFLAG_RD, machine, 0, ""); @@ -887,23 +888,30 @@ alpha_init(pfn, ptb, bim, bip, biv) } + proc_linkup(&proc0); /* * Init mapping for u page(s) for proc 0 */ - proc0.p_addr = proc0paddr = - (struct user *)pmap_steal_memory(UPAGES * PAGE_SIZE); + proc0uarea = (struct user *)pmap_steal_memory(UAREA_PAGES * PAGE_SIZE); + proc0kstack = pmap_steal_memory(KSTACK_PAGES * PAGE_SIZE); + proc0.p_uarea = proc0uarea; + thread0 = &proc0.p_thread; + thread0->td_kstack = proc0kstack; + thread0->td_pcb = (struct pcb *) + (thread0->td_kstack + KSTACK_PAGES * PAGE_SIZE) - 1; /* * Setup the global data for the bootstrap cpu. */ { - size_t sz = round_page(UPAGES * PAGE_SIZE); + /* This is not a 'struct user' */ + size_t sz = round_page(KSTACK_PAGES * PAGE_SIZE); globalp = (struct globaldata *) pmap_steal_memory(sz); globaldata_init(globalp, alpha_pal_whami(), sz); alpha_pal_wrval((u_int64_t) globalp); PCPU_GET(next_asn) = 1; /* 0 used for proc0 pmap */ #ifdef SMP - proc0.p_md.md_kernnest = 1; + thread0->td_md.md_kernnest = 1; #endif } @@ -921,28 +929,26 @@ alpha_init(pfn, ptb, bim, bip, biv) * Initialize the rest of proc 0's PCB, and cache its physical * address. */ - proc0.p_md.md_pcbpaddr = - (struct pcb *)ALPHA_K0SEG_TO_PHYS((vm_offset_t)&proc0paddr->u_pcb); + thread0->td_md.md_pcbpaddr = + (struct pcb *)ALPHA_K0SEG_TO_PHYS((vm_offset_t)thread0->td_pcb); /* * Set the kernel sp, reserving space for an (empty) trapframe, * and make proc0's trapframe pointer point to it for sanity. */ - proc0paddr->u_pcb.pcb_hw.apcb_ksp = - (u_int64_t)proc0paddr + USPACE - sizeof(struct trapframe); - proc0.p_frame = - (struct trapframe *)proc0paddr->u_pcb.pcb_hw.apcb_ksp; + thread0->td_frame = (struct trapframe *)thread0->td_pcb - 1; + thread0->td_pcb->pcb_hw.apcb_ksp = (u_int64_t)thread0->td_frame; /* * Get the right value for the boot cpu's idle ptbr. */ - globalp->gd_idlepcb.apcb_ptbr = proc0.p_addr->u_pcb.pcb_hw.apcb_ptbr; + globalp->gd_idlepcb.apcb_ptbr = thread0->td_pcb->pcb_hw.apcb_ptbr; - /* Setup curproc so that mutexes work */ - PCPU_SET(curproc, &proc0); + /* Setup curthread so that mutexes work */ + PCPU_SET(curthread, thread0); PCPU_SET(spinlocks, NULL); - LIST_INIT(&proc0.p_contested); + LIST_INIT(&thread0->td_contested); /* * Initialise mutexes. @@ -1175,13 +1181,16 @@ DELAY(int n) void osendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) { - struct proc *p = curproc; + struct proc *p; + struct thread *td; osiginfo_t *sip, ksi; struct trapframe *frame; struct sigacts *psp; int oonstack, fsize, rndfsize; - frame = p->p_frame; + td = curthread; + p = td->td_proc; + frame = td->td_frame; oonstack = sigonstack(alpha_pal_rdusp()); fsize = sizeof ksi; rndfsize = ((fsize + 15) / 16) * 16; @@ -1230,16 +1239,16 @@ osendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) ksi.si_sc.sc_ps = frame->tf_regs[FRAME_PS]; /* copy the registers. */ - fill_regs(p, (struct reg *)ksi.si_sc.sc_regs); + fill_regs(td, (struct reg *)ksi.si_sc.sc_regs); ksi.si_sc.sc_regs[R_ZERO] = 0xACEDBADE; /* magic number */ ksi.si_sc.sc_regs[R_SP] = alpha_pal_rdusp(); /* save the floating-point state, if necessary, then copy it. */ - alpha_fpstate_save(p, 1); /* XXX maybe write=0 */ - ksi.si_sc.sc_ownedfp = p->p_md.md_flags & MDP_FPUSED; - bcopy(&p->p_addr->u_pcb.pcb_fp, (struct fpreg *)ksi.si_sc.sc_fpregs, + alpha_fpstate_save(td, 1); /* XXX maybe write=0 */ + ksi.si_sc.sc_ownedfp = td->td_md.md_flags & MDP_FPUSED; + bcopy(&td->td_pcb->pcb_fp, (struct fpreg *)ksi.si_sc.sc_fpregs, sizeof(struct fpreg)); - ksi.si_sc.sc_fp_control = p->p_addr->u_pcb.pcb_fp_control; + ksi.si_sc.sc_fp_control = td->td_pcb->pcb_fp_control; bzero(ksi.si_sc.sc_reserved, sizeof ksi.si_sc.sc_reserved); /* XXX */ ksi.si_sc.sc_xxx1[0] = 0; /* XXX */ ksi.si_sc.sc_xxx1[1] = 0; /* XXX */ @@ -1279,12 +1288,15 @@ osendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) void sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) { - struct proc *p = curproc; + struct proc *p; + struct thread *td; struct trapframe *frame; struct sigacts *psp; struct sigframe sf, *sfp; int oonstack, rndfsize; + td = curthread; + p = td->td_proc; PROC_LOCK_ASSERT(p, MA_OWNED); psp = p->p_sigacts; #ifdef COMPAT_43 @@ -1294,7 +1306,7 @@ sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) } #endif - frame = p->p_frame; + frame = td->td_frame; oonstack = sigonstack(alpha_pal_rdusp()); rndfsize = ((sizeof(sf) + 15) / 16) * 16; @@ -1306,7 +1318,7 @@ sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE; sf.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0; - fill_regs(p, (struct reg *)sf.sf_uc.uc_mcontext.mc_regs); + fill_regs(td, (struct reg *)sf.sf_uc.uc_mcontext.mc_regs); sf.sf_uc.uc_mcontext.mc_regs[R_SP] = alpha_pal_rdusp(); sf.sf_uc.uc_mcontext.mc_regs[R_ZERO] = 0xACEDBADE; /* magic number */ sf.sf_uc.uc_mcontext.mc_regs[R_PS] = frame->tf_regs[FRAME_PS]; @@ -1362,12 +1374,12 @@ sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) } /* save the floating-point state, if necessary, then copy it. */ - alpha_fpstate_save(p, 1); - sf.sf_uc.uc_mcontext.mc_ownedfp = p->p_md.md_flags & MDP_FPUSED; - bcopy(&p->p_addr->u_pcb.pcb_fp, + alpha_fpstate_save(td, 1); + sf.sf_uc.uc_mcontext.mc_ownedfp = td->td_md.md_flags & MDP_FPUSED; + bcopy(&td->td_pcb->pcb_fp, (struct fpreg *)sf.sf_uc.uc_mcontext.mc_fpregs, sizeof(struct fpreg)); - sf.sf_uc.uc_mcontext.mc_fp_control = p->p_addr->u_pcb.pcb_fp_control; + sf.sf_uc.uc_mcontext.mc_fp_control = td->td_pcb->pcb_fp_control; #ifdef COMPAT_OSF1 /* @@ -1428,12 +1440,13 @@ sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) */ #ifdef COMPAT_43 int -osigreturn(struct proc *p, +osigreturn(struct thread *td, struct osigreturn_args /* { struct osigcontext *sigcntxp; } */ *uap) { struct osigcontext *scp, ksc; + struct proc *p = td->td_proc; scp = uap->sigcntxp; @@ -1470,25 +1483,25 @@ osigreturn(struct proc *p, SIG_CANTMASK(p->p_sigmask); PROC_UNLOCK(p); - set_regs(p, (struct reg *)ksc.sc_regs); - p->p_frame->tf_regs[FRAME_PC] = ksc.sc_pc; - p->p_frame->tf_regs[FRAME_PS] = + set_regs(td, (struct reg *)ksc.sc_regs); + td->td_frame->tf_regs[FRAME_PC] = ksc.sc_pc; + td->td_frame->tf_regs[FRAME_PS] = (ksc.sc_ps | ALPHA_PSL_USERSET) & ~ALPHA_PSL_USERCLR; - p->p_frame->tf_regs[FRAME_FLAGS] = 0; /* full restore */ + td->td_frame->tf_regs[FRAME_FLAGS] = 0; /* full restore */ alpha_pal_wrusp(ksc.sc_regs[R_SP]); /* XXX ksc.sc_ownedfp ? */ - alpha_fpstate_drop(p); - bcopy((struct fpreg *)ksc.sc_fpregs, &p->p_addr->u_pcb.pcb_fp, + alpha_fpstate_drop(td); + bcopy((struct fpreg *)ksc.sc_fpregs, &td->td_pcb->pcb_fp, sizeof(struct fpreg)); - p->p_addr->u_pcb.pcb_fp_control = ksc.sc_fp_control; + td->td_pcb->pcb_fp_control = ksc.sc_fp_control; return (EJUSTRETURN); } #endif int -sigreturn(struct proc *p, +sigreturn(struct thread *td, struct sigreturn_args /* { ucontext_t *sigcntxp; } */ *uap) @@ -1496,14 +1509,16 @@ sigreturn(struct proc *p, ucontext_t uc, *ucp; struct pcb *pcb; unsigned long val; + struct proc *p; #ifdef COMPAT_43 if (((struct osigcontext*)uap->sigcntxp)->sc_regs[R_ZERO] == 0xACEDBADE) - return osigreturn(p, (struct osigreturn_args *)uap); + return osigreturn(td, (struct osigreturn_args *)uap); #endif ucp = uap->sigcntxp; - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; + p = td->td_proc; #ifdef DEBUG if (sigdebug & SDB_FOLLOW) @@ -1519,12 +1534,12 @@ sigreturn(struct proc *p, /* * Restore the user-supplied information */ - set_regs(p, (struct reg *)uc.uc_mcontext.mc_regs); + set_regs(td, (struct reg *)uc.uc_mcontext.mc_regs); val = (uc.uc_mcontext.mc_regs[R_PS] | ALPHA_PSL_USERSET) & ~ALPHA_PSL_USERCLR; - p->p_frame->tf_regs[FRAME_PS] = val; - p->p_frame->tf_regs[FRAME_PC] = uc.uc_mcontext.mc_regs[R_PC]; - p->p_frame->tf_regs[FRAME_FLAGS] = 0; /* full restore */ + td->td_frame->tf_regs[FRAME_PS] = val; + td->td_frame->tf_regs[FRAME_PC] = uc.uc_mcontext.mc_regs[R_PC]; + td->td_frame->tf_regs[FRAME_FLAGS] = 0; /* full restore */ alpha_pal_wrusp(uc.uc_mcontext.mc_regs[R_SP]); PROC_LOCK(p); @@ -1540,10 +1555,10 @@ sigreturn(struct proc *p, PROC_UNLOCK(p); /* XXX ksc.sc_ownedfp ? */ - alpha_fpstate_drop(p); + alpha_fpstate_drop(td); bcopy((struct fpreg *)uc.uc_mcontext.mc_fpregs, - &p->p_addr->u_pcb.pcb_fp, sizeof(struct fpreg)); - p->p_addr->u_pcb.pcb_fp_control = uc.uc_mcontext.mc_fp_control; + &td->td_pcb->pcb_fp, sizeof(struct fpreg)); + td->td_pcb->pcb_fp_control = uc.uc_mcontext.mc_fp_control; #ifdef DEBUG if (sigdebug & SDB_FOLLOW) @@ -1576,14 +1591,14 @@ cpu_halt(void) * Clear registers on exec */ void -setregs(struct proc *p, u_long entry, u_long stack, u_long ps_strings) +setregs(struct thread *td, u_long entry, u_long stack, u_long ps_strings) { - struct trapframe *tfp = p->p_frame; + struct trapframe *tfp = td->td_frame; bzero(tfp->tf_regs, FRAME_SIZE * sizeof tfp->tf_regs[0]); - bzero(&p->p_addr->u_pcb.pcb_fp, sizeof p->p_addr->u_pcb.pcb_fp); - p->p_addr->u_pcb.pcb_fp_control = 0; - p->p_addr->u_pcb.pcb_fp.fpr_cr = (FPCR_DYN_NORMAL + bzero(&td->td_pcb->pcb_fp, sizeof td->td_pcb->pcb_fp); + td->td_pcb->pcb_fp_control = 0; + td->td_pcb->pcb_fp.fpr_cr = (FPCR_DYN_NORMAL | FPCR_INVD | FPCR_DZED | FPCR_OVFD | FPCR_INED | FPCR_UNFD); @@ -1599,20 +1614,20 @@ setregs(struct proc *p, u_long entry, u_long stack, u_long ps_strings) tfp->tf_regs[FRAME_T12] = tfp->tf_regs[FRAME_PC]; /* a.k.a. PV */ tfp->tf_regs[FRAME_FLAGS] = 0; /* full restore */ - p->p_md.md_flags &= ~MDP_FPUSED; - alpha_fpstate_drop(p); + td->td_md.md_flags &= ~MDP_FPUSED; + alpha_fpstate_drop(td); } int -ptrace_set_pc(struct proc *p, unsigned long addr) +ptrace_set_pc(struct thread *td, unsigned long addr) { - struct trapframe *tp = p->p_frame; + struct trapframe *tp = td->td_frame; tp->tf_regs[FRAME_PC] = addr; return 0; } static int -ptrace_read_int(struct proc *p, vm_offset_t addr, u_int32_t *v) +ptrace_read_int(struct thread *td, vm_offset_t addr, u_int32_t *v) { struct iovec iov; struct uio uio; @@ -1624,12 +1639,12 @@ ptrace_read_int(struct proc *p, vm_offset_t addr, u_int32_t *v) uio.uio_resid = sizeof(u_int32_t); uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_READ; - uio.uio_procp = p; - return procfs_domem(curproc, p, NULL, &uio); + uio.uio_td = td; + return procfs_domem(curproc, td->td_proc, NULL, &uio); } static int -ptrace_write_int(struct proc *p, vm_offset_t addr, u_int32_t v) +ptrace_write_int(struct thread *td, vm_offset_t addr, u_int32_t v) { struct iovec iov; struct uio uio; @@ -1641,12 +1656,12 @@ ptrace_write_int(struct proc *p, vm_offset_t addr, u_int32_t v) uio.uio_resid = sizeof(u_int32_t); uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_WRITE; - uio.uio_procp = p; - return procfs_domem(curproc, p, NULL, &uio); + uio.uio_td = td; + return procfs_domem(curproc, td->td_proc, NULL, &uio); } static u_int64_t -ptrace_read_register(struct proc *p, int regno) +ptrace_read_register(struct thread *td, int regno) { static int reg_to_frame[32] = { FRAME_V0, @@ -1689,54 +1704,54 @@ ptrace_read_register(struct proc *p, int regno) if (regno == R_ZERO) return 0; - return p->p_frame->tf_regs[reg_to_frame[regno]]; + return td->td_frame->tf_regs[reg_to_frame[regno]]; } static int -ptrace_clear_bpt(struct proc *p, struct mdbpt *bpt) +ptrace_clear_bpt(struct thread *td, struct mdbpt *bpt) { - return ptrace_write_int(p, bpt->addr, bpt->contents); + return ptrace_write_int(td, bpt->addr, bpt->contents); } static int -ptrace_set_bpt(struct proc *p, struct mdbpt *bpt) +ptrace_set_bpt(struct thread *td, struct mdbpt *bpt) { int error; u_int32_t bpins = 0x00000080; - error = ptrace_read_int(p, bpt->addr, &bpt->contents); + error = ptrace_read_int(td, bpt->addr, &bpt->contents); if (error) return error; - return ptrace_write_int(p, bpt->addr, bpins); + return ptrace_write_int(td, bpt->addr, bpins); } int -ptrace_clear_single_step(struct proc *p) +ptrace_clear_single_step(struct thread *td) { - if (p->p_md.md_flags & MDP_STEP2) { - ptrace_clear_bpt(p, &p->p_md.md_sstep[1]); - ptrace_clear_bpt(p, &p->p_md.md_sstep[0]); - p->p_md.md_flags &= ~MDP_STEP2; - } else if (p->p_md.md_flags & MDP_STEP1) { - ptrace_clear_bpt(p, &p->p_md.md_sstep[0]); - p->p_md.md_flags &= ~MDP_STEP1; + if (td->td_md.md_flags & MDP_STEP2) { + ptrace_clear_bpt(td, &td->td_md.md_sstep[1]); + ptrace_clear_bpt(td, &td->td_md.md_sstep[0]); + td->td_md.md_flags &= ~MDP_STEP2; + } else if (td->td_md.md_flags & MDP_STEP1) { + ptrace_clear_bpt(td, &td->td_md.md_sstep[0]); + td->td_md.md_flags &= ~MDP_STEP1; } return 0; } int -ptrace_single_step(struct proc *p) +ptrace_single_step(struct thread *td) { int error; - vm_offset_t pc = p->p_frame->tf_regs[FRAME_PC]; + vm_offset_t pc = td->td_frame->tf_regs[FRAME_PC]; alpha_instruction ins; vm_offset_t addr[2]; /* places to set breakpoints */ int count = 0; /* count of breakpoints */ - if (p->p_md.md_flags & (MDP_STEP1|MDP_STEP2)) + if (td->td_md.md_flags & (MDP_STEP1|MDP_STEP2)) panic("ptrace_single_step: step breakpoints not removed"); - error = ptrace_read_int(p, pc, &ins.bits); + error = ptrace_read_int(td, pc, &ins.bits); if (error) return error; @@ -1744,7 +1759,7 @@ ptrace_single_step(struct proc *p) case op_j: /* Jump: target is register value */ - addr[0] = ptrace_read_register(p, ins.jump_format.rs) & ~3; + addr[0] = ptrace_read_register(td, ins.jump_format.rs) & ~3; count = 1; break; @@ -1775,20 +1790,20 @@ ptrace_single_step(struct proc *p) count = 1; } - p->p_md.md_sstep[0].addr = addr[0]; - error = ptrace_set_bpt(p, &p->p_md.md_sstep[0]); + td->td_md.md_sstep[0].addr = addr[0]; + error = ptrace_set_bpt(td, &td->td_md.md_sstep[0]); if (error) return error; if (count == 2) { - p->p_md.md_sstep[1].addr = addr[1]; - error = ptrace_set_bpt(p, &p->p_md.md_sstep[1]); + td->td_md.md_sstep[1].addr = addr[1]; + error = ptrace_set_bpt(td, &td->td_md.md_sstep[1]); if (error) { - ptrace_clear_bpt(p, &p->p_md.md_sstep[0]); + ptrace_clear_bpt(td, &td->td_md.md_sstep[0]); return error; } - p->p_md.md_flags |= MDP_STEP2; + td->td_md.md_flags |= MDP_STEP2; } else - p->p_md.md_flags |= MDP_STEP1; + td->td_md.md_flags |= MDP_STEP1; return 0; } @@ -1812,15 +1827,13 @@ alpha_pa_access(vm_offset_t pa) } int -fill_regs(p, regs) - struct proc *p; +fill_regs(td, regs) + struct thread *td; struct reg *regs; { - struct pcb *pcb = &p->p_addr->u_pcb; - struct trapframe *tp = p->p_frame; + struct pcb *pcb = td->td_pcb; + struct trapframe *tp = td->td_frame; - tp = p->p_frame; - #define C(r) regs->r_regs[R_ ## r] = tp->tf_regs[FRAME_ ## r] C(V0); @@ -1839,14 +1852,12 @@ fill_regs(p, regs) } int -set_regs(p, regs) - struct proc *p; +set_regs(td, regs) + struct thread *td; struct reg *regs; { - struct pcb *pcb = &p->p_addr->u_pcb; - struct trapframe *tp = p->p_frame; - - tp = p->p_frame; + struct pcb *pcb = td->td_pcb; + struct trapframe *tp = td->td_frame; #define C(r) tp->tf_regs[FRAME_ ## r] = regs->r_regs[R_ ## r] @@ -1866,24 +1877,24 @@ set_regs(p, regs) } int -fill_fpregs(p, fpregs) - struct proc *p; +fill_fpregs(td, fpregs) + struct thread *td; struct fpreg *fpregs; { - alpha_fpstate_save(p, 0); + alpha_fpstate_save(td, 0); - bcopy(&p->p_addr->u_pcb.pcb_fp, fpregs, sizeof *fpregs); + bcopy(&td->td_pcb->pcb_fp, fpregs, sizeof *fpregs); return (0); } int -set_fpregs(p, fpregs) - struct proc *p; +set_fpregs(td, fpregs) + struct thread *td; struct fpreg *fpregs; { - alpha_fpstate_drop(p); + alpha_fpstate_drop(td); - bcopy(fpregs, &p->p_addr->u_pcb.pcb_fp, sizeof *fpregs); + bcopy(fpregs, &td->td_pcb->pcb_fp, sizeof *fpregs); return (0); } @@ -1976,27 +1987,27 @@ SYSCTL_INT(_machdep, CPU_WALLCLOCK, wall_cmos_clock, CTLFLAG_RW, &wall_cmos_clock, 0, ""); void -alpha_fpstate_check(struct proc *p) +alpha_fpstate_check(struct thread *td) { /* - * For SMP, we should check the fpcurproc of each cpu. + * For SMP, we should check the fpcurthread of each cpu. */ #ifndef SMP critical_t s; s = critical_enter(); - if (p->p_addr->u_pcb.pcb_hw.apcb_flags & ALPHA_PCB_FLAGS_FEN) - if (p != PCPU_GET(fpcurproc)) - panic("alpha_check_fpcurproc: bogus"); + if (td->td_pcb->pcb_hw.apcb_flags & ALPHA_PCB_FLAGS_FEN) + if (td != PCPU_GET(fpcurthread)) + panic("alpha_check_fpcurthread: bogus"); critical_exit(s); #endif } -#define SET_FEN(p) \ - (p)->p_addr->u_pcb.pcb_hw.apcb_flags |= ALPHA_PCB_FLAGS_FEN +#define SET_FEN(td) \ + (td)->td_pcb->pcb_hw.apcb_flags |= ALPHA_PCB_FLAGS_FEN -#define CLEAR_FEN(p) \ - (p)->p_addr->u_pcb.pcb_hw.apcb_flags &= ~ALPHA_PCB_FLAGS_FEN +#define CLEAR_FEN(td) \ + (td)->td_pcb->pcb_hw.apcb_flags &= ~ALPHA_PCB_FLAGS_FEN /* * Save the floating point state in the pcb. Use this to get read-only @@ -2006,14 +2017,14 @@ alpha_fpstate_check(struct proc *p) * FEN trap. */ void -alpha_fpstate_save(struct proc *p, int write) +alpha_fpstate_save(struct thread *td, int write) { critical_t s; s = critical_enter(); - if (p != NULL && p == PCPU_GET(fpcurproc)) { + if (td != NULL && td == PCPU_GET(fpcurthread)) { /* - * If curproc != fpcurproc, then we need to enable FEN + * If curthread != fpcurthread, then we need to enable FEN * so that we can dump the fp state. */ alpha_pal_wrfen(1); @@ -2021,27 +2032,27 @@ alpha_fpstate_save(struct proc *p, int write) /* * Save the state in the pcb. */ - savefpstate(&p->p_addr->u_pcb.pcb_fp); + savefpstate(&td->td_pcb->pcb_fp); if (write) { /* - * If fpcurproc == curproc, just ask the + * If fpcurthread == curthread, just ask the * PALcode to disable FEN, otherwise we must - * clear the FEN bit in fpcurproc's pcb. + * clear the FEN bit in fpcurthread's pcb. */ - if (PCPU_GET(fpcurproc) == curproc) + if (PCPU_GET(fpcurthread) == curthread) alpha_pal_wrfen(0); else - CLEAR_FEN(PCPU_GET(fpcurproc)); - PCPU_SET(fpcurproc, NULL); + CLEAR_FEN(PCPU_GET(fpcurthread)); + PCPU_SET(fpcurthread, NULL); } else { /* * Make sure that we leave FEN enabled if - * curproc == fpcurproc. We must have at most + * curthread == fpcurthread. We must have at most * one process with FEN enabled. Note that FEN - * must already be set in fpcurproc's pcb. + * must already be set in fpcurthread's pcb. */ - if (curproc != PCPU_GET(fpcurproc)) + if (curthread != PCPU_GET(fpcurthread)) alpha_pal_wrfen(0); } } @@ -2054,13 +2065,13 @@ alpha_fpstate_save(struct proc *p, int write) * (e.g. on sigreturn). */ void -alpha_fpstate_drop(struct proc *p) +alpha_fpstate_drop(struct thread *td) { critical_t s; s = critical_enter(); - if (p == PCPU_GET(fpcurproc)) { - if (p == curproc) { + if (td == PCPU_GET(fpcurthread)) { + if (td == curthread) { /* * Disable FEN via the PALcode. This will * clear the bit in the pcb as well. @@ -2070,9 +2081,9 @@ alpha_fpstate_drop(struct proc *p) /* * Clear the FEN bit of the pcb. */ - CLEAR_FEN(p); + CLEAR_FEN(td); } - PCPU_SET(fpcurproc, NULL); + PCPU_SET(fpcurthread, NULL); } critical_exit(s); } @@ -2082,7 +2093,7 @@ alpha_fpstate_drop(struct proc *p) * from the pcb. */ void -alpha_fpstate_switch(struct proc *p) +alpha_fpstate_switch(struct thread *td) { critical_t s; @@ -2091,31 +2102,31 @@ alpha_fpstate_switch(struct proc *p) */ s = critical_enter(); alpha_pal_wrfen(1); - if (PCPU_GET(fpcurproc)) { + if (PCPU_GET(fpcurthread)) { /* * Dump the old fp state if its valid. */ - savefpstate(&PCPU_GET(fpcurproc)->p_addr->u_pcb.pcb_fp); - CLEAR_FEN(PCPU_GET(fpcurproc)); + savefpstate(&PCPU_GET(fpcurthread)->td_pcb->pcb_fp); + CLEAR_FEN(PCPU_GET(fpcurthread)); } /* * Remember the new FP owner and reload its state. */ - PCPU_SET(fpcurproc, p); - restorefpstate(&PCPU_GET(fpcurproc)->p_addr->u_pcb.pcb_fp); + PCPU_SET(fpcurthread, td); + restorefpstate(&PCPU_GET(fpcurthread)->td_pcb->pcb_fp); /* - * If the new owner is curproc, leave FEN enabled, otherwise + * If the new owner is curthread, leave FEN enabled, otherwise * mark its PCB so that it gets FEN when we context switch to * it later. */ - if (p != curproc) { + if (td != curthread) { alpha_pal_wrfen(0); - SET_FEN(p); + SET_FEN(td); } - p->p_md.md_flags |= MDP_FPUSED; + td->td_md.md_flags |= MDP_FPUSED; critical_exit(s); } @@ -2129,7 +2140,7 @@ globaldata_init(struct globaldata *globaldata, int cpuid, size_t sz) globaldata->gd_idlepcbphys = vtophys((vm_offset_t) &globaldata->gd_idlepcb); globaldata->gd_idlepcb.apcb_ksp = (u_int64_t) ((caddr_t) globaldata + sz - sizeof(struct trapframe)); - globaldata->gd_idlepcb.apcb_ptbr = proc0.p_addr->u_pcb.pcb_hw.apcb_ptbr; + globaldata->gd_idlepcb.apcb_ptbr = thread0->td_pcb->pcb_hw.apcb_ptbr; globaldata->gd_cpuid = cpuid; globaldata->gd_next_asn = 0; globaldata->gd_current_asngen = 1; diff --git a/sys/alpha/alpha/mem.c b/sys/alpha/alpha/mem.c index 6af53c4..13bbeb1 100644 --- a/sys/alpha/alpha/mem.c +++ b/sys/alpha/alpha/mem.c @@ -100,12 +100,12 @@ static struct cdevsw mem_cdevsw = { struct mem_range_softc mem_range_softc; static int -mmclose(dev_t dev, int flags, int fmt, struct proc *p) +mmclose(dev_t dev, int flags, int fmt, struct thread *td) { switch (minor(dev)) { #ifdef PERFMON case 32: - return perfmon_close(dev, flags, fmt, p); + return perfmon_close(dev, flags, fmt, td); #endif default: break; @@ -114,7 +114,7 @@ mmclose(dev_t dev, int flags, int fmt, struct proc *p) } static int -mmopen(dev_t dev, int flags, int fmt, struct proc *p) +mmopen(dev_t dev, int flags, int fmt, struct thread *td) { switch (minor(dev)) { @@ -125,7 +125,7 @@ mmopen(dev_t dev, int flags, int fmt, struct proc *p) break; case 32: #ifdef PERFMON - return perfmon_open(dev, flags, fmt, p); + return perfmon_open(dev, flags, fmt, td); #else return ENODEV; #endif @@ -240,12 +240,12 @@ memmmap(dev_t dev, vm_offset_t offset, int prot) } static int -mmioctl(dev_t dev, u_long cmd, caddr_t cmdarg, int flags, struct proc *p) +mmioctl(dev_t dev, u_long cmd, caddr_t cmdarg, int flags, struct thread *td) { switch(minor(dev)) { #ifdef PERFMON case 32: - return perfmon_ioctl(dev, cmd, cmdarg, flags, p); + return perfmon_ioctl(dev, cmd, cmdarg, flags, td); #endif default: return ENODEV; diff --git a/sys/alpha/alpha/mp_machdep.c b/sys/alpha/alpha/mp_machdep.c index 7ae77d5..d1324e7 100644 --- a/sys/alpha/alpha/mp_machdep.c +++ b/sys/alpha/alpha/mp_machdep.c @@ -158,7 +158,7 @@ smp_init_secondary(void) * Set curproc to our per-cpu idleproc so that mutexes have * something unique to lock with. */ - PCPU_SET(curproc, PCPU_GET(idleproc)); + PCPU_SET(curthread, PCPU_GET(idlethread)); PCPU_SET(spinlocks, NULL); /* @@ -175,12 +175,12 @@ smp_init_secondary(void) * * cache idleproc's physical address. */ - curproc->p_md.md_pcbpaddr = (struct pcb *)PCPU_GET(idlepcbphys); + curthread->td_md.md_pcbpaddr = (struct pcb *)PCPU_GET(idlepcbphys); /* * and make idleproc's trapframe pointer point to its * stack pointer for sanity. */ - curproc->p_frame = + curthread->td_frame = (struct trapframe *)globalp->gd_idlepcb.apcb_ksp; mtx_lock_spin(&ap_boot_mtx); @@ -232,7 +232,7 @@ smp_start_secondary(int cpuid) if (bootverbose) printf("smp_start_secondary: starting cpu %d\n", cpuid); - sz = round_page(UPAGES * PAGE_SIZE); + sz = round_page((UAREA_PAGES + KSTACK_PAGES) * PAGE_SIZE); globaldata = malloc(sz, M_TEMP, M_NOWAIT); if (!globaldata) { printf("smp_start_secondary: can't allocate memory\n"); diff --git a/sys/alpha/alpha/pmap.c b/sys/alpha/alpha/pmap.c index eed5e5e..c03d3dd 100644 --- a/sys/alpha/alpha/pmap.c +++ b/sys/alpha/alpha/pmap.c @@ -337,7 +337,7 @@ static pmap_t pmap_active[MAXCPU]; static vm_zone_t pvzone; static struct vm_zone pvzone_store; static struct vm_object pvzone_obj; -static int pv_entry_count=0, pv_entry_max=0, pv_entry_high_water=0; +static int pv_entry_count = 0, pv_entry_max = 0, pv_entry_high_water = 0; static int pmap_pagedaemon_waken = 0; static struct pv_entry *pvinit; @@ -564,9 +564,9 @@ pmap_bootstrap(vm_offset_t ptaddr, u_int maxasn) * Set up proc0's PCB such that the ptbr points to the right place * and has the kernel pmap's. */ - proc0.p_addr->u_pcb.pcb_hw.apcb_ptbr = + thread0->td_pcb->pcb_hw.apcb_ptbr = ALPHA_K0SEG_TO_PHYS((vm_offset_t)Lev1map) >> PAGE_SHIFT; - proc0.p_addr->u_pcb.pcb_hw.apcb_asn = 0; + thread0->td_pcb->pcb_hw.apcb_asn = 0; } int @@ -934,22 +934,22 @@ pmap_new_proc(struct proc *p) */ upobj = p->p_upages_obj; if (upobj == NULL) { - upobj = vm_object_allocate(OBJT_DEFAULT, UPAGES); + upobj = vm_object_allocate(OBJT_DEFAULT, UAREA_PAGES); p->p_upages_obj = upobj; } /* get a kernel virtual address for the UPAGES for this proc */ - up = (vm_offset_t)p->p_addr; + up = (vm_offset_t)p->p_uarea; if (up == 0) { - up = kmem_alloc_nofault(kernel_map, UPAGES * PAGE_SIZE); + up = kmem_alloc_nofault(kernel_map, UAREA_PAGES * PAGE_SIZE); if (up == 0) panic("pmap_new_proc: upage allocation failed"); - p->p_addr = (struct user *)up; + p->p_uarea = (struct user *)up; } ptek = vtopte(up); - for (i = 0; i < UPAGES; i++) { + for (i = 0; i < UAREA_PAGES; i++) { /* * Get a kernel stack page */ @@ -992,9 +992,9 @@ pmap_dispose_proc(p) pt_entry_t *ptek, oldpte; upobj = p->p_upages_obj; - up = (vm_offset_t)p->p_addr; + up = (vm_offset_t)p->p_uarea; ptek = vtopte(up); - for (i = 0; i < UPAGES; i++) { + for (i = 0; i < UAREA_PAGES; i++) { m = vm_page_lookup(upobj, i); if (m == NULL) panic("pmap_dispose_proc: upage already missing?"); @@ -1019,14 +1019,9 @@ pmap_swapout_proc(p) vm_offset_t up; vm_page_t m; - /* - * Make sure we aren't fpcurproc. - */ - alpha_fpstate_save(p, 1); - upobj = p->p_upages_obj; - up = (vm_offset_t)p->p_addr; - for (i = 0; i < UPAGES; i++) { + up = (vm_offset_t)p->p_uarea; + for (i = 0; i < UAREA_PAGES; i++) { m = vm_page_lookup(upobj, i); if (m == NULL) panic("pmap_swapout_proc: upage already missing?"); @@ -1049,8 +1044,8 @@ pmap_swapin_proc(p) vm_page_t m; upobj = p->p_upages_obj; - up = (vm_offset_t)p->p_addr; - for (i = 0; i < UPAGES; i++) { + up = (vm_offset_t)p->p_uarea; + for (i = 0; i < UAREA_PAGES; i++) { m = vm_page_grab(upobj, i, VM_ALLOC_NORMAL | VM_ALLOC_RETRY); pmap_kenter(up + i * PAGE_SIZE, VM_PAGE_TO_PHYS(m)); if (m->valid != VM_PAGE_BITS_ALL) { @@ -1064,12 +1059,180 @@ pmap_swapin_proc(p) vm_page_wakeup(m); vm_page_flag_set(m, PG_MAPPED | PG_WRITEABLE); } +} + +/* + * Create the kernel stack for a new thread. + * This routine directly affects the fork perf for a process and thread. + */ +void +pmap_new_thread(struct thread *td) +{ + int i; + vm_object_t ksobj; + vm_offset_t ks; + vm_page_t m; + pt_entry_t *ptek, oldpte; + + /* + * allocate object for the upages + */ + ksobj = td->td_kstack_obj; + if (ksobj == NULL) { + ksobj = vm_object_allocate(OBJT_DEFAULT, KSTACK_PAGES); + td->td_kstack_obj = ksobj; + } + +#ifdef KSTACK_GUARD + /* get a kernel virtual address for the kstack for this thread */ + ks = td->td_kstack; + if (ks == 0) { + ks = kmem_alloc_nofault(kernel_map, + (KSTACK_PAGES + 1) * PAGE_SIZE); + if (ks == NULL) + panic("pmap_new_thread: kstack allocation failed"); + ks += PAGE_SIZE; + td->td_kstack = ks; + } + + ptek = vtopte(ks - PAGE_SIZE); + oldpte = *ptek; + *ptek = 0; + if (oldpte) + pmap_invalidate_page(kernel_pmap, ks - PAGE_SIZE); + ptek++; +#else + /* get a kernel virtual address for the kstack for this thread */ + ks = td->td_kstack; + if (ks == 0) { + ks = kmem_alloc_nofault(kernel_map, KSTACK_PAGES * PAGE_SIZE); + if (ks == NULL) + panic("pmap_new_thread: kstack allocation failed"); + td->td_kstack = ks; + } + ptek = vtopte(ks); +#endif + for (i = 0; i < KSTACK_PAGES; i++) { + /* + * Get a kernel stack page + */ + m = vm_page_grab(ksobj, i, VM_ALLOC_NORMAL | VM_ALLOC_RETRY); + + /* + * Wire the page + */ + m->wire_count++; + cnt.v_wire_count++; + + oldpte = *(ptek + i); + /* + * Enter the page into the kernel address space. + */ + *(ptek + i) = pmap_phys_to_pte(VM_PAGE_TO_PHYS(m)) + | PG_ASM | PG_KRE | PG_KWE | PG_V; + if (oldpte) + pmap_invalidate_page(kernel_pmap, ks + i * PAGE_SIZE); + + vm_page_wakeup(m); + vm_page_flag_clear(m, PG_ZERO); + vm_page_flag_set(m, PG_MAPPED | PG_WRITEABLE); + m->valid = VM_PAGE_BITS_ALL; + } +} + +/* + * Dispose the kernel stack for a thread that has exited. + * This routine directly impacts the exit perf of a thread. + */ +void +pmap_dispose_thread(td) + struct thread *td; +{ + int i; + vm_object_t ksobj; + vm_offset_t ks; + vm_page_t m; + pt_entry_t *ptek, oldpte; + + ksobj = td->td_kstack_obj; + ks = td->td_kstack; + ptek = vtopte(ks); + for (i = 0; i < KSTACK_PAGES; i++) { + m = vm_page_lookup(ksobj, i); + if (m == NULL) + panic("pmap_dispose_thread: kstack already missing?"); + vm_page_busy(m); + oldpte = *(ptek + i); + *(ptek + i) = 0; + pmap_invalidate_page(kernel_pmap, ks + i * PAGE_SIZE); + vm_page_unwire(m, 0); + vm_page_free(m); + } +} + +/* + * Allow the kernel stack for a thread to be prejudicially paged out. + */ +void +pmap_swapout_thread(td) + struct thread *td; +{ + int i; + vm_object_t ksobj; + vm_offset_t ks; + vm_page_t m; + + /* + * Make sure we aren't fpcurthread. + */ + alpha_fpstate_save(td, 1); + + ksobj = td->td_kstack_obj; + ks = td->td_kstack; + for (i = 0; i < KSTACK_PAGES; i++) { + m = vm_page_lookup(ksobj, i); + if (m == NULL) + panic("pmap_swapout_thread: kstack already missing?"); + vm_page_dirty(m); + vm_page_unwire(m, 0); + pmap_kremove(ks + i * PAGE_SIZE); + } +} + +/* + * Bring the kernel stack for a specified thread back in. + */ +void +pmap_swapin_thread(td) + struct thread *td; +{ + int i, rv; + vm_object_t ksobj; + vm_offset_t ks; + vm_page_t m; + + ksobj = td->td_kstack_obj; + ks = td->td_kstack; + for (i = 0; i < KSTACK_PAGES; i++) { + m = vm_page_grab(ksobj, i, VM_ALLOC_NORMAL | VM_ALLOC_RETRY); + pmap_kenter(ks + i * PAGE_SIZE, VM_PAGE_TO_PHYS(m)); + if (m->valid != VM_PAGE_BITS_ALL) { + rv = vm_pager_get_pages(ksobj, &m, 1, 0); + if (rv != VM_PAGER_OK) + panic("pmap_swapin_thread: cannot get kstack for proc: %d\n", td->td_proc->p_pid); + m = vm_page_lookup(ksobj, i); + m->valid = VM_PAGE_BITS_ALL; + } + vm_page_wire(m); + vm_page_wakeup(m); + vm_page_flag_set(m, PG_MAPPED | PG_WRITEABLE); + } /* * The pcb may be at a different physical address now so cache the * new address. */ - p->p_md.md_pcbpaddr = (void*)vtophys((vm_offset_t)&p->p_addr->u_pcb); + td->td_md.md_pcbpaddr = (void *)vtophys((vm_offset_t)td->td_pcb); } /*************************************************** @@ -1677,7 +1840,7 @@ pmap_collect() { int i; vm_page_t m; - static int warningdone=0; + static int warningdone = 0; if (pmap_pagedaemon_waken == 0) return; @@ -2917,7 +3080,7 @@ pmap_clear_reference(vm_page_t m) * From NetBSD */ void -pmap_emulate_reference(struct proc *p, vm_offset_t v, int user, int write) +pmap_emulate_reference(struct vmspace *vm, vm_offset_t v, int user, int write) { pt_entry_t faultoff, *pte; vm_offset_t pa; @@ -2932,9 +3095,8 @@ pmap_emulate_reference(struct proc *p, vm_offset_t v, int user, int write) pte = vtopte(v); user_addr = 0; } else { - KASSERT(p != NULL, ("pmap_emulate_reference: bad proc")); - KASSERT(p->p_vmspace != NULL, ("pmap_emulate_reference: bad p_vmspace")); - pte = pmap_lev3pte(p->p_vmspace->vm_map.pmap, v); + KASSERT(vm != NULL, ("pmap_emulate_reference: bad vmspace")); + pte = pmap_lev3pte(vm->vm_map.pmap, v); user_addr = 1; } #ifdef DEBUG /* These checks are more expensive */ @@ -2964,7 +3126,7 @@ pmap_emulate_reference(struct proc *p, vm_offset_t v, int user, int write) KASSERT((*pte & PG_MANAGED) != 0, ("pmap_emulate_reference(%p, 0x%lx, %d, %d): pa 0x%lx not managed", - p, v, user, write, pa)); + curthread, v, user, write, pa)); /* * Twiddle the appropriate bits to reflect the reference @@ -3092,11 +3254,11 @@ pmap_mincore(pmap, addr) } void -pmap_activate(struct proc *p) +pmap_activate(struct thread *td) { pmap_t pmap; - pmap = vmspace_pmap(p->p_vmspace); + pmap = vmspace_pmap(td->td_proc->p_vmspace); if (pmap_active[PCPU_GET(cpuid)] && pmap != pmap_active[PCPU_GET(cpuid)]) { atomic_clear_32(&pmap_active[PCPU_GET(cpuid)]->pm_active, @@ -3104,7 +3266,7 @@ pmap_activate(struct proc *p) pmap_active[PCPU_GET(cpuid)] = 0; } - p->p_addr->u_pcb.pcb_hw.apcb_ptbr = + td->td_pcb->pcb_hw.apcb_ptbr = ALPHA_K0SEG_TO_PHYS((vm_offset_t) pmap->pm_lev1) >> PAGE_SHIFT; if (pmap->pm_asn[PCPU_GET(cpuid)].gen != PCPU_GET(current_asngen)) @@ -3113,18 +3275,19 @@ pmap_activate(struct proc *p) pmap_active[PCPU_GET(cpuid)] = pmap; atomic_set_32(&pmap->pm_active, 1 << PCPU_GET(cpuid)); - p->p_addr->u_pcb.pcb_hw.apcb_asn = pmap->pm_asn[PCPU_GET(cpuid)].asn; + td->td_pcb->pcb_hw.apcb_asn = pmap->pm_asn[PCPU_GET(cpuid)].asn; - if (p == curproc) { - alpha_pal_swpctx((u_long)p->p_md.md_pcbpaddr); + if (td == curthread) { + alpha_pal_swpctx((u_long)td->td_md.md_pcbpaddr); } } void -pmap_deactivate(struct proc *p) +pmap_deactivate(struct thread *td) { pmap_t pmap; - pmap = vmspace_pmap(p->p_vmspace); + + pmap = vmspace_pmap(td->td_proc->p_vmspace); atomic_clear_32(&pmap->pm_active, 1 << PCPU_GET(cpuid)); pmap_active[PCPU_GET(cpuid)] = 0; } @@ -3154,14 +3317,14 @@ pmap_pid_dump(int pid) int i,j; index = 0; pmap = vmspace_pmap(p->p_vmspace); - for(i=0;i<1024;i++) { + for (i = 0; i < 1024; i++) { pd_entry_t *pde; pt_entry_t *pte; unsigned base = i << PDRSHIFT; pde = &pmap->pm_pdir[i]; if (pde && pmap_pde_v(pde)) { - for(j=0;j<1024;j++) { + for (j = 0; j < 1024; j++) { unsigned va = base + (j << PAGE_SHIFT); if (va >= (vm_offset_t) VM_MIN_KERNEL_ADDRESS) { if (index) { diff --git a/sys/alpha/alpha/procfs_machdep.c b/sys/alpha/alpha/procfs_machdep.c index 96fd0e5..ae7fa10 100644 --- a/sys/alpha/alpha/procfs_machdep.c +++ b/sys/alpha/alpha/procfs_machdep.c @@ -85,7 +85,7 @@ int error; \ \ mtx_lock_spin(&sched_lock); \ - if ((p->p_sflag & PS_INMEM) == 0) \ + if ((td->td_proc->p_sflag & PS_INMEM) == 0) \ error = EIO; \ else \ error = (action); \ @@ -94,21 +94,21 @@ } while(0) int -procfs_read_regs(p, regs) - struct proc *p; +procfs_read_regs(td, regs) + struct thread *td; struct reg *regs; { - PROCFS_ACTION(fill_regs(p, regs)); + PROCFS_ACTION(fill_regs(td, regs)); } int -procfs_write_regs(p, regs) - struct proc *p; +procfs_write_regs(td, regs) + struct thread *td; struct reg *regs; { - PROCFS_ACTION(set_regs(p, regs)); + PROCFS_ACTION(set_regs(td, regs)); } /* @@ -117,26 +117,26 @@ procfs_write_regs(p, regs) */ int -procfs_read_fpregs(p, fpregs) - struct proc *p; +procfs_read_fpregs(td, fpregs) + struct thread *td; struct fpreg *fpregs; { - PROCFS_ACTION(fill_fpregs(p, fpregs)); + PROCFS_ACTION(fill_fpregs(td, fpregs)); } int -procfs_write_fpregs(p, fpregs) - struct proc *p; +procfs_write_fpregs(td, fpregs) + struct thread *td; struct fpreg *fpregs; { - PROCFS_ACTION(set_fpregs(p, fpregs)); + PROCFS_ACTION(set_fpregs(td, fpregs)); } int -procfs_sstep(p) - struct proc *p; +procfs_sstep(td) + struct thread *td; { return (EINVAL); } @@ -145,16 +145,16 @@ procfs_sstep(p) * Placeholders */ int -procfs_read_dbregs(p, dbregs) - struct proc *p; +procfs_read_dbregs(td, dbregs) + struct thread *td; struct dbreg *dbregs; { return (EIO); } int -procfs_write_dbregs(p, dbregs) - struct proc *p; +procfs_write_dbregs(td, dbregs) + struct thread *td; struct dbreg *dbregs; { return (EIO); diff --git a/sys/alpha/alpha/prom.c b/sys/alpha/alpha/prom.c index 887f991..54d913a 100644 --- a/sys/alpha/alpha/prom.c +++ b/sys/alpha/alpha/prom.c @@ -315,8 +315,8 @@ hwrpb_restart_setup() p = (struct pcs *)((char *)hwrpb + hwrpb->rpb_pcs_off); p->pcs_flags &= ~PCS_BIP; - bcopy(&proc0.p_addr->u_pcb.pcb_hw, p->pcs_hwpcb, - sizeof proc0.p_addr->u_pcb.pcb_hw); + bcopy(&thread0->td_pcb->pcb_hw, p->pcs_hwpcb, + sizeof thread0->td_pcb->pcb_hw); hwrpb->rpb_vptb = VPTBASE; /* when 'c'ontinuing from console halt, do a dump */ diff --git a/sys/alpha/alpha/promcons.c b/sys/alpha/alpha/promcons.c index fa0511d..e95d951 100644 --- a/sys/alpha/alpha/promcons.c +++ b/sys/alpha/alpha/promcons.c @@ -92,10 +92,10 @@ int promparam __P((struct tty *, struct termios *)); void promstop __P((struct tty *, int)); int -promopen(dev, flag, mode, p) +promopen(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { struct tty *tp; int unit = minor(dev); @@ -124,7 +124,7 @@ promopen(dev, flag, mode, p) ttsetwater(tp); setuptimeout = 1; - } else if ((tp->t_state & TS_XCLUDE) && suser(p)) { + } else if ((tp->t_state & TS_XCLUDE) && suser(td->td_proc)) { splx(s); return EBUSY; } @@ -143,10 +143,10 @@ promopen(dev, flag, mode, p) } int -promclose(dev, flag, mode, p) +promclose(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { int unit = minor(dev); struct tty *tp = prom_tp; @@ -161,12 +161,12 @@ promclose(dev, flag, mode, p) } int -promioctl(dev, cmd, data, flag, p) +promioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { int unit = minor(dev); struct tty *tp = prom_tp; @@ -175,7 +175,7 @@ promioctl(dev, cmd, data, flag, p) if (unit != 0) return ENXIO; - error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); + error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, td); if (error != ENOIOCTL) return error; error = ttioctl(tp, cmd, data, flag); diff --git a/sys/alpha/alpha/support.s b/sys/alpha/alpha/support.s index 6c42b81..61c692e 100644 --- a/sys/alpha/alpha/support.s +++ b/sys/alpha/alpha/support.s @@ -72,13 +72,13 @@ beq t1, fusufault lda t0, fusufault /* trap faults */ - ldq t2, GD_CURPROC(globalp) - ldq t2, P_ADDR(t2) - stq t0, U_PCB_ONFAULT(t2) + ldq t2, GD_CURTHREAD(globalp) + ldq t2, TD_PCB(t2) + stq t0, PCB_ONFAULT(t2) stq a1, 0(a0) /* try the store */ - stq zero, U_PCB_ONFAULT(t2) /* clean up */ + stq zero, PCB_ONFAULT(t2) /* clean up */ mov zero, v0 RET @@ -92,9 +92,9 @@ beq t1, fusufault lda t0, fusufault /* trap faults */ - ldq t2, GD_CURPROC(globalp) - ldq t2, P_ADDR(t2) - stq t0, U_PCB_ONFAULT(t2) + ldq t2, GD_CURTHREAD(globalp) + ldq t2, TD_PCB(t2) + stq t0, PCB_ONFAULT(t2) zap a1, 0xfe, a1 /* mask off the byte to store */ insbl a1, a0, a1 /* shift it to the right place */ @@ -103,7 +103,7 @@ or a1, t0, a1 /* move it in */ stq_u a1, 0(a0) /* and put the byte back */ - stq zero, U_PCB_ONFAULT(t2) /* clean up */ + stq zero, PCB_ONFAULT(t2) /* clean up */ mov zero, v0 RET @@ -117,13 +117,13 @@ beq t1, fusufault lda t0, fusufault /* trap faults */ - ldq t2, GD_CURPROC(globalp) - ldq t2, P_ADDR(t2) - stq t0, U_PCB_ONFAULT(t2) + ldq t2, GD_CURTHREAD(globalp) + ldq t2, TD_PCB(t2) + stq t0, PCB_ONFAULT(t2) ldq v0, 0(a0) /* try the fetch */ - stq zero, U_PCB_ONFAULT(t2) /* clean up */ + stq zero, PCB_ONFAULT(t2) /* clean up */ RET END(fuword) @@ -136,14 +136,14 @@ beq t1, fusufault lda t0, fusufault /* trap faults */ - ldq t2, GD_CURPROC(globalp) - ldq t2, P_ADDR(t2) - stq t0, U_PCB_ONFAULT(t2) + ldq t2, GD_CURTHREAD(globalp) + ldq t2, TD_PCB(t2) + stq t0, PCB_ONFAULT(t2) ldq_u v0, 0(a0) /* get the word containing our byte */ extbl v0, a0, v0 /* extract the byte */ - stq zero, U_PCB_ONFAULT(t2) /* clean up */ + stq zero, PCB_ONFAULT(t2) /* clean up */ RET END(fubyte) @@ -154,9 +154,9 @@ END(suibyte) LEAF(fusufault, 0) - ldq t0, GD_CURPROC(globalp) - ldq t0, P_ADDR(t0) - stq zero, U_PCB_ONFAULT(t0) + ldq t0, GD_CURTHREAD(globalp) + ldq t0, TD_PCB(t0) + stq zero, PCB_ONFAULT(t0) ldiq v0, -1 RET END(fusufault) @@ -222,15 +222,15 @@ NESTED(copyinstr, 4, 16, ra, 0, 0) beq t1, copyerr /* if it's not, error out. */ lda v0, copyerr /* set up fault handler. */ .set noat - ldq at_reg, GD_CURPROC(globalp) - ldq at_reg, P_ADDR(at_reg) - stq v0, U_PCB_ONFAULT(at_reg) + ldq at_reg, GD_CURTHREAD(globalp) + ldq at_reg, TD_PCB(at_reg) + stq v0, PCB_ONFAULT(at_reg) .set at CALL(copystr) /* do the copy. */ .set noat - ldq at_reg, GD_CURPROC(globalp) /* kill the fault handler. */ - ldq at_reg, P_ADDR(at_reg) - stq zero, U_PCB_ONFAULT(at_reg) + ldq at_reg, GD_CURTHREAD(globalp) /* kill the fault handler. */ + ldq at_reg, TD_PCB(at_reg) + stq zero, PCB_ONFAULT(at_reg) .set at ldq ra, (16-8)(sp) /* restore ra. */ lda sp, 16(sp) /* kill stack frame. */ @@ -246,15 +246,15 @@ NESTED(copyoutstr, 4, 16, ra, 0, 0) beq t1, copyerr /* if it's not, error out. */ lda v0, copyerr /* set up fault handler. */ .set noat - ldq at_reg, GD_CURPROC(globalp) - ldq at_reg, P_ADDR(at_reg) - stq v0, U_PCB_ONFAULT(at_reg) + ldq at_reg, GD_CURTHREAD(globalp) + ldq at_reg, TD_PCB(at_reg) + stq v0, PCB_ONFAULT(at_reg) .set at CALL(copystr) /* do the copy. */ .set noat - ldq at_reg, GD_CURPROC(globalp) /* kill the fault handler. */ - ldq at_reg, P_ADDR(at_reg) - stq zero, U_PCB_ONFAULT(at_reg) + ldq at_reg, GD_CURTHREAD(globalp) /* kill the fault handler. */ + ldq at_reg, TD_PCB(at_reg) + stq zero, PCB_ONFAULT(at_reg) .set at ldq ra, (16-8)(sp) /* restore ra. */ lda sp, 16(sp) /* kill stack frame. */ @@ -514,15 +514,15 @@ NESTED(copyin, 3, 16, ra, 0, 0) beq t1, copyerr /* if it's not, error out. */ lda v0, copyerr /* set up fault handler. */ .set noat - ldq at_reg, GD_CURPROC(globalp) - ldq at_reg, P_ADDR(at_reg) - stq v0, U_PCB_ONFAULT(at_reg) + ldq at_reg, GD_CURTHREAD(globalp) + ldq at_reg, TD_PCB(at_reg) + stq v0, PCB_ONFAULT(at_reg) .set at CALL(bcopy) /* do the copy. */ .set noat - ldq at_reg, GD_CURPROC(globalp) /* kill the fault handler. */ - ldq at_reg, P_ADDR(at_reg) - stq zero, U_PCB_ONFAULT(at_reg) + ldq at_reg, GD_CURTHREAD(globalp) /* kill the fault handler. */ + ldq at_reg, TD_PCB(at_reg) + stq zero, PCB_ONFAULT(at_reg) .set at ldq ra, (16-8)(sp) /* restore ra. */ lda sp, 16(sp) /* kill stack frame. */ @@ -539,15 +539,15 @@ NESTED(copyout, 3, 16, ra, 0, 0) beq t1, copyerr /* if it's not, error out. */ lda v0, copyerr /* set up fault handler. */ .set noat - ldq at_reg, GD_CURPROC(globalp) - ldq at_reg, P_ADDR(at_reg) - stq v0, U_PCB_ONFAULT(at_reg) + ldq at_reg, GD_CURTHREAD(globalp) + ldq at_reg, TD_PCB(at_reg) + stq v0, PCB_ONFAULT(at_reg) .set at CALL(bcopy) /* do the copy. */ .set noat - ldq at_reg, GD_CURPROC(globalp) /* kill the fault handler. */ - ldq at_reg, P_ADDR(at_reg) - stq zero, U_PCB_ONFAULT(at_reg) + ldq at_reg, GD_CURTHREAD(globalp) /* kill the fault handler. */ + ldq at_reg, TD_PCB(at_reg) + stq zero, PCB_ONFAULT(at_reg) .set at ldq ra, (16-8)(sp) /* restore ra. */ lda sp, 16(sp) /* kill stack frame. */ @@ -556,9 +556,9 @@ NESTED(copyout, 3, 16, ra, 0, 0) END(copyout) LEAF(copyerr, 0) - ldq t0, GD_CURPROC(globalp) - ldq t0, P_ADDR(t0) - stq zero, U_PCB_ONFAULT(t0) /* reset fault handler. */ + ldq t0, GD_CURTHREAD(globalp) + ldq t0, TD_PCB(t0) + stq zero, PCB_ONFAULT(t0) /* reset fault handler. */ ldq ra, (16-8)(sp) /* restore ra. */ lda sp, 16(sp) /* kill stack frame. */ ldiq v0, EFAULT /* return EFAULT. */ diff --git a/sys/alpha/alpha/swtch.s b/sys/alpha/alpha/swtch.s index 0d244fc..79454c5 100644 --- a/sys/alpha/alpha/swtch.s +++ b/sys/alpha/alpha/swtch.s @@ -49,13 +49,13 @@ /* * savectx: save process context, i.e. callee-saved registers * - * Note that savectx() only works for processes other than curproc, + * Note that savectx() only works for processes other than curthread, * since cpu_switch will copy over the info saved here. (It _can_ - * sanely be used for curproc iff cpu_switch won't be called again, e.g. + * sanely be used for curthread iff cpu_switch won't be called again, e.g. * from if called from boot().) * * Arguments: - * a0 'struct user *' of the process that needs its context saved + * a0 'struct pcb *' of the process that needs its context saved * * Return: * v0 0. (note that for child processes, it seems @@ -66,17 +66,17 @@ LEAF(savectx, 1) br pv, Lsavectx1 Lsavectx1: LDGP(pv) - stq sp, U_PCB_HWPCB_KSP(a0) /* store sp */ - stq s0, U_PCB_CONTEXT+(0 * 8)(a0) /* store s0 - s6 */ - stq s1, U_PCB_CONTEXT+(1 * 8)(a0) - stq s2, U_PCB_CONTEXT+(2 * 8)(a0) - stq s3, U_PCB_CONTEXT+(3 * 8)(a0) - stq s4, U_PCB_CONTEXT+(4 * 8)(a0) - stq s5, U_PCB_CONTEXT+(5 * 8)(a0) - stq s6, U_PCB_CONTEXT+(6 * 8)(a0) - stq ra, U_PCB_CONTEXT+(7 * 8)(a0) /* store ra */ + stq sp, PCB_HWPCB_KSP(a0) /* store sp */ + stq s0, PCB_CONTEXT+(0 * 8)(a0) /* store s0 - s6 */ + stq s1, PCB_CONTEXT+(1 * 8)(a0) + stq s2, PCB_CONTEXT+(2 * 8)(a0) + stq s3, PCB_CONTEXT+(3 * 8)(a0) + stq s4, PCB_CONTEXT+(4 * 8)(a0) + stq s5, PCB_CONTEXT+(5 * 8)(a0) + stq s6, PCB_CONTEXT+(6 * 8)(a0) + stq ra, PCB_CONTEXT+(7 * 8)(a0) /* store ra */ call_pal PAL_OSF1_rdps /* NOTE: doesn't kill a0 */ - stq v0, U_PCB_CONTEXT+(8 * 8)(a0) /* store ps, for ipl */ + stq v0, PCB_CONTEXT+(8 * 8)(a0) /* store ps, for ipl */ mov zero, v0 RET @@ -103,49 +103,49 @@ LEAF(cpu_throw, 0) LEAF(cpu_switch, 1) LDGP(pv) /* do an inline savectx(), to save old context */ - ldq a0, GD_CURPROC(globalp) - ldq a1, P_ADDR(a0) + ldq a0, GD_CURTHREAD(globalp) + ldq a1, TD_PCB(a0) /* NOTE: ksp is stored by the swpctx */ - stq s0, U_PCB_CONTEXT+(0 * 8)(a1) /* store s0 - s6 */ - stq s1, U_PCB_CONTEXT+(1 * 8)(a1) - stq s2, U_PCB_CONTEXT+(2 * 8)(a1) - stq s3, U_PCB_CONTEXT+(3 * 8)(a1) - stq s4, U_PCB_CONTEXT+(4 * 8)(a1) - stq s5, U_PCB_CONTEXT+(5 * 8)(a1) - stq s6, U_PCB_CONTEXT+(6 * 8)(a1) - stq ra, U_PCB_CONTEXT+(7 * 8)(a1) /* store ra */ + stq s0, PCB_CONTEXT+(0 * 8)(a1) /* store s0 - s6 */ + stq s1, PCB_CONTEXT+(1 * 8)(a1) + stq s2, PCB_CONTEXT+(2 * 8)(a1) + stq s3, PCB_CONTEXT+(3 * 8)(a1) + stq s4, PCB_CONTEXT+(4 * 8)(a1) + stq s5, PCB_CONTEXT+(5 * 8)(a1) + stq s6, PCB_CONTEXT+(6 * 8)(a1) + stq ra, PCB_CONTEXT+(7 * 8)(a1) /* store ra */ call_pal PAL_OSF1_rdps /* NOTE: doesn't kill a0 */ - stq v0, U_PCB_CONTEXT+(8 * 8)(a1) /* store ps, for ipl */ + stq v0, PCB_CONTEXT+(8 * 8)(a1) /* store ps, for ipl */ - mov a0, s0 /* save old curproc */ - mov a1, s1 /* save old U-area */ + mov a0, s0 /* s0 = old curthread */ + mov a1, s1 /* s1 = old pcb */ sw1: br pv, Lcs1 Lcs1: LDGP(pv) - CALL(chooseproc) /* can't return NULL */ - mov v0, s2 - ldq s3, P_MD_PCBPADDR(s2) /* save new pcbpaddr */ + CALL(choosethread) /* can't return NULL */ + mov v0, s2 /* s2 = new thread */ + ldq s3, TD_MD_PCBPADDR(s2) /* s3 = new pcbpaddr */ /* * Check to see if we're switching to ourself. If we are, * don't bother loading the new context. * * Note that even if we re-enter cpu_switch() from idle(), - * s0 will still contain the old curproc value because any + * s0 will still contain the old curthread value because any * users of that register between then and now must have * saved it. Also note that switch_exit() ensures that * s0 is clear before jumping here to find a new process. */ - cmpeq s0, s2, t0 /* oldproc == newproc? */ + cmpeq s0, s2, t0 /* oldthread == newthread? */ bne t0, Lcs7 /* Yes! Skip! */ #ifdef SMP /* * Save fp state if we have some. */ - mov s0, a0 /* curproc */ - ldiq a1, 1 /* clear fpcurproc */ + mov s0, a0 /* curthread */ + ldiq a1, 1 /* clear fpcurthread */ CALL(alpha_fpstate_save) #endif @@ -165,8 +165,8 @@ Lcs1: LDGP(pv) */ beq s0, Lcs6 - mov s0, a0 /* pmap_deactivate(oldproc) */ - CALL(pmap_deactivate) + mov s0, a0 /* pmap_deactivate(oldthread) */ + CALL(pmap_deactivate) /* XXXKSE */ Lcs6: /* @@ -174,8 +174,8 @@ Lcs6: * the actual context swap. */ - mov s2, a0 /* pmap_activate(p) */ - CALL(pmap_activate) + mov s2, a0 /* pmap_activate(newthread) */ + CALL(pmap_activate) /* XXXKSE */ mov s3, a0 /* swap the context */ SWITCH_CONTEXT @@ -183,28 +183,28 @@ Lcs6: Lcs7: /* - * Now that the switch is done, update curproc and other + * Now that the switch is done, update curthread and other * globals. We must do this even if switching to ourselves * because we might have re-entered cpu_switch() from idle(), - * in which case curproc would be NULL. + * in which case curthread would be NULL. */ - stq s2, GD_CURPROC(globalp) /* curproc = p */ + stq s2, GD_CURTHREAD(globalp) /* curthread = p */ /* * Now running on the new u struct. * Restore registers and return. */ - ldq t0, P_ADDR(s2) + ldq t0, TD_PCB(s2) /* NOTE: ksp is restored by the swpctx */ - ldq s0, U_PCB_CONTEXT+(0 * 8)(t0) /* restore s0 - s6 */ - ldq s1, U_PCB_CONTEXT+(1 * 8)(t0) - ldq s2, U_PCB_CONTEXT+(2 * 8)(t0) - ldq s3, U_PCB_CONTEXT+(3 * 8)(t0) - ldq s4, U_PCB_CONTEXT+(4 * 8)(t0) - ldq s5, U_PCB_CONTEXT+(5 * 8)(t0) - ldq s6, U_PCB_CONTEXT+(6 * 8)(t0) - ldq ra, U_PCB_CONTEXT+(7 * 8)(t0) /* restore ra */ + ldq s0, PCB_CONTEXT+(0 * 8)(t0) /* restore s0 - s6 */ + ldq s1, PCB_CONTEXT+(1 * 8)(t0) + ldq s2, PCB_CONTEXT+(2 * 8)(t0) + ldq s3, PCB_CONTEXT+(3 * 8)(t0) + ldq s4, PCB_CONTEXT+(4 * 8)(t0) + ldq s5, PCB_CONTEXT+(5 * 8)(t0) + ldq s6, PCB_CONTEXT+(6 * 8)(t0) + ldq ra, PCB_CONTEXT+(7 * 8)(t0) /* restore ra */ ldiq v0, 1 /* possible ret to savectx() */ RET diff --git a/sys/alpha/alpha/sys_machdep.c b/sys/alpha/alpha/sys_machdep.c index ea0f49c..0d304cb 100644 --- a/sys/alpha/alpha/sys_machdep.c +++ b/sys/alpha/alpha/sys_machdep.c @@ -63,34 +63,34 @@ struct sysarch_args { }; #endif -static int alpha_sethae(struct proc *p, char *args); -static int alpha_get_fpmask(struct proc *p, char *args); -static int alpha_set_fpmask(struct proc *p, char *args); -static int alpha_set_uac(struct proc *p, char *args); -static int alpha_get_uac(struct proc *p, char *args); +static int alpha_sethae(struct thread *td, char *args); +static int alpha_get_fpmask(struct thread *td, char *args); +static int alpha_set_fpmask(struct thread *td, char *args); +static int alpha_set_uac(struct thread *td, char *args); +static int alpha_get_uac(struct thread *td, char *args); int -sysarch(p, uap) - struct proc *p; +sysarch(td, uap) + struct thread *td; register struct sysarch_args *uap; { int error = 0; switch(SCARG(uap,op)) { case ALPHA_SETHAE: - error = alpha_sethae(p, uap->parms); + error = alpha_sethae(td, uap->parms); break; case ALPHA_GET_FPMASK: - error = alpha_get_fpmask(p, uap->parms); + error = alpha_get_fpmask(td, uap->parms); break; case ALPHA_SET_FPMASK: - error = alpha_set_fpmask(p, uap->parms); + error = alpha_set_fpmask(td, uap->parms); break; case ALPHA_SET_UAC: - error = alpha_set_uac(p, uap->parms); + error = alpha_set_uac(td, uap->parms); break; case ALPHA_GET_UAC: - error = alpha_get_uac(p, uap->parms); + error = alpha_get_uac(td, uap->parms); break; default: @@ -105,7 +105,7 @@ struct alpha_sethae_args { }; static int -alpha_sethae(struct proc *p, char *args) +alpha_sethae(struct thread *td, char *args) { int error; struct alpha_sethae_args ua; @@ -117,12 +117,12 @@ alpha_sethae(struct proc *p, char *args) if (securelevel > 0) return (EPERM); - error = suser(p); + error = suser(td->td_proc); if (error) return (error); - p->p_md.md_flags |= MDP_HAEUSED; - p->p_md.md_hae = ua.hae; + td->td_md.md_flags |= MDP_HAEUSED; + td->td_md.md_hae = ua.hae; return (0); } @@ -132,19 +132,19 @@ struct alpha_fpmask_args { }; static int -alpha_get_fpmask(struct proc *p, char *args) +alpha_get_fpmask(struct thread *td, char *args) { int error; struct alpha_fpmask_args ua; - ua.mask = p->p_addr->u_pcb.pcb_fp_control; + ua.mask = td->td_pcb->pcb_fp_control; error = copyout(&ua, args, sizeof(struct alpha_fpmask_args)); return (error); } static int -alpha_set_fpmask(struct proc *p, char *args) +alpha_set_fpmask(struct thread *td, char *args) { int error; u_int64_t oldmask, *fp_control; @@ -154,7 +154,7 @@ alpha_set_fpmask(struct proc *p, char *args) if (error) return (error); - fp_control = &p->p_addr->u_pcb.pcb_fp_control; + fp_control = &td->td_pcb->pcb_fp_control; oldmask = *fp_control; *fp_control = ua.mask & IEEE_TRAP_ENABLE_MASK; ua.mask = oldmask; @@ -164,20 +164,23 @@ alpha_set_fpmask(struct proc *p, char *args) } static int -alpha_set_uac(struct proc *p, char *args) +alpha_set_uac(struct thread *td, char *args) { int error; unsigned long uac; + struct proc *p; error = copyin(args, &uac, sizeof(uac)); if (error) return (error); + p = td->td_proc; PROC_LOCK(p); if (p->p_pptr) { PROC_LOCK(p->p_pptr); - p->p_pptr->p_md.md_flags &= ~MDP_UAC_MASK; - p->p_pptr->p_md.md_flags |= uac & MDP_UAC_MASK; + /* XXXKSE which threads? */ + p->p_pptr->p_thread.td_md.md_flags &= ~MDP_UAC_MASK; + p->p_pptr->p_thread.td_md.md_flags |= uac & MDP_UAC_MASK; PROC_UNLOCK(p->p_pptr); } PROC_UNLOCK(p); @@ -185,16 +188,19 @@ alpha_set_uac(struct proc *p, char *args) } static int -alpha_get_uac(struct proc *p, char *args) +alpha_get_uac(struct thread *td, char *args) { + struct proc *p; int error; unsigned long uac; + p = td->td_proc; error = ESRCH; PROC_LOCK(p); if (p->p_pptr) { PROC_LOCK(p->p_pptr); - uac = p->p_pptr->p_md.md_flags & MDP_UAC_MASK; + /* XXXKSE which threads? */ + uac = p->p_pptr->p_thread.td_md.md_flags & MDP_UAC_MASK; PROC_UNLOCK(p->p_pptr); PROC_UNLOCK(p); error = copyout(&uac, args, sizeof(uac)); 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); diff --git a/sys/alpha/alpha/vm_machdep.c b/sys/alpha/alpha/vm_machdep.c index 0aec807..6e302cd 100644 --- a/sys/alpha/alpha/vm_machdep.c +++ b/sys/alpha/alpha/vm_machdep.c @@ -118,30 +118,35 @@ vm_fault_quick(v, prot) * ready to run and return to user mode. */ void -cpu_fork(p1, p2, flags) - register struct proc *p1, *p2; +cpu_fork(td1, p2, flags) + register struct thread *td1; + register struct proc *p2; int flags; { - struct user *up; + struct proc *p1; + struct thread *td2; struct trapframe *p2tf; if ((flags & RFPROC) == 0) return; - p2->p_frame = p1->p_frame; - p2->p_md.md_flags = p1->p_md.md_flags & (MDP_FPUSED | MDP_UAC_MASK); + p1 = td1->td_proc; + td2 = &p2->p_thread; + td2->td_pcb = (struct pcb *) + (td2->td_kstack + KSTACK_PAGES * PAGE_SIZE) - 1; + td2->td_md.md_flags = td1->td_md.md_flags & (MDP_FPUSED | MDP_UAC_MASK); /* * Cache the physical address of the pcb, so we can * swap to it easily. */ - p2->p_md.md_pcbpaddr = (void*)vtophys((vm_offset_t)&p2->p_addr->u_pcb); + td2->td_md.md_pcbpaddr = (void*)vtophys((vm_offset_t)td2->td_pcb); /* * Copy floating point state from the FP chip to the PCB * if this process has state stored there. */ - alpha_fpstate_save(p1, 0); + alpha_fpstate_save(td1, 0); /* * Copy pcb and stack from proc p1 to p2. We do this as @@ -149,16 +154,16 @@ cpu_fork(p1, p2, flags) * stack. The stack and pcb need to agree. Make sure that the * new process has FEN disabled. */ - p2->p_addr->u_pcb = p1->p_addr->u_pcb; - p2->p_addr->u_pcb.pcb_hw.apcb_usp = alpha_pal_rdusp(); - p2->p_addr->u_pcb.pcb_hw.apcb_flags &= ~ALPHA_PCB_FLAGS_FEN; + bcopy(td1->td_pcb, td2->td_pcb, sizeof(struct pcb)); + td2->td_pcb->pcb_hw.apcb_usp = alpha_pal_rdusp(); + td2->td_pcb->pcb_hw.apcb_flags &= ~ALPHA_PCB_FLAGS_FEN; /* * Set the floating point state. */ - if ((p2->p_addr->u_pcb.pcb_fp_control & IEEE_INHERIT) == 0) { - p2->p_addr->u_pcb.pcb_fp_control = 0; - p2->p_addr->u_pcb.pcb_fp.fpr_cr = (FPCR_DYN_NORMAL + if ((td2->td_pcb->pcb_fp_control & IEEE_INHERIT) == 0) { + td2->td_pcb->pcb_fp_control = 0; + td2->td_pcb->pcb_fp.fpr_cr = (FPCR_DYN_NORMAL | FPCR_INVD | FPCR_DZED | FPCR_OVFD | FPCR_INED | FPCR_UNFD); @@ -169,7 +174,7 @@ cpu_fork(p1, p2, flags) * is started, to resume here, returning nonzero from setjmp. */ #ifdef DIAGNOSTIC - alpha_fpstate_check(p1); + alpha_fpstate_check(td1); #endif /* @@ -179,34 +184,32 @@ cpu_fork(p1, p2, flags) * copy trapframe from parent so return to user mode * will be to right address, with correct registers. */ - p2->p_frame = (struct trapframe *) - ((char *)p2->p_addr + USPACE - sizeof(struct trapframe)); - bcopy(p1->p_frame, p2->p_frame, sizeof(struct trapframe)); + td2->td_frame = (struct trapframe *)td2->td_pcb - 1; + bcopy(td1->td_frame, td2->td_frame, sizeof(struct trapframe)); /* * Set up return-value registers as fork() libc stub expects. */ - p2tf = p2->p_frame; - p2tf->tf_regs[FRAME_V0] = 0; /* child's pid (linux) */ - p2tf->tf_regs[FRAME_A3] = 0; /* no error */ - p2tf->tf_regs[FRAME_A4] = 1; /* is child (FreeBSD) */ + p2tf = td2->td_frame; + p2tf->tf_regs[FRAME_V0] = 0; /* child's pid (linux) */ + p2tf->tf_regs[FRAME_A3] = 0; /* no error */ + p2tf->tf_regs[FRAME_A4] = 1; /* is child (FreeBSD) */ /* * Arrange for continuation at fork_return(), which * will return to exception_return(). Note that the child * process doesn't stay in the kernel for long! */ - up = p2->p_addr; - up->u_pcb.pcb_hw.apcb_ksp = (u_int64_t)p2tf; - up->u_pcb.pcb_context[0] = (u_int64_t)fork_return; /* s0: a0 */ - up->u_pcb.pcb_context[1] = (u_int64_t)exception_return; /* s1: ra */ - up->u_pcb.pcb_context[2] = (u_long) p2; /* s2: a1 */ - up->u_pcb.pcb_context[7] = (u_int64_t)fork_trampoline; /* ra: magic */ + td2->td_pcb->pcb_hw.apcb_ksp = (u_int64_t)p2tf; + td2->td_pcb->pcb_context[0] = (u_int64_t)fork_return; /* s0: a0 */ + td2->td_pcb->pcb_context[1] = (u_int64_t)exception_return;/* s1: ra */ + td2->td_pcb->pcb_context[2] = (u_long)td2; /* s2: a1 */ + td2->td_pcb->pcb_context[7] = (u_int64_t)fork_trampoline; /* ra: magic*/ #ifdef SMP /* * We start off at a nesting level of 1 within the kernel. */ - p2->p_md.md_kernnest = 1; + td2->td_md.md_kernnest = 1; #endif } @@ -217,8 +220,8 @@ cpu_fork(p1, p2, flags) * This is needed to make kernel threads stay in kernel mode. */ void -cpu_set_fork_handler(p, func, arg) - struct proc *p; +cpu_set_fork_handler(td, func, arg) + struct thread *td; void (*func) __P((void *)); void *arg; { @@ -226,8 +229,8 @@ cpu_set_fork_handler(p, func, arg) * Note that the trap frame follows the args, so the function * is really called like this: func(arg, frame); */ - p->p_addr->u_pcb.pcb_context[0] = (u_long) func; - p->p_addr->u_pcb.pcb_context[2] = (u_long) arg; + td->td_pcb->pcb_context[0] = (u_long) func; + td->td_pcb->pcb_context[2] = (u_long) arg; } /* @@ -238,11 +241,11 @@ cpu_set_fork_handler(p, func, arg) * from proc0. */ void -cpu_exit(p) - register struct proc *p; +cpu_exit(td) + register struct thread *td; { - alpha_fpstate_drop(p); + alpha_fpstate_drop(td); } void @@ -255,14 +258,23 @@ cpu_wait(p) * Dump the machine specific header information at the start of a core dump. */ int -cpu_coredump(p, vp, cred) - struct proc *p; +cpu_coredump(td, vp, cred) + struct thread *td; struct vnode *vp; struct ucred *cred; { - - return (vn_rdwr(UIO_WRITE, vp, (caddr_t) p->p_addr, ctob(UPAGES), - (off_t)0, UIO_SYSSPACE, IO_UNIT, cred, (int *)NULL, p)); + int error; + + /* XXXKSE this is totally bogus! (and insecure) */ + error = vn_rdwr(UIO_WRITE, vp, (caddr_t) td->td_proc->p_uarea, + ctob(UAREA_PAGES), (off_t)0, + UIO_SYSSPACE, IO_UNIT, cred, (int *)NULL, td); + if (error) + return error; + error = vn_rdwr(UIO_WRITE, vp, (caddr_t) td->td_kstack, + ctob(KSTACK_PAGES), (off_t)ctob(UAREA_PAGES), + UIO_SYSSPACE, IO_UNIT, cred, (int *)NULL, td); + return error; } /* diff --git a/sys/alpha/include/cpu.h b/sys/alpha/include/cpu.h index 69ed2ea..e5fd400 100644 --- a/sys/alpha/include/cpu.h +++ b/sys/alpha/include/cpu.h @@ -52,7 +52,7 @@ #include <machine/frame.h> -#define cpu_getstack(p) (alpha_pal_rdusp()) +#define cpu_getstack(td) (alpha_pal_rdusp()) /* * Arguments to hardclock and gatherstats encapsulate the previous @@ -99,7 +99,7 @@ struct clockframe { #ifdef _KERNEL struct pcb; -struct proc; +struct thread; struct reg; struct rpb; struct trapframe; @@ -116,10 +116,10 @@ void XentSys __P((u_int64_t, u_int64_t, u_int64_t)); /* MAGIC */ void XentUna __P((u_int64_t, u_int64_t, u_int64_t)); /* MAGIC */ void alpha_init __P((u_long, u_long, u_long, u_long, u_long)); int alpha_pa_access __P((u_long)); -void alpha_fpstate_check __P((struct proc *p)); -void alpha_fpstate_save __P((struct proc *p, int write)); -void alpha_fpstate_drop __P((struct proc *p)); -void alpha_fpstate_switch __P((struct proc *p)); +void alpha_fpstate_check __P((struct thread *p)); +void alpha_fpstate_save __P((struct thread *p, int write)); +void alpha_fpstate_drop __P((struct thread *p)); +void alpha_fpstate_switch __P((struct thread *p)); int badaddr __P((void *, size_t)); int badaddr_read __P((void *, size_t, void *)); u_int64_t console_restart __P((u_int64_t, u_int64_t, u_int64_t)); @@ -138,7 +138,7 @@ void regdump __P((struct trapframe *)); void regtoframe __P((struct reg *, struct trapframe *)); void savectx __P((struct pcb *)); void set_iointr __P((void (*)(void *, unsigned long))); -void switch_exit __P((struct proc *)); /* MAGIC */ +void switch_exit __P((struct thread *)); /* MAGIC */ void fork_trampoline __P((void)); /* MAGIC */ void syscall __P((u_int64_t, struct trapframe *)); void trap __P((unsigned long, unsigned long, unsigned long, unsigned long, diff --git a/sys/alpha/include/fpu.h b/sys/alpha/include/fpu.h index 250db28..712a1f9 100644 --- a/sys/alpha/include/fpu.h +++ b/sys/alpha/include/fpu.h @@ -117,7 +117,7 @@ #ifdef _KERNEL -extern int fp_software_completion(u_int64_t regmask, struct proc *p); +extern int fp_software_completion(u_int64_t regmask, struct thread *p); #endif diff --git a/sys/alpha/include/globaldata.h b/sys/alpha/include/globaldata.h index d577fee..5d8514b 100644 --- a/sys/alpha/include/globaldata.h +++ b/sys/alpha/include/globaldata.h @@ -44,15 +44,15 @@ * point at the globaldata structure. */ struct globaldata { - struct alpha_pcb gd_idlepcb; /* pcb for idling */ - struct proc *gd_curproc; /* current process */ - struct proc *gd_idleproc; /* idle process */ - struct proc *gd_fpcurproc; /* fp state owner */ - struct pcb *gd_curpcb; /* current pcb */ - struct timeval gd_switchtime; - int gd_switchticks; - u_int gd_cpuid; /* this cpu number */ - u_int gd_other_cpus; /* all other cpus */ + struct alpha_pcb gd_idlepcb; /* pcb for idling */ + struct thread *gd_curthread; /* current thread */ + struct thread *gd_idlethread; /* idle thread */ + struct thread *gd_fpcurthread; /* fp state owner */ + struct pcb *gd_curpcb; /* current pcb */ + struct timeval gd_switchtime; + int gd_switchticks; + u_int gd_cpuid; /* this cpu number */ + u_int gd_other_cpus; /* all other cpus */ u_int64_t gd_idlepcbphys; /* pa of gd_idlepcb */ u_int64_t gd_pending_ipis; /* pending IPI events */ u_int32_t gd_next_asn; /* next ASN to allocate */ diff --git a/sys/alpha/include/globals.h b/sys/alpha/include/globals.h index 313541b..46dab32 100644 --- a/sys/alpha/include/globals.h +++ b/sys/alpha/include/globals.h @@ -40,9 +40,11 @@ register struct globaldata *globalp __asm__("$8"); #define PCPU_PTR(member) (&GLOBALP->gd_ ## member) #define PCPU_SET(member,value) (GLOBALP->gd_ ## member = (value)) -#define CURPROC PCPU_GET(curproc) -#define CURTHD PCPU_GET(curproc) /* temporary */ -#define curproc PCPU_GET(curproc) +#define curthread PCPU_GET(curthread) +#define CURPROC (curthread->td_proc) +#define curproc (curthread->td_proc) +#define curksegrp (curthread->td_ksegrp) +#define curkse (curthread->td_kse) #endif /* _KERNEL */ diff --git a/sys/alpha/include/md_var.h b/sys/alpha/include/md_var.h index 41512d7..b4fdfe4 100644 --- a/sys/alpha/include/md_var.h +++ b/sys/alpha/include/md_var.h @@ -40,7 +40,7 @@ extern int Maxmem; extern int busdma_swi_pending; struct fpreg; -struct proc; +struct thread; struct reg; struct cam_sim; struct pcicfg; @@ -50,10 +50,10 @@ void cpu_halt __P((void)); void cpu_reset __P((void)); int is_physical_memory __P((vm_offset_t addr)); void swi_vm __P((void *)); -int fill_regs __P((struct proc *, struct reg *)); -int set_regs __P((struct proc *, struct reg *)); -int fill_fpregs __P((struct proc *, struct fpreg *)); -int set_fpregs __P((struct proc *, struct fpreg *)); +int fill_regs __P((struct thread *, struct reg *)); +int set_regs __P((struct thread *, struct reg *)); +int fill_fpregs __P((struct thread *, struct fpreg *)); +int set_fpregs __P((struct thread *, struct fpreg *)); void alpha_register_pci_scsi __P((int bus, int slot, struct cam_sim *sim)); #ifdef _SYS_BUS_H_ struct resource *alpha_platform_alloc_ide_intr(int chan); diff --git a/sys/alpha/include/mutex.h b/sys/alpha/include/mutex.h index c141d6f..9192bb2 100644 --- a/sys/alpha/include/mutex.h +++ b/sys/alpha/include/mutex.h @@ -58,7 +58,7 @@ extern struct mtx clock_lock; 1: ldq_l a0, lck+MTX_LOCK; \ cmpeq a0, MTX_UNOWNED, a1; \ beq a1, 1b; \ - ldq a0, PC_CURPROC(globalp); \ + ldq a0, PC_CURTHREAD(globalp); \ stq_c a0, lck+MTX_LOCK; \ beq a0, 1b; \ mb; \ diff --git a/sys/alpha/include/param.h b/sys/alpha/include/param.h index 0a0206e..91dabba 100644 --- a/sys/alpha/include/param.h +++ b/sys/alpha/include/param.h @@ -133,8 +133,10 @@ #define SSIZE 1 /* initial stack size/NBPG */ #define SINCR 1 /* increment of stack/NBPG */ -#define UPAGES 2 /* pages of u-area */ -#define USPACE (UPAGES * PAGE_SIZE) /* total size of u-area */ +#define KSTACK_PAGES 2 /* pages of kstack (with pcb) */ +#define UAREA_PAGES 1 /* pages of u-area */ + +#define KSTACK_GUARD /* compile in kstack guard page */ /* * Constants related to network buffer management. diff --git a/sys/alpha/include/pcpu.h b/sys/alpha/include/pcpu.h index d577fee..5d8514b 100644 --- a/sys/alpha/include/pcpu.h +++ b/sys/alpha/include/pcpu.h @@ -44,15 +44,15 @@ * point at the globaldata structure. */ struct globaldata { - struct alpha_pcb gd_idlepcb; /* pcb for idling */ - struct proc *gd_curproc; /* current process */ - struct proc *gd_idleproc; /* idle process */ - struct proc *gd_fpcurproc; /* fp state owner */ - struct pcb *gd_curpcb; /* current pcb */ - struct timeval gd_switchtime; - int gd_switchticks; - u_int gd_cpuid; /* this cpu number */ - u_int gd_other_cpus; /* all other cpus */ + struct alpha_pcb gd_idlepcb; /* pcb for idling */ + struct thread *gd_curthread; /* current thread */ + struct thread *gd_idlethread; /* idle thread */ + struct thread *gd_fpcurthread; /* fp state owner */ + struct pcb *gd_curpcb; /* current pcb */ + struct timeval gd_switchtime; + int gd_switchticks; + u_int gd_cpuid; /* this cpu number */ + u_int gd_other_cpus; /* all other cpus */ u_int64_t gd_idlepcbphys; /* pa of gd_idlepcb */ u_int64_t gd_pending_ipis; /* pending IPI events */ u_int32_t gd_next_asn; /* next ASN to allocate */ diff --git a/sys/alpha/include/pmap.h b/sys/alpha/include/pmap.h index 055ea36..959805e 100644 --- a/sys/alpha/include/pmap.h +++ b/sys/alpha/include/pmap.h @@ -220,6 +220,8 @@ extern char *ptvmmap; /* poor name! */ extern vm_offset_t virtual_avail; extern vm_offset_t virtual_end; +struct vmspace; + vm_offset_t pmap_steal_memory __P((vm_size_t)); void pmap_bootstrap __P((vm_offset_t, u_int)); void pmap_setdevram __P((unsigned long long basea, vm_offset_t sizea)); @@ -230,8 +232,8 @@ unsigned *pmap_pte __P((pmap_t, vm_offset_t)) __pure2; vm_page_t pmap_use_pt __P((pmap_t, vm_offset_t)); void pmap_set_opt __P((unsigned *)); void pmap_set_opt_bsp __P((void)); -void pmap_deactivate __P((struct proc *p)); -void pmap_emulate_reference __P((struct proc *p, vm_offset_t v, int user, int write)); +void pmap_deactivate __P((struct thread *td)); +void pmap_emulate_reference __P((struct vmspace *vm, vm_offset_t v, int user, int write)); #endif /* _KERNEL */ diff --git a/sys/alpha/include/proc.h b/sys/alpha/include/proc.h index b3f98f6..16cf1d5 100644 --- a/sys/alpha/include/proc.h +++ b/sys/alpha/include/proc.h @@ -43,7 +43,7 @@ struct mdbpt { u_int32_t contents; }; -struct mdproc { +struct mdthread { u_long md_flags; struct pcb *md_pcbpaddr; /* phys addr of the pcb */ struct mdbpt md_sstep[2]; /* two single step breakpoints */ @@ -62,4 +62,7 @@ struct mdproc { unaligned access */ #define MDP_UAC_MASK (MDP_UAC_NOPRINT | MDP_UAC_NOFIX | MDP_UAC_SIGBUS) +struct mdproc { +}; + #endif /* !_MACHINE_PROC_H_ */ diff --git a/sys/alpha/include/ptrace.h b/sys/alpha/include/ptrace.h index 5a9cf14..87a03af 100644 --- a/sys/alpha/include/ptrace.h +++ b/sys/alpha/include/ptrace.h @@ -48,7 +48,7 @@ #define FIX_SSTEP(p) ptrace_clear_single_step(p) #ifdef _KERNEL -int ptrace_clear_single_step(struct proc *_p); +int ptrace_clear_single_step(struct thread *_p); #endif #endif diff --git a/sys/alpha/include/reg.h b/sys/alpha/include/reg.h index 5dfde65..b4a73f3 100644 --- a/sys/alpha/include/reg.h +++ b/sys/alpha/include/reg.h @@ -110,7 +110,7 @@ struct dbreg { #ifdef _KERNEL void restorefpstate __P((struct fpreg *)); void savefpstate __P((struct fpreg *)); -void setregs __P((struct proc *, u_long, u_long, u_long)); +void setregs __P((struct thread *, u_long, u_long, u_long)); #endif #endif /* _ALPHA_REG_H_ */ diff --git a/sys/alpha/include/vmparam.h b/sys/alpha/include/vmparam.h index bd08553..29dcc99 100644 --- a/sys/alpha/include/vmparam.h +++ b/sys/alpha/include/vmparam.h @@ -62,7 +62,7 @@ * with a 32bit value. OSF1 manages to have a variable location for * the user stack which we should probably also support. */ -#define USRSTACK (0x12000000LL - (UPAGES*PAGE_SIZE)) +#define USRSTACK (0x12000000LL) /* * Virtual memory related constants, all in bytes diff --git a/sys/alpha/linux/linux_proto.h b/sys/alpha/linux/linux_proto.h index 9caa5ea..31f052c 100644 --- a/sys/alpha/linux/linux_proto.h +++ b/sys/alpha/linux/linux_proto.h @@ -15,6 +15,8 @@ struct proc; +struct thread; + #define PAD_(t) (sizeof(register_t) <= sizeof(t) ? \ 0 : sizeof(register_t) - sizeof(t)) @@ -594,144 +596,144 @@ struct linux_getdents64_args { char dirent_l_[PADL_(void *)]; void * dirent; char dirent_r_[PADR_(void *)]; char count_l_[PADL_(l_uint)]; l_uint count; char count_r_[PADR_(l_uint)]; }; -int linux_fork __P((struct proc *, struct linux_fork_args *)); -int osf1_wait4 __P((struct proc *, struct osf1_wait4_args *)); -int linux_link __P((struct proc *, struct linux_link_args *)); -int linux_unlink __P((struct proc *, struct linux_unlink_args *)); -int linux_chdir __P((struct proc *, struct linux_chdir_args *)); -int linux_mknod __P((struct proc *, struct linux_mknod_args *)); -int linux_chmod __P((struct proc *, struct linux_chmod_args *)); -int linux_chown __P((struct proc *, struct linux_chown_args *)); -int linux_brk __P((struct proc *, struct linux_brk_args *)); -int linux_lseek __P((struct proc *, struct linux_lseek_args *)); -int linux_getpid __P((struct proc *, struct linux_getpid_args *)); -int linux_umount __P((struct proc *, struct linux_umount_args *)); -int linux_getuid __P((struct proc *, struct linux_getuid_args *)); -int linux_ptrace __P((struct proc *, struct linux_ptrace_args *)); -int linux_access __P((struct proc *, struct linux_access_args *)); -int linux_kill __P((struct proc *, struct linux_kill_args *)); -int linux_open __P((struct proc *, struct linux_open_args *)); -int linux_getgid __P((struct proc *, struct linux_getgid_args *)); -int osf1_sigprocmask __P((struct proc *, struct osf1_sigprocmask_args *)); -int linux_sigpending __P((struct proc *, struct linux_sigpending_args *)); -int linux_ioctl __P((struct proc *, struct linux_ioctl_args *)); -int linux_symlink __P((struct proc *, struct linux_symlink_args *)); -int linux_readlink __P((struct proc *, struct linux_readlink_args *)); -int linux_execve __P((struct proc *, struct linux_execve_args *)); -int linux_getpagesize __P((struct proc *, struct linux_getpagesize_args *)); -int linux_vfork __P((struct proc *, struct linux_vfork_args *)); -int linux_newstat __P((struct proc *, struct linux_newstat_args *)); -int linux_newlstat __P((struct proc *, struct linux_newlstat_args *)); -int linux_mmap __P((struct proc *, struct linux_mmap_args *)); -int linux_munmap __P((struct proc *, struct linux_munmap_args *)); -int linux_mprotect __P((struct proc *, struct linux_mprotect_args *)); -int linux_madvise __P((struct proc *, struct linux_madvise_args *)); -int linux_vhangup __P((struct proc *, struct linux_vhangup_args *)); -int linux_setgroups __P((struct proc *, struct linux_setgroups_args *)); -int linux_getgroups __P((struct proc *, struct linux_getgroups_args *)); -int linux_setpgid __P((struct proc *, struct linux_setpgid_args *)); -int osf1_setitimer __P((struct proc *, struct osf1_setitimer_args *)); -int linux_gethostname __P((struct proc *, struct linux_gethostname_args *)); -int linux_getdtablesize __P((struct proc *, struct linux_getdtablesize_args *)); -int linux_newfstat __P((struct proc *, struct linux_newfstat_args *)); -int linux_fcntl __P((struct proc *, struct linux_fcntl_args *)); -int osf1_select __P((struct proc *, struct osf1_select_args *)); -int osf1_socket __P((struct proc *, struct osf1_socket_args *)); -int linux_connect __P((struct proc *, struct linux_connect_args *)); -int osf1_sigreturn __P((struct proc *, struct osf1_sigreturn_args *)); -int osf1_sigsuspend __P((struct proc *, struct osf1_sigsuspend_args *)); -int linux_recvmsg __P((struct proc *, struct linux_recvmsg_args *)); -int linux_sendmsg __P((struct proc *, struct linux_sendmsg_args *)); -int osf1_gettimeofday __P((struct proc *, struct osf1_gettimeofday_args *)); -int osf1_getrusage __P((struct proc *, struct osf1_getrusage_args *)); -int linux_rename __P((struct proc *, struct linux_rename_args *)); -int linux_truncate __P((struct proc *, struct linux_truncate_args *)); -int osf1_sendto __P((struct proc *, struct osf1_sendto_args *)); -int linux_socketpair __P((struct proc *, struct linux_socketpair_args *)); -int linux_mkdir __P((struct proc *, struct linux_mkdir_args *)); -int linux_rmdir __P((struct proc *, struct linux_rmdir_args *)); -int linux_getrlimit __P((struct proc *, struct linux_getrlimit_args *)); -int linux_setrlimit __P((struct proc *, struct linux_setrlimit_args *)); -int linux_quotactl __P((struct proc *, struct linux_quotactl_args *)); -int osf1_sigaction __P((struct proc *, struct osf1_sigaction_args *)); -int linux_msgctl __P((struct proc *, struct linux_msgctl_args *)); -int linux_msgget __P((struct proc *, struct linux_msgget_args *)); -int linux_msgrcv __P((struct proc *, struct linux_msgrcv_args *)); -int linux_msgsnd __P((struct proc *, struct linux_msgsnd_args *)); -int linux_semctl __P((struct proc *, struct linux_semctl_args *)); -int linux_semget __P((struct proc *, struct linux_semget_args *)); -int linux_semop __P((struct proc *, struct linux_semop_args *)); -int linux_lchown __P((struct proc *, struct linux_lchown_args *)); -int linux_shmat __P((struct proc *, struct linux_shmat_args *)); -int linux_shmctl __P((struct proc *, struct linux_shmctl_args *)); -int linux_shmdt __P((struct proc *, struct linux_shmdt_args *)); -int linux_shmget __P((struct proc *, struct linux_shmget_args *)); -int linux_msync __P((struct proc *, struct linux_msync_args *)); -int linux_getpgid __P((struct proc *, struct linux_getpgid_args *)); -int linux_getsid __P((struct proc *, struct linux_getsid_args *)); -int linux_sigaltstack __P((struct proc *, struct linux_sigaltstack_args *)); -int osf1_sysinfo __P((struct proc *, struct osf1_sysinfo_args *)); -int linux_sysfs __P((struct proc *, struct linux_sysfs_args *)); -int osf1_getsysinfo __P((struct proc *, struct osf1_getsysinfo_args *)); -int osf1_setsysinfo __P((struct proc *, struct osf1_setsysinfo_args *)); -int linux_bdflush __P((struct proc *, struct linux_bdflush_args *)); -int linux_sethae __P((struct proc *, struct linux_sethae_args *)); -int linux_mount __P((struct proc *, struct linux_mount_args *)); -int linux_old_adjtimex __P((struct proc *, struct linux_old_adjtimex_args *)); -int linux_swapoff __P((struct proc *, struct linux_swapoff_args *)); -int linux_getdents __P((struct proc *, struct linux_getdents_args *)); -int linux_create_module __P((struct proc *, struct linux_create_module_args *)); -int linux_init_module __P((struct proc *, struct linux_init_module_args *)); -int linux_delete_module __P((struct proc *, struct linux_delete_module_args *)); -int linux_get_kernel_syms __P((struct proc *, struct linux_get_kernel_syms_args *)); -int linux_syslog __P((struct proc *, struct linux_syslog_args *)); -int linux_reboot __P((struct proc *, struct linux_reboot_args *)); -int linux_clone __P((struct proc *, struct linux_clone_args *)); -int linux_uselib __P((struct proc *, struct linux_uselib_args *)); -int linux_sysinfo __P((struct proc *, struct linux_sysinfo_args *)); -int linux_sysctl __P((struct proc *, struct linux_sysctl_args *)); -int linux_oldumount __P((struct proc *, struct linux_oldumount_args *)); -int linux_times __P((struct proc *, struct linux_times_args *)); -int linux_personality __P((struct proc *, struct linux_personality_args *)); -int linux_setfsuid __P((struct proc *, struct linux_setfsuid_args *)); -int linux_setfsgid __P((struct proc *, struct linux_setfsgid_args *)); -int linux_ustat __P((struct proc *, struct linux_ustat_args *)); -int linux_statfs __P((struct proc *, struct linux_statfs_args *)); -int linux_fstatfs __P((struct proc *, struct linux_fstatfs_args *)); -int linux_sched_setscheduler __P((struct proc *, struct linux_sched_setscheduler_args *)); -int linux_sched_getscheduler __P((struct proc *, struct linux_sched_getscheduler_args *)); -int linux_sched_get_priority_max __P((struct proc *, struct linux_sched_get_priority_max_args *)); -int linux_sched_get_priority_min __P((struct proc *, struct linux_sched_get_priority_min_args *)); -int linux_newuname __P((struct proc *, struct linux_newuname_args *)); -int linux_mremap __P((struct proc *, struct linux_mremap_args *)); -int linux_nfsservctl __P((struct proc *, struct linux_nfsservctl_args *)); -int linux_pciconfig_read __P((struct proc *, struct linux_pciconfig_read_args *)); -int linux_pciconfig_write __P((struct proc *, struct linux_pciconfig_write_args *)); -int linux_query_module __P((struct proc *, struct linux_query_module_args *)); -int linux_prctl __P((struct proc *, struct linux_prctl_args *)); -int linux_pread __P((struct proc *, struct linux_pread_args *)); -int linux_pwrite __P((struct proc *, struct linux_pwrite_args *)); -int linux_rt_sigreturn __P((struct proc *, struct linux_rt_sigreturn_args *)); -int linux_rt_sigaction __P((struct proc *, struct linux_rt_sigaction_args *)); -int linux_rt_sigprocmask __P((struct proc *, struct linux_rt_sigprocmask_args *)); -int linux_rt_sigpending __P((struct proc *, struct linux_rt_sigpending_args *)); -int linux_rt_sigtimedwait __P((struct proc *, struct linux_rt_sigtimedwait_args *)); -int linux_rt_sigqueueinfo __P((struct proc *, struct linux_rt_sigqueueinfo_args *)); -int linux_rt_sigsuspend __P((struct proc *, struct linux_rt_sigsuspend_args *)); -int linux_select __P((struct proc *, struct linux_select_args *)); -int linux_getitimer __P((struct proc *, struct linux_getitimer_args *)); -int linux_setitimer __P((struct proc *, struct linux_setitimer_args *)); -int linux_utimes __P((struct proc *, struct linux_utimes_args *)); -int linux_wait4 __P((struct proc *, struct linux_wait4_args *)); -int linux_adjtimex __P((struct proc *, struct linux_adjtimex_args *)); -int linux_getcwd __P((struct proc *, struct linux_getcwd_args *)); -int linux_capget __P((struct proc *, struct linux_capget_args *)); -int linux_capset __P((struct proc *, struct linux_capset_args *)); -int linux_sendfile __P((struct proc *, struct linux_sendfile_args *)); -int linux_pivot_root __P((struct proc *, struct linux_pivot_root_args *)); -int linux_mincore __P((struct proc *, struct linux_mincore_args *)); -int linux_pciconfig_iobase __P((struct proc *, struct linux_pciconfig_iobase_args *)); -int linux_getdents64 __P((struct proc *, struct linux_getdents64_args *)); +int linux_fork __P((struct thread *, struct linux_fork_args *)); +int osf1_wait4 __P((struct thread *, struct osf1_wait4_args *)); +int linux_link __P((struct thread *, struct linux_link_args *)); +int linux_unlink __P((struct thread *, struct linux_unlink_args *)); +int linux_chdir __P((struct thread *, struct linux_chdir_args *)); +int linux_mknod __P((struct thread *, struct linux_mknod_args *)); +int linux_chmod __P((struct thread *, struct linux_chmod_args *)); +int linux_chown __P((struct thread *, struct linux_chown_args *)); +int linux_brk __P((struct thread *, struct linux_brk_args *)); +int linux_lseek __P((struct thread *, struct linux_lseek_args *)); +int linux_getpid __P((struct thread *, struct linux_getpid_args *)); +int linux_umount __P((struct thread *, struct linux_umount_args *)); +int linux_getuid __P((struct thread *, struct linux_getuid_args *)); +int linux_ptrace __P((struct thread *, struct linux_ptrace_args *)); +int linux_access __P((struct thread *, struct linux_access_args *)); +int linux_kill __P((struct thread *, struct linux_kill_args *)); +int linux_open __P((struct thread *, struct linux_open_args *)); +int linux_getgid __P((struct thread *, struct linux_getgid_args *)); +int osf1_sigprocmask __P((struct thread *, struct osf1_sigprocmask_args *)); +int linux_sigpending __P((struct thread *, struct linux_sigpending_args *)); +int linux_ioctl __P((struct thread *, struct linux_ioctl_args *)); +int linux_symlink __P((struct thread *, struct linux_symlink_args *)); +int linux_readlink __P((struct thread *, struct linux_readlink_args *)); +int linux_execve __P((struct thread *, struct linux_execve_args *)); +int linux_getpagesize __P((struct thread *, struct linux_getpagesize_args *)); +int linux_vfork __P((struct thread *, struct linux_vfork_args *)); +int linux_newstat __P((struct thread *, struct linux_newstat_args *)); +int linux_newlstat __P((struct thread *, struct linux_newlstat_args *)); +int linux_mmap __P((struct thread *, struct linux_mmap_args *)); +int linux_munmap __P((struct thread *, struct linux_munmap_args *)); +int linux_mprotect __P((struct thread *, struct linux_mprotect_args *)); +int linux_madvise __P((struct thread *, struct linux_madvise_args *)); +int linux_vhangup __P((struct thread *, struct linux_vhangup_args *)); +int linux_setgroups __P((struct thread *, struct linux_setgroups_args *)); +int linux_getgroups __P((struct thread *, struct linux_getgroups_args *)); +int linux_setpgid __P((struct thread *, struct linux_setpgid_args *)); +int osf1_setitimer __P((struct thread *, struct osf1_setitimer_args *)); +int linux_gethostname __P((struct thread *, struct linux_gethostname_args *)); +int linux_getdtablesize __P((struct thread *, struct linux_getdtablesize_args *)); +int linux_newfstat __P((struct thread *, struct linux_newfstat_args *)); +int linux_fcntl __P((struct thread *, struct linux_fcntl_args *)); +int osf1_select __P((struct thread *, struct osf1_select_args *)); +int osf1_socket __P((struct thread *, struct osf1_socket_args *)); +int linux_connect __P((struct thread *, struct linux_connect_args *)); +int osf1_sigreturn __P((struct thread *, struct osf1_sigreturn_args *)); +int osf1_sigsuspend __P((struct thread *, struct osf1_sigsuspend_args *)); +int linux_recvmsg __P((struct thread *, struct linux_recvmsg_args *)); +int linux_sendmsg __P((struct thread *, struct linux_sendmsg_args *)); +int osf1_gettimeofday __P((struct thread *, struct osf1_gettimeofday_args *)); +int osf1_getrusage __P((struct thread *, struct osf1_getrusage_args *)); +int linux_rename __P((struct thread *, struct linux_rename_args *)); +int linux_truncate __P((struct thread *, struct linux_truncate_args *)); +int osf1_sendto __P((struct thread *, struct osf1_sendto_args *)); +int linux_socketpair __P((struct thread *, struct linux_socketpair_args *)); +int linux_mkdir __P((struct thread *, struct linux_mkdir_args *)); +int linux_rmdir __P((struct thread *, struct linux_rmdir_args *)); +int linux_getrlimit __P((struct thread *, struct linux_getrlimit_args *)); +int linux_setrlimit __P((struct thread *, struct linux_setrlimit_args *)); +int linux_quotactl __P((struct thread *, struct linux_quotactl_args *)); +int osf1_sigaction __P((struct thread *, struct osf1_sigaction_args *)); +int linux_msgctl __P((struct thread *, struct linux_msgctl_args *)); +int linux_msgget __P((struct thread *, struct linux_msgget_args *)); +int linux_msgrcv __P((struct thread *, struct linux_msgrcv_args *)); +int linux_msgsnd __P((struct thread *, struct linux_msgsnd_args *)); +int linux_semctl __P((struct thread *, struct linux_semctl_args *)); +int linux_semget __P((struct thread *, struct linux_semget_args *)); +int linux_semop __P((struct thread *, struct linux_semop_args *)); +int linux_lchown __P((struct thread *, struct linux_lchown_args *)); +int linux_shmat __P((struct thread *, struct linux_shmat_args *)); +int linux_shmctl __P((struct thread *, struct linux_shmctl_args *)); +int linux_shmdt __P((struct thread *, struct linux_shmdt_args *)); +int linux_shmget __P((struct thread *, struct linux_shmget_args *)); +int linux_msync __P((struct thread *, struct linux_msync_args *)); +int linux_getpgid __P((struct thread *, struct linux_getpgid_args *)); +int linux_getsid __P((struct thread *, struct linux_getsid_args *)); +int linux_sigaltstack __P((struct thread *, struct linux_sigaltstack_args *)); +int osf1_sysinfo __P((struct thread *, struct osf1_sysinfo_args *)); +int linux_sysfs __P((struct thread *, struct linux_sysfs_args *)); +int osf1_getsysinfo __P((struct thread *, struct osf1_getsysinfo_args *)); +int osf1_setsysinfo __P((struct thread *, struct osf1_setsysinfo_args *)); +int linux_bdflush __P((struct thread *, struct linux_bdflush_args *)); +int linux_sethae __P((struct thread *, struct linux_sethae_args *)); +int linux_mount __P((struct thread *, struct linux_mount_args *)); +int linux_old_adjtimex __P((struct thread *, struct linux_old_adjtimex_args *)); +int linux_swapoff __P((struct thread *, struct linux_swapoff_args *)); +int linux_getdents __P((struct thread *, struct linux_getdents_args *)); +int linux_create_module __P((struct thread *, struct linux_create_module_args *)); +int linux_init_module __P((struct thread *, struct linux_init_module_args *)); +int linux_delete_module __P((struct thread *, struct linux_delete_module_args *)); +int linux_get_kernel_syms __P((struct thread *, struct linux_get_kernel_syms_args *)); +int linux_syslog __P((struct thread *, struct linux_syslog_args *)); +int linux_reboot __P((struct thread *, struct linux_reboot_args *)); +int linux_clone __P((struct thread *, struct linux_clone_args *)); +int linux_uselib __P((struct thread *, struct linux_uselib_args *)); +int linux_sysinfo __P((struct thread *, struct linux_sysinfo_args *)); +int linux_sysctl __P((struct thread *, struct linux_sysctl_args *)); +int linux_oldumount __P((struct thread *, struct linux_oldumount_args *)); +int linux_times __P((struct thread *, struct linux_times_args *)); +int linux_personality __P((struct thread *, struct linux_personality_args *)); +int linux_setfsuid __P((struct thread *, struct linux_setfsuid_args *)); +int linux_setfsgid __P((struct thread *, struct linux_setfsgid_args *)); +int linux_ustat __P((struct thread *, struct linux_ustat_args *)); +int linux_statfs __P((struct thread *, struct linux_statfs_args *)); +int linux_fstatfs __P((struct thread *, struct linux_fstatfs_args *)); +int linux_sched_setscheduler __P((struct thread *, struct linux_sched_setscheduler_args *)); +int linux_sched_getscheduler __P((struct thread *, struct linux_sched_getscheduler_args *)); +int linux_sched_get_priority_max __P((struct thread *, struct linux_sched_get_priority_max_args *)); +int linux_sched_get_priority_min __P((struct thread *, struct linux_sched_get_priority_min_args *)); +int linux_newuname __P((struct thread *, struct linux_newuname_args *)); +int linux_mremap __P((struct thread *, struct linux_mremap_args *)); +int linux_nfsservctl __P((struct thread *, struct linux_nfsservctl_args *)); +int linux_pciconfig_read __P((struct thread *, struct linux_pciconfig_read_args *)); +int linux_pciconfig_write __P((struct thread *, struct linux_pciconfig_write_args *)); +int linux_query_module __P((struct thread *, struct linux_query_module_args *)); +int linux_prctl __P((struct thread *, struct linux_prctl_args *)); +int linux_pread __P((struct thread *, struct linux_pread_args *)); +int linux_pwrite __P((struct thread *, struct linux_pwrite_args *)); +int linux_rt_sigreturn __P((struct thread *, struct linux_rt_sigreturn_args *)); +int linux_rt_sigaction __P((struct thread *, struct linux_rt_sigaction_args *)); +int linux_rt_sigprocmask __P((struct thread *, struct linux_rt_sigprocmask_args *)); +int linux_rt_sigpending __P((struct thread *, struct linux_rt_sigpending_args *)); +int linux_rt_sigtimedwait __P((struct thread *, struct linux_rt_sigtimedwait_args *)); +int linux_rt_sigqueueinfo __P((struct thread *, struct linux_rt_sigqueueinfo_args *)); +int linux_rt_sigsuspend __P((struct thread *, struct linux_rt_sigsuspend_args *)); +int linux_select __P((struct thread *, struct linux_select_args *)); +int linux_getitimer __P((struct thread *, struct linux_getitimer_args *)); +int linux_setitimer __P((struct thread *, struct linux_setitimer_args *)); +int linux_utimes __P((struct thread *, struct linux_utimes_args *)); +int linux_wait4 __P((struct thread *, struct linux_wait4_args *)); +int linux_adjtimex __P((struct thread *, struct linux_adjtimex_args *)); +int linux_getcwd __P((struct thread *, struct linux_getcwd_args *)); +int linux_capget __P((struct thread *, struct linux_capget_args *)); +int linux_capset __P((struct thread *, struct linux_capset_args *)); +int linux_sendfile __P((struct thread *, struct linux_sendfile_args *)); +int linux_pivot_root __P((struct thread *, struct linux_pivot_root_args *)); +int linux_mincore __P((struct thread *, struct linux_mincore_args *)); +int linux_pciconfig_iobase __P((struct thread *, struct linux_pciconfig_iobase_args *)); +int linux_getdents64 __P((struct thread *, struct linux_getdents64_args *)); #ifdef COMPAT_43 diff --git a/sys/alpha/tlsb/zs_tlsb.c b/sys/alpha/tlsb/zs_tlsb.c index f6b67b8..ee3dbef 100644 --- a/sys/alpha/tlsb/zs_tlsb.c +++ b/sys/alpha/tlsb/zs_tlsb.c @@ -264,7 +264,7 @@ zs_cnputc(dev_t dev, int c) static int -zsopen(dev_t dev, int flag, int mode, struct proc *p) +zsopen(dev_t dev, int flag, int mode, struct thread *td) { struct zs_softc *sc = ZS_SOFTC(minor(dev)); struct tty *tp; @@ -290,7 +290,7 @@ zsopen(dev_t dev, int flag, int mode, struct proc *p) tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; ttsetwater(tp); setuptimeout = 1; - } else if ((tp->t_state & TS_XCLUDE) && suser(p)) { + } else if ((tp->t_state & TS_XCLUDE) && suser(td->td_proc)) { splx(s); return EBUSY; } @@ -311,7 +311,7 @@ zsopen(dev_t dev, int flag, int mode, struct proc *p) } static int -zsclose(dev_t dev, int flag, int mode, struct proc *p) +zsclose(dev_t dev, int flag, int mode, struct thread *td) { struct zs_softc *sc = ZS_SOFTC(minor(dev)); struct tty *tp; @@ -332,7 +332,7 @@ zsclose(dev_t dev, int flag, int mode, struct proc *p) } static int -zsioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +zsioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { struct zs_softc *sc = ZS_SOFTC(minor(dev)); struct tty *tp; @@ -343,7 +343,7 @@ zsioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) tp = ZS_SOFTC(minor(dev))->tp; - error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); + error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, td); if (error != ENOIOCTL) return (error); |
